Movimiento avanzado del jugador en Unity

En este tutorial, exploraremos las mecánicas avanzadas de movimiento del jugador en Unity, que incluyen correr, agacharse y un sistema de cámara fluido. Estas características agregan profundidad y refinamiento a los controles del jugador, lo que mejora la experiencia de juego general. Usaremos el sistema de física de Unity para lograr movimientos e interacciones realistas.

Preparando la escena

Antes de sumergirnos en la codificación, configuremos una escena básica con un objeto jugador y una cámara:

1. Crea un nuevo proyecto Unity.
2. En la Jerarquía, crea un Cubo 3D, cámbiale el nombre a Player y escálalo para que se parezca a un personaje (por ejemplo, X: 1, Y: 2, Z: 1).
3. Agregue un componente Rigidbody al reproductor y configure la propiedad Interpolate en Interpolate para una física suave.
4. Agregue un componente Capsule Collider, ajuste su altura y radio para que coincidan con el modelo del jugador.
5. Crea un GameObject vacío, nómbralo CameraRig y adjúntale una Camera. Coloca la cámara detrás y ligeramente por encima del jugador.
6. Convierte CameraRig en un elemento secundario del objeto Player para seguir sus movimientos.

Implementación de movimientos avanzados de jugadores

Implementaremos un script que maneja el movimiento básico, correr, agacharse y la rotación suave de la cámara.

Guión de movimiento del jugador

using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float walkSpeed = 5f;
    public float sprintSpeed = 10f;
    public float crouchSpeed = 2.5f;
    public float jumpForce = 5f;
    public float gravity = 20f;

    public Transform cameraTransform;
    public float lookSensitivity = 2f;
    public float maxLookAngle = 80f;

    private Rigidbody rb;
    private float currentSpeed;
    private bool isCrouching = false;
    private bool isGrounded = false;

    private void Start()
    {
        rb = GetComponent();
        rb.freezeRotation = true; // Prevent the Rigidbody from rotating
    }

    private void Update()
    {
        HandleMovement();
        HandleJumping();
        HandleCrouching();
        HandleCameraRotation();
    }

    private void HandleMovement()
    {
        float moveHorizontal = Input.GetAxis("Horizontal");
        float moveVertical = Input.GetAxis("Vertical");

        Vector3 move = transform.right * moveHorizontal + transform.forward * moveVertical;
        move = move.normalized * currentSpeed * Time.deltaTime;

        Vector3 velocity = rb.velocity;
        velocity.x = move.x;
        velocity.z = move.z;
        rb.velocity = velocity;
    }

    private void HandleJumping()
    {
        if (Input.GetButtonDown("Jump") && isGrounded)
        {
            rb.velocity = new Vector3(rb.velocity.x, jumpForce, rb.velocity.z);
        }
    }

    private void HandleCrouching()
    {
        if (Input.GetKeyDown(KeyCode.LeftControl))
        {
            isCrouching = !isCrouching;
            currentSpeed = isCrouching ? crouchSpeed : walkSpeed;
            transform.localScale = new Vector3(1, isCrouching ? 0.5f : 1, 1);
        }

        if (Input.GetKey(KeyCode.LeftShift) && !isCrouching)
        {
            currentSpeed = sprintSpeed;
        }
        else if (!isCrouching)
        {
            currentSpeed = walkSpeed;
        }
    }

    private void HandleCameraRotation()
    {
        float mouseX = Input.GetAxis("Mouse X") * lookSensitivity;
        float mouseY = Input.GetAxis("Mouse Y") * lookSensitivity;

        Vector3 rotation = cameraTransform.localEulerAngles;
        rotation.y += mouseX;
        rotation.x -= mouseY;
        rotation.x = Mathf.Clamp(rotation.x, -maxLookAngle, maxLookAngle);

        cameraTransform.localEulerAngles = rotation;
    }

    private void OnCollisionStay(Collision collision)
    {
        if (collision.gameObject.CompareTag("Ground"))
        {
            isGrounded = true;
        }
    }

    private void OnCollisionExit(Collision collision)
    {
        if (collision.gameObject.CompareTag("Ground"))
        {
            isGrounded = false;
        }
    }
}

Características principales y explicación

Control de movimiento y velocidad

El script utiliza Rigidbody de Unity para mover al jugador, lo que permite interacciones basadas en la física. La velocidad varía en función de si el jugador está caminando, corriendo o agachado. La posición agachada se activa con la tecla LeftControl y la velocidad se activa mientras se mantiene presionada la tecla LeftShift.

Saltar

El método HandleJumping aplica una fuerza hacia arriba cuando el jugador presiona el botón de salto (predeterminado: barra espaciadora), siempre que el jugador esté en el suelo. La detección del suelo se controla verificando si hay colisiones con objetos etiquetados como "Ground".

Control de cámara

La rotación de la cámara se controla con el ratón, lo que permite una perspectiva en primera o tercera persona según la posición de la cámara. El ángulo de visión está limitado para evitar una inclinación excesiva, que puede desorientar a los jugadores.

Conclusión

Este tutorial proporciona una base para el movimiento avanzado del jugador en Unity, y cubre varios aspectos como el control basado en la física, el sprint, el agacharse y el manejo de la cámara. Estas técnicas se pueden personalizar y ampliar para adaptarse a diferentes géneros y estilos de juego, lo que mejora la experiencia del jugador con controles realistas y con capacidad de respuesta.

Recuerde que el movimiento del jugador es un aspecto fundamental del juego y debe ajustarse con cuidado para garantizar una experiencia satisfactoria. Experimente con diferentes valores y características para encontrar la mejor configuración para su proyecto.