Movimento avançado do jogador em Unity

Neste tutorial, exploraremos mecânicas avançadas de movimento do jogador em Unity, incluindo correr, agachar e um sistema de câmera suave. Esses recursos adicionam profundidade e polimento aos controles do jogador, aprimorando a experiência geral do jogo. Usaremos o sistema de física do Unity para movimentos e interações realistas.

Preparando a cena

Antes de começarmos a codificar, vamos configurar uma cena básica com um objeto de jogador e uma câmera:

1. Crie um novo projeto Unity.
2. Na Hierarquia, crie um Cubo 3D, renomeie-o para Jogador e dimensione-o para se assemelhar a um personagem (por exemplo, X: 1, Y: 2, Z: 1).
3. Adicione um componente Rigidbody ao Player e defina a propriedade Interpolate como Interpolate para uma física suave.
4. Adicione um componente Capsule Collider, ajuste sua altura e raio para corresponder ao modelo do jogador.
5. Crie um GameObject vazio, nomeie-o CameraRig e anexe uma Camera a ele. Posicione a câmera atrás e um pouco acima do jogador.
6. Faça do CameraRig um filho do objeto Player para seguir seus movimentos.

Implementando o movimento avançado do jogador

Implementaremos um script que lida com movimentos básicos, corrida, agachamento e rotação suave da câmera.

Script de movimento do jogador

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;
        }
    }
}

Principais características e explicação

Controle de movimento e velocidade

O script usa Rigidbody do Unity para mover o jogador, permitindo interações baseadas em física. A velocidade varia com base em se o jogador está andando, correndo ou agachado. O agachamento é alternado com a tecla LeftControl, e o sprint ocorre enquanto segura a tecla LeftShift.

Pular

O método HandleJumping aplica uma força para cima quando o jogador pressiona o botão de pulo (padrão: barra de espaço), desde que o jogador esteja no chão. A detecção de chão é tratada verificando colisões com objetos marcados com "Ground".

Controle de câmera

A rotação da câmera é controlada usando o mouse, fornecendo uma perspectiva de primeira ou terceira pessoa com base no posicionamento da câmera. O ângulo de visão é fixado para evitar inclinação excessiva, o que pode desorientar os jogadores.

Conclusão

Este tutorial fornece uma base para movimentação avançada do jogador em Unity, cobrindo vários aspectos como controle baseado em física, corrida, agachamento e gerenciamento de câmera. Essas técnicas podem ser ainda mais personalizadas e expandidas para se adequarem a diferentes gêneros e estilos de jogo, aprimorando a experiência do jogador com controles responsivos e realistas.

Lembre-se, o movimento do jogador é um aspecto crítico da jogabilidade e deve ser ajustado cuidadosamente para garantir uma experiência satisfatória ao jogador. Experimente diferentes valores e recursos para encontrar a melhor configuração para seu projeto.