Controlador de Personaje en Primera Persona: Construyendo desde Cero en Unity 🚶‍♂️ FPS Essentials

¡Hola, futuros desarrolladores de juegos! 👋 ¿Listos para darle vida a vuestros protagonistas en un mundo 3D? En este tutorial, nos sumergiremos en la creación de un controlador de personaje en primera persona (FPS) desde cero en Unity. Este es un componente fundamental para cualquier juego que se juegue desde la perspectiva del personaje, y aprender a construirlo os dará un control inmenso sobre la experiencia de vuestros jugadores.

Construiremos un sistema que incluye movimiento básico (adelante, atrás, izquierda, derecha, saltar), control de cámara con el ratón y manejo de colisiones. ¡Manos a la obra!

🎯 Objetivos del Tutorial

Al final de este tutorial, habréis logrado:

• Configurar un objeto de jugador básico para el FPS.
• Implementar movimiento horizontal usando el CharacterController de Unity.
• Añadir funcionalidad de salto con gravedad simulada.
• Desarrollar un script para controlar la cámara del jugador con el ratón.
• Integrar la cámara con el movimiento del personaje.
• Entender los principios de detección de colisiones en un controlador FPS.

🛠️ Requisitos Previos

Antes de empezar, asegúrate de tener lo siguiente:

• Unity Hub y Unity Editor (versión 2021.x o superior recomendada) instalados.
• Un nuevo proyecto de Unity 3D.
• Un entorno de desarrollo para C# (Visual Studio o Rider).

🚀 Configuración del Proyecto y Escena

Primero, necesitamos preparar nuestra escena para el personaje. Empezaremos con un terreno simple y algunos obstáculos.

Paso 1: Crear una Nueva Escena y Terreno

1. Abre tu proyecto Unity.
2. Ve a File > New Scene.
3. En la jerarquía, haz clic derecho y selecciona 3D Object > Terrain. Esto nos dará un suelo sobre el que movernos.
4. Opcionalmente, puedes añadir algunos cubos (3D Object > Cube) y escalarlos para que actúen como obstáculos y rampas.

Paso 2: Crear el Objeto del Jugador (Player Object)

Crearemos un objeto vacío que servirá como nuestro Player principal y contendrá la lógica de movimiento.

1. En la jerarquía, haz clic derecho y selecciona Create Empty.
2. Renómbralo a Player.
3. Asegúrate de que su posición sea (0, 1, 0) para que esté ligeramente por encima del terreno.

Paso 3: Añadir el CharacterController

El CharacterController es un componente de Unity diseñado específicamente para mover personajes en juegos en tercera o primera persona sin lidiar con la física compleja de un Rigidbody. Maneja colisiones de forma muy eficiente.

1. Selecciona el objeto Player en la jerarquía.
2. En el Inspector, haz clic en Add Component.
3. Busca y selecciona Character Controller.

🚶‍♂️ Implementando el Movimiento del Jugador

Ahora vamos a escribir el script que controlará el movimiento de nuestro personaje.

Paso 1: Crear el Script de Movimiento

1. En la carpeta Assets, crea una nueva carpeta llamada Scripts.
2. Dentro de Scripts, haz clic derecho y selecciona Create > C# Script.
3. Nómbralo PlayerMovement.
4. Arrastra y suelta este script al objeto Player en la jerarquía.

Paso 2: Escribir el Código de Movimiento Básico

Abre el script PlayerMovement y reemplaza su contenido con lo siguiente:

using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float moveSpeed = 5f; // Velocidad de movimiento del personaje
    public float jumpForce = 8f; // Fuerza del salto
    public float gravity = -9.81f; // Gravedad aplicada

    private CharacterController controller; // Referencia al CharacterController
    private Vector3 velocity; // Vector de velocidad para la gravedad y salto
    private bool isGrounded; // Verdadero si el personaje está en el suelo

    // Referencia al suelo para la detección de isGrounded
    public Transform groundCheck;
    public float groundDistance = 0.4f; // Radio de la esfera de detección del suelo
    public LayerMask groundMask; // Capa que se considera 'suelo'

    void Start()
    {
        controller = GetComponent<CharacterController>();
    }

    void Update()
    {
        // 1. Detección de suelo
        isGrounded = Physics.CheckSphere(groundCheck.position, groundDistance, groundMask);

        if (isGrounded && velocity.y < 0)
        {
            velocity.y = -2f; // Pequeño valor negativo para asegurar que se 'pega' al suelo
        }

        // 2. Input de movimiento horizontal
        float x = Input.GetAxis("Horizontal");
        float z = Input.GetAxis("Vertical");

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move * moveSpeed * Time.deltaTime);

        // 3. Salto
        if (Input.GetButtonDown("Jump") && isGrounded)
        {
            velocity.y = Mathf.Sqrt(jumpForce * -2f * gravity);
        }

        // 4. Aplicar gravedad
        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}

Paso 3: Configurar el Script y el Detección de Suelo en Unity

1. groundCheck: En la jerarquía, haz clic derecho en el objeto Player y selecciona Create Empty. Renómbralo a GroundCheck. Posiciónalo justo debajo del centro del CharacterController (por ejemplo, Y = -1.0 si tu CharacterController tiene Height = 2). Este objeto se usará para detectar si el jugador está en el suelo. Arrastra este objeto al campo Ground Check en el script PlayerMovement del Inspector.
2. LayerMask: Crea una nueva capa para el suelo. Ve a Layers (parte superior derecha del editor) > Add Layer.... Añade una capa llamada Ground. Selecciona tu Terrain y cualquier otro objeto que deba considerarse suelo, y asígnales esta nueva capa.
3. En el Inspector del PlayerMovement script, selecciona la capa Ground en el campo Ground Mask.

    void OnDrawGizmosSelected()
    {
        if (groundCheck == null) return;
        Gizmos.color = Color.red;
        Gizmos.DrawSphere(groundCheck.position, groundDistance);
    }

Progreso:

👁️ Control de Cámara en Primera Persona

Un buen controlador FPS necesita una cámara que siga la mirada del jugador con el ratón.

Paso 1: Crear la Cámara del Jugador

1. En la jerarquía, haz clic derecho en el objeto Player y selecciona Camera. Esto creará una cámara como hijo del jugador.
2. Renómbrala a PlayerCamera.
3. Posiciónala en (0, 0.7, 0) aproximadamente (o donde consideres que deben estar los ojos del personaje).

Paso 2: Crear el Script de Control de Cámara

1. En la carpeta Scripts, crea un nuevo script C# llamado MouseLook.
2. Arrastra y suelta este script al objeto PlayerCamera.

Paso 3: Escribir el Código del MouseLook

Abre el script MouseLook y reemplaza su contenido con lo siguiente:

using UnityEngine;

public class MouseLook : MonoBehaviour
{
    public float mouseSensitivity = 100f; // Sensibilidad del ratón

    public Transform playerBody; // Referencia al cuerpo del jugador (objeto Player)

    float xRotation = 0f; // Rotación actual en el eje X (arriba/abajo)

    void Start()
    {
        // Bloquear y ocultar el cursor del ratón
        Cursor.lockState = CursorLockMode.Locked;
    }

    void Update()
    {
        // 1. Obtener input del ratón
        float mouseX = Input.GetAxis("Mouse X") * mouseSensitivity * Time.deltaTime;
        float mouseY = Input.GetAxis("Mouse Y") * mouseSensitivity * Time.deltaTime;

        // 2. Rotación vertical de la cámara (mirar arriba/abajo)
        xRotation -= mouseY;
        xRotation = Mathf.Clamp(xRotation, -90f, 90f); // Limitar la rotación vertical

        transform.localRotation = Quaternion.Euler(xRotation, 0f, 0f);

        // 3. Rotación horizontal del cuerpo del jugador (mirar izquierda/derecha)
        playerBody.Rotate(Vector3.up * mouseX);
    }
}

Paso 4: Configurar el Script MouseLook

1. Selecciona el objeto PlayerCamera en la jerarquía.
2. En el Inspector, arrastra el objeto Player desde la jerarquía al campo Player Body del script MouseLook.

Ahora, cuando ejecutes el juego, deberías poder mover el personaje con W, A, S, D y Espacio, y controlar la vista con el ratón. ¡Felicidades! 🎉

✨ Pulido y Consideraciones Avanzadas

Ya tenemos un controlador funcional, pero siempre hay espacio para mejorar y añadir más funcionalidades.

Velocidad Variable y Sprint

Para añadir la funcionalidad de sprint, podemos modificar el moveSpeed cuando se presiona una tecla específica.

1. Abre el script PlayerMovement.
2. Añade una variable para la velocidad de sprint y una para la velocidad normal:

    public float walkSpeed = 5f;
    public float sprintSpeed = 10f;

3. Modifica el método Update para cambiar la velocidad:

    void Update()
    {
        // ... (código existente)

        // Determinar la velocidad actual
        float currentMoveSpeed = Input.GetKey(KeyCode.LeftShift) ? sprintSpeed : walkSpeed;

        Vector3 move = transform.right * x + transform.forward * z;
        controller.Move(move * currentMoveSpeed * Time.deltaTime);

        // ... (código existente)
    }

Detección de Pendientes (Slopes)

El CharacterController maneja las pendientes automáticamente hasta cierto punto (Slope Limit). Para un control más fino, o para evitar deslizarse por pendientes suaves, puedes implementar una lógica adicional, aunque para la mayoría de los casos el CharacterController es suficiente.

Interacciones con el Entorno (Raycasting)

Para permitir que el jugador interactúe con objetos (abrir puertas, recoger ítems), puedes usar Raycasting desde la cámara del jugador.

1. Abre el script MouseLook o crea uno nuevo para interacción.
2. Añade un Raycast en Update:

    // Dentro de Update en MouseLook o un nuevo script de interacción
    void CheckForInteraction()
    {
        if (Physics.Raycast(transform.position, transform.forward, out RaycastHit hit, 3f))
        {
            // Si el raycast golpea algo a una distancia de 3 unidades
            // hit.collider.gameObject es el objeto golpeado
            Debug.Log("Mirando a: " + hit.collider.name);
            // Puedes añadir lógica para interactuar si se presiona un botón (e.g., Input.GetKeyDown(KeyCode.E))
        }
    }

    void Update()
    {
        // ... (código existente de MouseLook)
        CheckForInteraction(); // Llama a esta función en cada frame
    }

Consideraciones sobre Física

Es importante entender que el CharacterController no usa el motor de física completo como un Rigidbody. Esto significa que no reacciona a fuerzas externas ni colisiones de la misma manera. Si necesitas interacciones físicas complejas (ser empujado por explosiones, empujar otros objetos físicos), podrías considerar usar un Rigidbody y manejar el movimiento manualmente (evitando la interpolación y usando MovePosition/MoveRotation para un control fino) o un Rigidbody en modo cinemático con su propio script de movimiento.

Dificultad: Principiante Intermedio

💡 Conclusión

¡Felicidades! Has construido un controlador de personaje en primera persona robusto y personalizable en Unity. Esta base es crucial para desarrollar cualquier tipo de juego FPS, desde shooters hasta juegos de aventura y exploración.

Recuerda que este es solo el punto de partida. Puedes expandir este controlador con muchas más funcionalidades: agacharse, deslizarse, escalar, animaciones, sonido de pasos, etc. La clave es entender los principios básicos y construir sobre ellos. ¡Ahora sal y crea tu propio mundo interactivo!

Si tienes alguna pregunta o te encuentras con algún problema, no dudes en revisar la documentación oficial de Unity sobre CharacterController y Input System.

¡Feliz desarrollo de juegos! 🎮