État :

public abstract class State
{
    public abstract void StartState();
    public virtual void UpdateState()
    {
    }
    public abstract void EndState();
}

Méthodes abstraites :

public abstract void StartState(); public abstract void EndState(); sont des méthodes abstraites. Une méthode abstraite n’a pas de corps (implémentation) ici et doit être implémentée par toute classe non abstraite qui hérite de cette classe State.

Méthode virtuelle :

public virtual void UpdateState() {} est une méthode virtuelle. Une méthode virtuelle possède une implémentation (dans ce cas, un corps vide {}), mais elle peut être redéfinie par les classes dérivées si un comportement différent est nécessaire.

Fonctionnement pour notre ennemi

Héritage d’état :

La classe State sera héritée par d’autres états spécifiques. Par exemple, nous pourrions avoir des classes comme IdleState, AttackState et PatrolState qui héritent de State. Chacun de ces états implémentera ses propres versions de StartState(), UpdateState() et EndState().

Comportement de l'ennemi :

Le comportement de l'ennemi est géré à l'aide d'états, avec StartState() pour initialiser l'état, UpdateState() pour mettre à jour le comportement pendant l'état, et EndState() pour effectuer le nettoyage après la fin de l'état.

Utilisation de la classe abstraite : Définir State comme une classe abstraite garantit que tous les états spécifiques implémentent les méthodes nécessaires, ce qui organise le comportement de l'ennemi et simplifie la gestion des états sans modifier le script de l'ennemi.

Gestionnaire d'états :

public class StateManager
{
    State currentState;

    public StateManager(State startingState)
    {
        currentState = startingState;
        currentState.StartState();
    }

    public void ChangeState(State newState)
    {
        currentState.EndState();
        currentState = newState;
        currentState.StartState();
    }

    public void UpdateStates()
    {
        currentState.UpdateState();
    }
}

Explication

Le constructeur public StateManager(State startingState) initialise le StateManager avec un état de départ. Il définit currentState sur startingState et appelle currentState.StartState() pour l'initialiser.

La méthode ChangeState, public void ChangeState(State newState), modifie l'état de l'ennemi. Elle appelle currentState.EndState() pour nettoyer l'état actuel, définit currentState sur le nouvel état, puis appelle currentState.StartState() pour initialiser le nouvel état.

La méthode UpdateStates, public void UpdateStates(), met à jour l'état actuel en appelant currentState.UpdateState() afin d'exécuter les actions associées à cet état.

Fonctionnement pour notre ennemi

Lorsque nous créons un StateManager pour notre ennemi, le constructeur initialise l'état de départ. Lorsque l'ennemi doit changer de comportement, la méthode ChangeState est appelée, mettant fin à l'état actuel avec EndState(), définissant le nouvel état, puis l'initialisant avec StartState(). Pendant la partie, la méthode UpdateStates est appelée de manière répétée pour exécuter les actions de l'état actuel via UpdateState().

Exemple de déroulement :

L'ennemi commence dans un IdleState, avec le StateManager créé et IdleState.StartState() appelé pour configurer le comportement d'attente. Lorsque l'ennemi détecte le joueur, ChangeState(new AttackState()) est appelé, mettant fin au comportement d'attente avec IdleState.EndState(). L'état actuel est alors défini sur AttackState, et AttackState.StartState() initie le comportement d'attaque. À chaque frame, UpdateStates() est appelé, et si l'état actuel est AttackState, AttackState.UpdateState() gère les actions d'attaque.

En utilisant la classe StateManager, il est possible de gérer et de basculer facilement entre différents comportements de notre ennemi de manière organisée.

État d'inactivité

public class IdleState : State
{
    Animator animator;

    public IdleState(Animator animator)
    {
        this.animator = animator;
    }

    public override void StartState()
    {
        animator.SetBool("idle", true);
    }

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

Explication

Le constructeur public IdleState(Animator animator) prend un objet Animator en paramètre et l'assigne à la variable animator de la classe. La méthode StartState, public override void StartState(), définit le paramètre booléen "idle" dans l'animator sur true, déclenchant ainsi l'animation d'inactivité. La méthode EndState, public override void EndState(), définit le paramètre "idle" sur false, arrêtant l'animation d'inactivité.

Fonctionnement pour notre ennemi

Lorsque l'ennemi entre dans l'IdleState, la méthode StartState() définit le paramètre "idle" dans l'animator sur true, lançant l'animation d'inactivité et donnant l'apparence d'un ennemi inactif. Lorsque l'ennemi quitte l'IdleState, la méthode EndState() définit le paramètre "idle" sur false, arrêtant l'animation d'inactivité et préparant l'ennemi à passer à un autre état, comme le déplacement ou l'attaque.

Exemple de flux de travail

Le StateManager définit l'état de l'ennemi sur IdleState, appelant IdleState.StartState() pour activer le paramètre "idle" de l'animateur, lançant ainsi l'animation d'attente. Lors du changement de comportement de l'ennemi, le StateManager appelle IdleState.EndState(), désactivant le paramètre "idle" et arrêtant l'animation d'attente. Le StateManager fait ensuite passer l'ennemi à un nouvel état, tel que AttackState ou PatrolState.

En utilisant la classe IdleState, nous pouvons garantir que notre ennemi peut entrer et sortir du comportement d'attente de manière fluide, le rendant ainsi plus dynamique et réaliste. Cette structure facilite également l'ajout ou la modification du comportement d'attente de l'ennemi sans impacter les autres parties du code de l'ennemi.