En este tutorial, construiremos desde cero un sistema de control de personaje en primera persona dentro de Unity. Este sistema nos permitirá mover nuestro personaje con las teclas WASD y controlar la visión con el ratón. Es perfecto para desarrolladores que están comenzando con Unity o desean reforzar sus conceptos fundamentales.

Preparación del Proyecto y Escena

Creación de un Nuevo Proyecto

Abre Unity Hub y selecciona "Nuevo". Elige la plantilla Proyecto 3D y nombra tu proyecto (por ejemplo, "MiJuegoFPS"). Haz clic en "Crear" y espera a que el editor de Unity cargue completamente.

Importación de Assets Opcionales

Para enriquecer nuestro entorno de prueba, podemos importar algunos recursos gratuitos:

• Busca en la Asset Store "Low Poly Simple Nature Pack" y descárgalo.
• Una vez descargado, ve a Ventana -> Gestión de Assets -> Mis Assets, encuentra el paquete y haz clic en "Importar" todo su contenido.
• Después de importar, localiza el paquete en la ventana de Proyecto dentro de la carpeta Assets, entra en la carpeta Scenes y abre una de las escenas de ejemplo (como Demo). La modificaremos para nuestros fines.

Organización de la Escena

1. En la ventana de Jerarquía, haz clic derecho y selecciona Crear Objeto Vacío, nómbralo "Entorno".
2. Selecciona todos los objetos de la escena excepto la Main Camera (cámara principal) y arrástralos debajo del objeto Entorno para mantener una estructura organizada.

Creación del Personaje Jugador

Construcción del Modelo del Jugador

1. En la ventana de Jerarquía, haz clic derecho -> Objeto 3D -> Cápsula, crea una cápsula y renómbrala como "Jugador".
2. Selecciona Jugador, en el panel Inspector busca el componente Transform, haz clic en los tres puntos del ángulo superior derecho y selecciona Restablecer. Luego, ajusta su posición en el eje Y a un valor ligeramente superior (por ejemplo, 1) para evitar que quede incrustado en el suelo.
3. Elimina el componente Capsule Collider (colisionador de cápsula) del objeto Jugador, ya que usaremos un componente más especializado.

Adición del Controlador de Personaje

1. Para el objeto Jugador, añade el componente: haz clic en Añadir Componente, busca y añade Character Controller.
2. Arrastra la Main Camera (cámara principal) para que sea un objeto hijo del objeto Jugador.
3. Selecciona Main Camera, restablece su Transform y ajusta su posición local (Local Position) a aproximadamente (0, 1.6, 0) para simular la altura de los ojos de una persona.

Desarrollo de Scripts de Control Central

Crearemos dos scripts principales para implementar la funcionalidad: ControladorCamara (para controlar la visión) y ControladorJugador (para controlar el movimiento).

Control de Vista en Primera Persona (ControladorCamara)

Creación del Script

1. En la ventana de Proyecto, haz clic derecho -> Crear -> Carpeta, nómbrala "Scripts".
2. Dentro de la carpeta Scripts, haz clic derecho -> Crear -> Script C#, nómbralo "ControladorCamara".
3. Arrastra el script ControladorCamara a la Main Camera para adjuntarlo como componente.

Implementación del Código de Vista

Haz doble clic en el script para abrirlo y escribe el siguiente código:

csharp

using UnityEngine;

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

    // Acumula el ángulo total del movimiento vertical del ratón
    private float rotacionX = 0f;

    // Referencia al objeto del jugador (cápsula) para controlar la rotación horizontal
    public Transform cuerpoJugador;

    void Start()
    {
        // Bloquea el cursor del ratón en el centro de la ventana y lo oculta
        Cursor.lockState = CursorLockMode.Locked;
    }

    void Update()
    {
        // Obtener el movimiento del ratón (incremento por frame) multiplicado por la sensibilidad
        float movimientoX = Input.GetAxis("Mouse X") * sensibilidadRaton * Time.deltaTime;
        float movimientoY = Input.GetAxis("Mouse Y") * sensibilidadRaton * Time.deltaTime;

        // Rotación vertical (mirar arriba/abajo, control de cámara)
        // Acumula el ángulo de rotación (restamos movimientoY porque al mover el ratón hacia arriba, la cámara debe mirar hacia abajo)
        rotacionX -= movimientoY;
        // Mathf.Clamp limita el ángulo de rotación entre -70 y 70 grados para evitar rotaciones excesivas
        rotacionX = Mathf.Clamp(rotacionX, -70f, 70f);

        // Aplica la rotación calculada a la rotación local de la cámara
        transform.localRotation = Quaternion.Euler(rotacionX, 0f, 0f);

        // Rotación horizontal (mirar izquierda/derecha, control del cuerpo del jugador)
        // Rota el cuerpo del jugador alrededor del eje Y del espacio mundial
        cuerpoJugador.Rotate(Vector3.up * movimientoX);
    }
}

Análisis del código:

• Input.GetAxis("Mouse X/Y") obtiene el incremento del movimiento del ratón.
• La variable rotacionX acumula la rotación vertical y es limitada por Mathf.Clamp para evitar que la cámara gire completamente.
• La rotación vertical de la cámara es una rotación local, mientras que la rotación horizontal del jugador es una rotación mundial, que es la implementación estándar para controles en primera persona.

Asociación del Script

Regresa al editor de Unity, selecciona Main Camera. En el componente del script ControladorCamara, arrastra el objeto Jugador desde la ventana de Jerarquía al campo Cuerpo Jugador para completar la asociación.

Control de Movimiento y Física del Jugador (ControladorJugador)

Creación del Script

1. En la carpeta Scripts, crea un nuevo script C# y nómbralo "ControladorJugador".
2. Arrastra este script al objeto Jugador.

Implementación del Código de Movimiento

Haz doble clic en el script ControladorJugador y añade el siguiente código:

csharp

using UnityEngine;

public class ControladorJugador : MonoBehaviour
{
    // Velocidad de movimiento
    public float velocidadCaminar = 6f;
    // Fuerza de salto
    public float fuerzaSalto = 8f;
    // Aceleración de gravedad
    public float gravedad = -9.81f;

    // Detección del suelo
    public Transform puntoDeteccionSuelo;      // Posición del punto de detección (objeto vacío)
    public float radioDeteccion = 0.4f;       // Radio de la esfera de detección
    public LayerMascara capaSuelo;            // Define qué capas se consideran "suelo"

    private CharacterController controlador;
    private Vector3 velocidad;                // Almacena el vector de velocidad y movimiento
    private bool enSuelo;                     // Indica si está en el suelo

    void Start()
    {
        // Obtener el componente CharacterController
        controlador = GetComponent<CharacterController>();
    }

    void Update()
    {
        // Detección del suelo
        // Crea una esfera en la posición del punto de detección para verificar colisiones con la capa del suelo
        enSuelo = Physics.CheckSphere(puntoDeteccionSuelo.position, radioDeteccion, capaSuelo);

        // Si está en el suelo y está cayendo, establece la velocidad vertical en un valor negativo pequeño
        if (enSuelo && velocidad.y < 0)
        {
            velocidad.y = -2f; // Un valor negativo pequeño para asegurar que el personaje siempre tenga una tendencia descendente
        }

        // Obtener entrada de movimiento (WASD)
        float horizontal = Input.GetAxis("Horizontal"); // A/D o teclas de dirección izquierda/derecha
        float vertical = Input.GetAxis("Vertical");     // W/S o teclas de dirección arriba/abajo

        // Calcular dirección de movimiento
        // Convierte la dirección de entrada del espacio local al mundial: adelante * entrada vertical + derecha * entrada horizontal
        Vector3 movimiento = transform.right * horizontal + transform.forward * vertical;
        // Usa el método CharacterController.Move para mover el personaje (multiplicado por velocidad y tiempo)
        controlador.Move(movimiento * velocidadCaminar * Time.deltaTime);

        // Lógica de salto
        // Si está en el suelo y presiona la tecla de salto (espacio por defecto)
        if (Input.GetButtonDown("Jump") && enSuelo)
        {
            velocidad.y = Mathf.Sqrt(fuerzaSalto * -2f * gravedad); // Calcula la velocidad inicial del salto según la fórmula física
        }

        // Aplicar gravedad
        // Calcula la velocidad vertical según la fórmula v = v0 + gt
        velocidad.y += gravedad * Time.deltaTime;
        // Mueve el personaje (solo en el eje Y)
        controlador.Move(velocidad * Time.deltaTime);
    }
}

Análisis del código:

• Utilizamos el método CharacterController.Move(), que acepta un vector de dirección y maneja las colisiones.
• La detección del suelo es crucial para el salto y el reinicio de la gravedad. Creamos una esfera de detección debajo del personaje usando Physics.CheckSphere.
• La velocidad inicial del salto se calcula mediante la fórmula física v = √(2gh) para que la altura del salto sea coherente con la gravedad.
• La aplicación de la gravedad y la velocidad se realiza en Update, multiplicando por Time.deltaTime para garantizar independencia del frame rate.

Configuración del Punto de Detección del Suelo

1. En la ventana de Jerarquía, selecciona el objeto Jugador, haz clic derecho -> Crear Objeto Vacío, crea un objeto hijo y nómbralo "PuntoDeteccionSuelo".
2. Usa la herramienta de movimiento para posicionar el objeto PuntoDeteccionSuelo en el centro inferior de la cápsula del Jugador (por ejemplo, Y=0.05 aproximadamente).
3. Selecciona el objeto Jugador, en el componente del script ControladorJugador, arrastra el objeto PuntoDeteccionSuelo al campo Punto Deteccion Suelo.
4. Configura Radio Deteccion en 0.4 aproximadamente.

Configuración de Capas

1. En el campo Capa Suelo debajo de Punto Deteccion Suelo, haz clic en el menú desplegable y selecciona Ventana de Capas en la parte inferior de Añadir Capa....
2. En el espacio en blanco junto a Capa de Usuario 8, escribe "Suelo" y haz clic en el espacio en blanco para confirmar.
3. Regresa al componente ControladorJugador, haz clic nuevamente en el menú desplegable Capa Suelo y selecciona la capa "Suelo" que acabamos de crear.
4. Selecciona el objeto Entorno (el objeto padre que contiene todos los elementos de la escena), en el menú desplegable de capas, selecciónala como "Suelo". Cuando aparezca el mensaje "¿Cambiar capas de los objetos hijos?", haz clic en "Sí, cambiar hijos".

Prueba y Ajuste

¡Todos los ajustes prnicipales están completados! Haz clic en el botón Reproducir en la parte superior del editor de Unity. En la ventana del juego, podrás:

• Moverte: Usa las teclas WASD.
• Controlar la visión: Mueve el ratón.
• Saltar: Presiona la barra espaciadora.

Deberías experimentar un control de personaje en primera persona fluido, con caída por gravedad, detección del suelo y funcionalidad de salto. Si la velocidad de movimiento o la sensibilidad del ratón no te parecen adecuadas, puedes ajustar las variables públicas en los componentes ControladorJugador y ControladorCamara en el panel Inspector.

Conclusión y Posibles Extensiones

Con este tutorial, has construido con éxito el núcleo de un sistema de control de personaje en primera persona estándar. Este es solo un punto de partida, y sobre esta base puedes continuar expandiendo el sistema, por ejemplo:

• Añadir función de carrera: Detecta la tecla Shift izquierda para aumentar la velocidad de movimiento.
• Implementar un sprint: Aumenta significativamente la velocidad por un corto tiempo con un período de enfriamiento.
• Incluir sonidos de pasos: Reproduce efectos de sonido al moverse.
• Desarrollar un sistema de interacción: Implementa funciones como abrir puertas, recoger objetos, etc.

¡Espero que este tutorial te sea de gran ayuda!