Avanceret spillerbevægelse i Unity

I denne tutorial vil vi udforske avanceret spillerbevægelsesmekanik i Unity, inklusive sprint, krøjning og et glat kamerasystem. Disse funktioner tilføjer dybde og polering til spillerkontroller, hvilket forbedrer den overordnede spiloplevelse. Vi vil bruge Unitys fysiksystem til realistisk bevægelse og interaktioner.

Opsætning af scenen

Før vi dykker ned i kodning, lad os opsætte en grundlæggende scene med et afspillerobjekt og et kamera:

1. Opret et nyt Unity-projekt.
2. Opret en 3D-terning i hierarkiet, omdøb den til Player og skaler den til at ligne en karakter (f.eks. X: 1, Y: 2, Z: 1).
3. Tilføj en Rigidbody komponent til afspilleren og indstil Interpolate egenskaben til Interpolate for glat fysik.
4. Tilføj en Capsule Collider-komponent, juster dens højde og radius, så den matcher afspillermodellen.
5. Opret et tomt GameObject, navngiv det CameraRig, og vedhæft et Camera til det. Placer kameraet bag og lidt over afspilleren.
6. Gør CameraRig til et underordnet af spilleren, der ønsker at følge dens bevægelser.

Implementering af avanceret spillerbevægelse

Vi vil implementere et script, der håndterer grundlæggende bevægelser, sprint, sammenkrøbning og jævn 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;
        }
    }
}

Nøglefunktioner og forklaring

Bevægelse og hastighedskontrol

Scriptet bruger Unitys Rigidbody til at flytte afspilleren, hvilket giver mulighed for fysikbaserede interaktioner. Hastigheden varierer afhængigt af, om spilleren går, spurter eller sidder på hug. Crouching skiftes med LeftControl-tasten, og sprint foregår, mens du holder LeftShift-tasten nede.

Hoppe

HandleJumping-metoden anvender en opadgående kraft, når spilleren trykker på springknappen (standard: mellemrumstasten), givet at spilleren er jordet. Jorddetektering håndteres ved at tjekke for kollisioner med objekter mærket "Ground".

Kamera kontrol

Kameraets rotation styres ved hjælp af musen, hvilket giver et førstepersons- eller tredjepersonsperspektiv baseret på kameraets positionering. Udseendevinklen er fastspændt for at forhindre overdreven vipning, hvilket kan desorientere spillere.

Konklusion

Denne tutorial giver et grundlag for avanceret spillerbevægelse i Unity, og dækker forskellige aspekter som fysikbaseret kontrol, sprint, hukning og kamerastyring. Disse teknikker kan yderligere tilpasses og udvides, så de passer til forskellige spilgenrer og stilarter, hvilket forbedrer spilleroplevelsen med responsive og realistiske kontroller.

Husk, at spillerbevægelser er et kritisk aspekt af gameplay og bør indstilles omhyggeligt for at sikre en tilfredsstillende spilleroplevelse. Eksperimenter med forskellige værdier og funktioner for at finde den bedste opsætning til dit projekt.