Mouvements avancés des joueurs dans Unity

Dans ce didacticiel, nous allons explorer les mécanismes de mouvement avancés des joueurs dans Unity, notamment le sprint, l'accroupissement et un système de caméra fluide. Ces fonctionnalités ajoutent de la profondeur et de la finition aux commandes du joueur, améliorant ainsi l'expérience de jeu globale. Nous utiliserons le système physique d'Unity pour des mouvements et des interactions réalistes.

Mise en place de la scène

Avant de plonger dans le codage, configurons une scène de base avec un objet joueur et une caméra:

1. Créez un nouveau projet Unity.
2. Dans la hiérarchie, créez un cube 3D, renommez-le en Player et mettez-le à l'échelle pour qu'il ressemble à un personnage (par exemple, X: 1, Y: 2, Z: 1).
3. Ajoutez un composant Rigidbody au lecteur et définissez la propriété Interpolate sur Interpolate pour une physique fluide.
4. Ajoutez un composant Capsule Collider, ajustez sa hauteur et son rayon pour correspondre au modèle du joueur.
5. Créez un GameObject vide, nommez-le CameraRig et attachez-lui une Camera. Positionnez la caméra derrière et légèrement au-dessus du joueur.
6. Faites du CameraRig un enfant de l'objet Player pour suivre ses mouvements.

Mise en œuvre du mouvement avancé du joueur

Nous allons implémenter un script qui gère les mouvements de base, les sprints, les accroupissements et la rotation fluide de la caméra.

Script de mouvement du joueur

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

Principales caractéristiques et explications

Contrôle du mouvement et de la vitesse

Le script utilise le Rigidbody d'Unity pour déplacer le joueur, ce qui permet des interactions basées sur la physique. La vitesse varie selon que le joueur marche, sprinte ou s'accroupit. L'accroupissement est activé avec la touche LeftControl et le sprint se produit en maintenant la touche LeftShift enfoncée.

Sauter

La méthode HandleJumping applique une force vers le haut lorsque le joueur appuie sur le bouton de saut (par défaut: barre d'espace), à ​​condition que le joueur soit au sol. La détection du sol est gérée en vérifiant les collisions avec les objets marqués "Ground".

Contrôle de la caméra

La rotation de la caméra est contrôlée à l'aide de la souris, ce qui permet d'obtenir une perspective à la première ou à la troisième personne en fonction du positionnement de la caméra. L'angle de vue est limité pour éviter une inclinaison excessive, qui peut désorienter les joueurs.

Conclusion

Ce didacticiel fournit les bases des mouvements avancés des joueurs dans Unity, couvrant divers aspects tels que le contrôle basé sur la physique, le sprint, l'accroupissement et la gestion de la caméra. Ces techniques peuvent être davantage personnalisées et étendues pour s'adapter à différents genres et styles de jeu, améliorant l'expérience du joueur avec des commandes réactives et réalistes.

N'oubliez pas que les mouvements des joueurs sont un aspect essentiel du gameplay et doivent être soigneusement réglés pour garantir une expérience de jeu satisfaisante. Expérimentez différentes valeurs et fonctionnalités pour trouver la meilleure configuration pour votre projet.