public class Projectile : MonoBehaviour
{
    [SerializeField] int damage;
    [SerializeField] float speed;
    Rigidbody2D rb;
    Vector2 direction;

    public void Setup(Vector2 direction)
    {
        this.direction = direction;
        rb = GetComponent<Rigidbody2D>();
        transform.right = direction;
        Destroy(gameObject, 6);
    }

    private void Update()
    {
        rb.velocity = direction * speed;
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        Debug.Log(collision.gameObject.name);
        if (collision.tag == "Player")
        {
            if (collision.TryGetComponent(out IGetAttacked getAttacked))
            {
                getAttacked.GetAttacked(damage);
                Destroy(gameObject);
            }
        }
    }
}

La classe Projectile est responsable de la gestion du comportement des projectiles que l’ennemi peut lancer vers le joueur. Cette classe gère la configuration de la direction et de la vitesse du projectile, la mise à jour de son mouvement et la gestion des collisions.

Méthode Setup

public void Setup(Vector2 direction)
{
    this.direction = direction;
    rb = GetComponent<Rigidbody2D>();
    transform.right = direction;
    Destroy(gameObject, 6);
}

But : Cette méthode initialise l’état du projectile.

Paramètres : Prend un paramètre Vector2 direction pour définir la direction dans laquelle le projectile va se déplacer.

Actions : Définit la direction du projectile, récupère le composant Rigidbody2D attaché au projectile, oriente le projectile vers la direction de déplacement, et programme la destruction du projectile après 6 secondes afin d’éviter qu’il ne reste indéfiniment dans la scène.

Méthode Update

private void Update()
{
    rb.velocity = direction * speed;
}

But : Cette méthode met à jour le mouvement du projectile.

Actions : Définit la vélocité du Rigidbody2D pour déplacer le projectile dans la direction spécifiée à la vitesse spécifiée.

Méthode OnTriggerEnter2D

private void OnTriggerEnter2D(Collider2D collision)
{
    Debug.Log(collision.gameObject.name);
    if (collision.tag == "Player")
    {
        if (collision.TryGetComponent(out IGetAttacked getAttacked))
        {
            getAttacked.GetAttacked(damage);
            Destroy(gameObject);
        }
    }
}

But : Cette méthode gère les collisions avec d'autres objets.

Paramètres : Prend un paramètre Collider2D collision pour détecter les collisions.

Actions : Affiche dans la console le nom de l'objet avec lequel le projectile est entré en collision, vérifie si le projectile a touché un objet ayant le tag "Player", et si l'objet possède un composant qui implémente l'interface IGetAttacked, appelle la méthode GetAttacked sur ce composant pour infliger des dégâts. Enfin, détruit le projectile après avoir touché le joueur.

Pourquoi cette approche

Modulaire et réutilisable : La classe Projectile est conçue pour être modulaire et réutilisable pour tout type de projectile utilisé par l’ennemi. En définissant la direction et la vitesse, il est possible de créer divers projectiles avec des comportements différents.

Gestion efficace du mouvement : L’utilisation du composant Rigidbody2D pour le mouvement garantit que le projectile se comporte selon le système physique de Unity, offrant un mouvement fluide et réaliste.

Détection de collision et gestion des dégâts : La méthode OnTriggerEnter2D permet au projectile de détecter les collisions avec le joueur et d’appliquer les dégâts de manière appropriée, rendant l’interaction entre le projectile et le joueur efficace.

Classe SendProjectileState

public class SendProjectileState : State
{
    Animator animator;
    System.Action sendProjectileFunc;

    public SendProjectileState(Animator animator, System.Action sendProjectileFunc)
    {
        this.animator = animator;
        this.sendProjectileFunc = sendProjectileFunc;
    }

    public override void StartState()
    {
        isStateFinished = false;
        animator.SetBool("projectil", true);
    }

    public override void StartAction()
    {
        sendProjectileFunc();
    }

    public override void EndState()
    {
        animator.SetBool("projectil", false);
    }
}

La classe SendProjectileState représente un état spécifique qui gère le comportement de l’ennemi lors du lancement d’un projectile. Cette classe hérite de la classe State et inclut des méthodes pour démarrer, terminer et initier l’action d’attaque par projectile.

Constructeur

Le constructeur initialise la classe SendProjectileState avec un Animator pour les animations et une action permettant d’envoyer le projectile. Il assigne ces valeurs aux variables membres correspondantes.

Méthode StartState

Cette méthode définit isStateFinished sur false et déclenche l'animation du projectile en réglant le paramètre booléen "projectil" de l'animateur sur true.

Méthode StartAction

Cette méthode appelle sendProjectileFunc, qui exécute l'action définie pour l'envoi du projectile. Cette méthode est généralement appelée par un événement de l'animateur afin de synchroniser le lancement du projectile avec l'animation.

Méthode EndState

Cette méthode arrête l'animation du projectile en réglant le paramètre booléen "projectil" de l'animateur sur false.

Pourquoi avons-nous procédé ainsi

Modulaire et réutilisable : La classe SendProjectileState est conçue pour être modulaire, permettant une intégration flexible de différents comportements d'envoi de projectiles grâce à l'utilisation de System.Action.

Intégration de l'animation : En utilisant les paramètres de l'animateur, cet état garantit que le lancement du projectile est synchronisé avec l'animation correspondante, offrant ainsi une expérience fluide et réaliste.

Fonction Send Projectile

void SendProjectile()
{
    Vector2 direction = (player.position - transform.position).normalized;
    Instantiate(projectile, projectileSendingPosition.position, Quaternion.identity).Setup(direction);
}

La méthode SendProjectile est responsable de la création et du lancement d'un projectile en direction du joueur. Cette méthode calcule la direction de l'ennemi vers le joueur, instancie le projectile et le configure pour qu'il se déplace dans la direction calculée.

Définition de la méthode et composants

Définition de la méthode : void SendProjectile(): Cette méthode ne retourne aucune valeur et est conçue pour gérer le lancement du projectile.

Composants : Vector2 direction = (player.position - transform.position).normalized; Cette ligne calcule la direction de l'ennemi vers le joueur en soustrayant la position de l'ennemi de celle du joueur. La partie .normalized garantit que le vecteur direction a une longueur de 1, ce qui en fait un vecteur unitaire indiquant uniquement la direction.

Instantiate(projectile, projectileSendingPosition.position, Quaternion.identity).Setup(direction); Cette ligne crée une nouvelle instance du projectile à la position spécifiée (projectileSendingPosition.position) sans rotation (Quaternion.identity). La méthode Setup est appelée sur le projectile instancié pour définir sa direction.

Liaison avec l'Animator Unity

La fonction StartAction est appelée à l'aide des événements de l'animator. Cela permet de spécifier l'image exacte dans l'animation de l'ennemi à laquelle le projectile doit être envoyé. Puisque l'animation comporte de nombreuses images, il est important de déterminer le moment précis où cette action doit se produire.