Erweiterte Spielerbewegung in Unity

In diesem Tutorial erkunden wir fortgeschrittene Spielerbewegungsmechaniken in Unity, darunter Sprinten, Ducken und ein flüssiges Kamerasystem. Diese Funktionen verleihen den Spielersteuerungen Tiefe und Eleganz und verbessern das gesamte Spielerlebnis. Wir werden das Physiksystem von Unity für realistische Bewegungen und Interaktionen verwenden.

Einrichten der Szene

Bevor wir uns in die Codierung stürzen, richten wir eine einfache Szene mit einem Spielerobjekt und einer Kamera ein:

1. Erstellen Sie ein neues Unity-Projekt.
2. Erstellen Sie in der Hierarchie einen 3D-Würfel, benennen Sie ihn in Player um und skalieren Sie ihn so, dass er einer Figur ähnelt (z. B. X: 1, Y: 2, Z: 1).
3. Fügen Sie dem Player eine Rigidbody-Komponente hinzu und setzen Sie die Interpolate-Eigenschaft auf Interpolate für eine reibungslose Physik.
4. Fügen Sie eine Capsule Collider-Komponente hinzu und passen Sie ihre Höhe und ihren Radius an das Spielermodell an.
5. Erstellen Sie ein leeres GameObject, nennen Sie es CameraRig und hängen Sie eine Camera daran an. Positionieren Sie die Kamera hinter und leicht über dem Spieler.
6. Machen Sie das CameraRig zu einem untergeordneten Element des Player-Objekts, um dessen Bewegungen zu folgen.

Implementieren erweiterter Spielerbewegungen

Wir werden ein Skript implementieren, das grundlegende Bewegungen, Sprinten, Ducken und eine sanfte Kameradrehung steuert.

PlayerMovement-Skript

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

Hauptmerkmale und Erklärung

Bewegung und Geschwindigkeitskontrolle

Das Skript verwendet Unitys Rigidbody, um den Spieler zu bewegen, was physikbasierte Interaktionen ermöglicht. Die Geschwindigkeit variiert, je nachdem, ob der Spieler geht, sprintet oder hockt. Das Hocken wird mit der Taste LinkeStrg umgeschaltet, und das Sprinten erfolgt, wenn die Taste LinkeUmschalttaste gedrückt gehalten wird.

Springen

Die Methode HandleJumping wendet eine Aufwärtskraft an, wenn der Spieler die Sprungtaste drückt (Standard: Leertaste), vorausgesetzt, der Spieler ist am Boden. Die Bodenerkennung erfolgt durch Überprüfung auf Kollisionen mit Objekten, die mit "Ground" markiert sind.

Kamerasteuerung

Die Drehung der Kamera wird mit der Maus gesteuert und ermöglicht je nach Kamerapositionierung eine Perspektive aus der ersten oder dritten Person. Der Blickwinkel ist begrenzt, um eine übermäßige Neigung zu verhindern, die den Spieler verwirren könnte.

Abschluss

Dieses Tutorial bietet eine Grundlage für fortgeschrittene Spielerbewegungen in Unity und behandelt verschiedene Aspekte wie physikbasierte Steuerung, Sprinten, Ducken und Kameraführung. Diese Techniken können weiter angepasst und erweitert werden, um verschiedenen Spielgenres und -stilen zu entsprechen und das Spielerlebnis mit reaktionsschnellen und realistischen Steuerelementen zu verbessern.

Denken Sie daran, dass die Spielerbewegungen ein entscheidender Aspekt des Spiels sind und sorgfältig abgestimmt werden sollten, um ein zufriedenstellendes Spielerlebnis zu gewährleisten. Experimentieren Sie mit verschiedenen Werten und Funktionen, um das beste Setup für Ihr Projekt zu finden.