Avancerad spelarrörelse i Unity

I den här handledningen kommer vi att utforska avancerad spelarrörelsemekanik i Unity, inklusive sprint, hukning och ett smidigt kamerasystem. Dessa funktioner lägger till djup och polering till spelarkontrollerna, vilket förbättrar den övergripande spelupplevelsen. Vi kommer att använda Unitys fysiksystem för realistiska rörelser och interaktioner.

Ställa in scenen

Innan vi dyker in i kodning, låt oss sätta upp en grundläggande scen med ett spelarobjekt och en kamera:

1. Skapa ett nytt Unity-projekt.
2. Skapa en 3D-kub i hierarkin, byt namn på den till Player och skala den för att likna en karaktär (t.ex. X: 1, Y: 2, Z: 1).
3. Lägg till en Rigidbody-komponent till spelaren och ställ in egenskapen Interpolate till Interpolate för smidig fysik.
4. Lägg till en Capsule Collider-komponent, justera dess höjd och radie för att matcha spelarmodellen.
5. Skapa ett tomt GameObject, döp det till CameraRig och fäst en Camera till det. Placera kameran bakom och något ovanför spelaren.
6. Gör CameraRig till ett barn till spelaren som vill följa dess rörelser.

Implementering av avancerad spelarrörelse

Vi kommer att implementera ett manus som hanterar grundläggande rörelser, sprint, hukning och smidig kamerarotation.

PlayerMovement Script

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

Nyckelfunktioner och förklaring

Rörelse och hastighetskontroll

Skriptet använder Unitys Rigidbody för att flytta spelaren, vilket möjliggör fysikbaserade interaktioner. Hastigheten varierar beroende på om spelaren går, spurtar eller hukar. Hukning växlas med LeftControl-tangenten, och sprintning sker medan du håller nere LeftShift-tangenten.

Hoppar

Metoden HandleJumping applicerar en uppåtgående kraft när spelaren trycker på hoppknappen (standard: mellanslag), givet att spelaren är jordad. Markdetektering hanteras genom att kontrollera kollisioner med objekt taggade "Ground".

Kamerakontroll

Kamerans rotation styrs med hjälp av musen, vilket ger ett förstapersons- eller tredjepersonsperspektiv baserat på kamerans positionering. Utseendevinkeln är fastspänd för att förhindra överdriven lutning, vilket kan desorientera spelarna.

Slutsats

Den här handledningen ger en grund för avancerade spelarrörelser i Unity, och täcker olika aspekter som fysikbaserad kontroll, sprint, hukning och kamerahantering. Dessa tekniker kan ytterligare anpassas och utökas för att passa olika spelgenrer och stilar, vilket förbättrar spelarupplevelsen med responsiva och realistiska kontroller.

Kom ihåg att spelarrörelser är en kritisk aspekt av spelet och bör justeras noggrant för att säkerställa en tillfredsställande spelarupplevelse. Experimentera med olika värden och funktioner för att hitta den bästa installationen för ditt projekt.