Zaawansowany ruch gracza w Unity

W tym samouczku przyjrzymy się zaawansowanym mechanizmom ruchu gracza w Unity, w tym sprintowi, kucaniu i płynnemu systemowi kamery. Te funkcje dodają głębi i polerowania do sterowania graczem, poprawiając ogólne wrażenia z rozgrywki. Wykorzystamy system fizyki Unity do realistycznego ruchu i interakcji.

Przygotowanie sceny

Zanim przejdziemy do kodowania, skonfigurujmy podstawową scenę z obiektem gracza i kamerą:

1. Utwórz nowy projekt Unity.
2. W hierarchii utwórz kostkę 3D, zmień jej nazwę na Player i przeskaluj ją tak, aby przypominała postać (np. X: 1, Y: 2, Z: 1).
3. Dodaj komponent Rigidbody do odtwarzacza i ustaw właściwość Interpolate na Interpolate, aby uzyskać płynną fizykę.
4. Dodaj komponent Capsule Collider, dostosuj jego wysokość i promień, aby pasował do modelu gracza.
5. Utwórz pusty GameObject, nazwij go CameraRig i dołącz do niego Camera. Umieść kamerę za i lekko nad graczem.
6. Ustaw CameraRig jako obiekt podrzędny obiektu Player, aby śledzić jego ruchy.

Wdrażanie zaawansowanego ruchu gracza

Wdrożymy skrypt obsługujący podstawowe ruchy, sprint, kucanie i płynny obrót kamery.

Skrypt ruchu gracza

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

Główne cechy i wyjaśnienie

Kontrola ruchu i prędkości

Skrypt używa Unity's Rigidbody do poruszania graczem, umożliwiając interakcje oparte na fizyce. Prędkość zmienia się w zależności od tego, czy gracz idzie, sprintuje czy kuca. Kucanie jest przełączane za pomocą klawisza LeftControl, a sprint odbywa się podczas przytrzymywania klawisza LeftShift.

Skoki

Metoda HandleJumping stosuje siłę skierowaną w górę, gdy gracz naciska przycisk skoku (domyślnie: spacja), zakładając, że gracz jest uziemiony. Wykrywanie uziemienia jest obsługiwane przez sprawdzanie kolizji z obiektami oznaczonymi "Ground".

Sterowanie kamerą

Obrót kamery jest kontrolowany za pomocą myszy, zapewniając perspektywę pierwszoosobową lub trzecioosobową w zależności od położenia kamery. Kąt patrzenia jest ograniczony, aby zapobiec nadmiernemu przechylaniu, które może dezorientować graczy.

Wniosek

Ten samouczek zapewnia podstawy dla zaawansowanego ruchu gracza w Unity, obejmując różne aspekty, takie jak sterowanie oparte na fizyce, sprint, kucanie i zarządzanie kamerą. Te techniki można dalej dostosowywać i rozszerzać, aby pasowały do ​​różnych gatunków i stylów gier, zwiększając wrażenia gracza dzięki responsywnym i realistycznym kontrolom.

Pamiętaj, że ruch gracza jest krytycznym aspektem rozgrywki i powinien być starannie dostrojony, aby zapewnić graczom satysfakcjonujące wrażenia. Eksperymentuj z różnymi wartościami i funkcjami, aby znaleźć najlepszą konfigurację dla swojego projektu.