Mișcare avansată a jucătorului în Unity

În acest tutorial, vom explora mecanismele avansate de mișcare a jucătorilor în Unity, inclusiv sprintul, ghemuirea și un sistem de cameră neted. Aceste caracteristici adaugă profunzime și luciu controalelor jucătorilor, îmbunătățind experiența generală de joc. Vom folosi sistemul fizic al Unity pentru mișcări și interacțiuni realiste.

Configurarea scenei

Înainte de a ne aprofunda în codificare, să configuram o scenă de bază cu un obiect player și o cameră:

  1. Creați un nou proiect Unity.
  2. În Ierarhie, creați un cub 3D, redenumiți-l în Player și scalați-l pentru a semăna cu un personaj (de exemplu, X: 1, Y: 2, Z: 1).
  3. Adăugați o componentă Rigidbody la Player și setați proprietatea Interpolate la Interpolate pentru o fizică fluidă.
  4. Adăugați o componentă Capsule Collider, ajustați-i înălțimea și raza pentru a se potrivi cu modelul jucătorului.
  5. Creați un GameObject gol, denumiți-l CameraRig și atașați-i un Camera. Poziționați camera în spatele și ușor deasupra playerului.
  6. Faceți din CameraRig un copil al obiectului Player pentru a-i urmări mișcările.

Implementarea mișcării avansate a jucătorului

Vom implementa un script care se ocupă de mișcarea de bază, sprintul, ghemuirea și rotirea lină a camerei.

Script PlayerMovement

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

Caracteristici cheie și explicații

Controlul mișcării și al vitezei

Scriptul folosește Rigidbody de la Unity pentru a muta jucătorul, permițând interacțiuni bazate pe fizică. Viteza variază în funcție de faptul că jucătorul merge, sprintează sau se ghemuiește. Ghemuirea este comutată cu tasta LeftControl, iar sprintul are loc în timp ce apăsați tasta LeftShift.

Jumping

Metoda HandleJumping aplică o forță ascendentă atunci când jucătorul apasă butonul de salt (implicit: bara de spațiu), având în vedere că jucătorul este legat la pământ. Detectarea solului este gestionată prin verificarea coliziunilor cu obiecte etichetate "Ground".

Controlul camerei

Rotirea camerei este controlată cu ajutorul mouse-ului, oferind o perspectivă la persoana întâi sau la persoana a treia bazată pe poziționarea camerei. Unghiul de privire este fixat pentru a preveni înclinarea excesivă, care poate dezorienta jucătorii.

Concluzie

Acest tutorial oferă o bază pentru mișcarea avansată a jucătorilor în Unity, acoperind diverse aspecte precum controlul bazat pe fizică, sprintul, ghemuirea și gestionarea camerei. Aceste tehnici pot fi personalizate și extinse în continuare pentru a se potrivi cu diferite genuri și stiluri de joc, îmbunătățind experiența jucătorului cu comenzi receptive și realiste.

Amintiți-vă, mișcarea jucătorului este un aspect critic al jocului și ar trebui să fie reglată cu atenție pentru a asigura o experiență satisfăcătoare pentru jucător. Experimentați cu diferite valori și caracteristici pentru a găsi cea mai bună configurație pentru proiectul dvs.