Avansert spillerbevegelse i Unity

I denne opplæringen vil vi utforske avansert spillerbevegelsesmekanikk i Unity, inkludert sprint, huking og et jevnt kamerasystem. Disse funksjonene gir dybde og polering til spillerkontrollene, og forbedrer den generelle spillopplevelsen. Vi skal bruke Unitys fysikksystem for realistiske bevegelser og interaksjoner.

Sette opp scenen

Før vi dykker inn i koding, la oss sette opp en grunnleggende scene med et spillerobjekt og et kamera:

1. Opprett et nytt Unity-prosjekt.
2. I hierarkiet, lag en 3D-kube, gi den nytt navn til Player, og skaler den til å ligne en karakter (f.eks. X: 1, Y: 2, Z: 1).
3. Legg til en Rigidbody-komponent til spilleren og sett Interpolate-egenskapen til Interpolate for jevn fysikk.
4. Legg til en Capsule Collider-komponent, juster høyden og radiusen for å matche spillermodellen.
5. Lag et tomt GameObject, navngi det CameraRig, og fest et Camera til det. Plasser kameraet bak og litt over spilleren.
6. Gjør CameraRig til et barn av spilleren som ønsker å følge dens bevegelser.

Implementering av avansert spillerbevegelse

Vi vil implementere et skript som håndterer grunnleggende bevegelse, sprint, huking og jevn kamerarotasjon.

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økkelfunksjoner og forklaring

Bevegelse og hastighetskontroll

Skriptet bruker Unitys Rigidbody for å flytte spilleren, noe som muliggjør fysikkbaserte interaksjoner. Hastigheten varierer basert på om spilleren går, spurter eller sitter på huk. Crouching veksles med LeftControl-tasten, og sprint skjer mens du holder LeftShift-tasten nede.

Hopping

HandleJumping-metoden bruker en oppadgående kraft når spilleren trykker på hoppknappen (standard: mellomromstasten), gitt at spilleren er jordet. Bakkedeteksjon håndteres ved å se etter kollisjoner med objekter merket "Ground".

Kamerakontroll

Kameraets rotasjon styres ved hjelp av musen, og gir et førstepersons- eller tredjepersonsperspektiv basert på kameraets plassering. Utseendevinkelen er klemt for å forhindre overdreven vipping, noe som kan desorientere spillere.

Konklusjon

Denne opplæringen gir et grunnlag for avanserte spillerbevegelser i Unity, og dekker ulike aspekter som fysikkbasert kontroll, sprint, huking og kamerastyring. Disse teknikkene kan tilpasses og utvides ytterligere for å passe til forskjellige spillsjangre og -stiler, noe som forbedrer spilleropplevelsen med responsive og realistiske kontroller.

Husk at spillerbevegelse er et kritisk aspekt ved spilling og bør justeres nøye for å sikre en tilfredsstillende spilleropplevelse. Eksperimenter med forskjellige verdier og funksjoner for å finne det beste oppsettet for prosjektet ditt.