Créer un Gestionnaire d'État

État:

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 a une implémentation (dans ce cas, un corps vide {}), mais elle peut être remplacée par des classes dérivées si elles ont besoin d'un comportement différent.

Comment cela fonctionne 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é par des états, avec StartState() initialisant l'état, UpdateState() mettant à jour le comportement pendant l'état, et EndState() nettoyant après la fin de l'état.

Utilisation de la classe abstraite : Faire de State une classe abstraite garantit que tous les états spécifiques implémentent les méthodes nécessaires, organisant le comportement de l'ennemi et simplifiant la gestion des états sans modifier le script de l'ennemi.

Gestionnaire d'États:

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), change 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() pour effectuer les actions associées à cet état.

Comment cela fonctionne 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 et l'initialisant avec StartState(). Pendant le jeu, 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 Flux de Travail :

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 ensuite 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, nous pouvons facilement gérer et basculer entre différents comportements de notre ennemi de manière organisée.

État d'Attente

Explication

Le constructeur public IdleState(Animator animator) prend un objet Animator comme 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'animateur sur true, déclenchant l'animation d'attente. La méthode EndState, public override void EndState(), définit le paramètre "idle" sur false, arrêtant l'animation d'attente.

Comment cela fonctionne pour notre ennemi

Lorsque l'ennemi entre dans le IdleState, la méthode StartState() définit le paramètre "idle" dans l'animateur sur vrai, démarrant l'animation d'inactivité, faisant apparaître l'ennemi comme inactif. Lorsque l'ennemi quitte le IdleState, la méthode EndState() définit le paramètre "idle" sur faux, arrêtant l'animation d'inactivité et préparant l'ennemi à passer à un autre état, comme se déplacer ou attaquer.

Exemple de flux de travail

Le StateManager définit l'état de l'ennemi sur IdleState, appelant IdleState.StartState() pour définir le paramètre "idle" de l'animateur sur vrai, démarrant l'animation d'inactivité. Lors du changement de comportement de l'ennemi, le StateManager appelle IdleState.EndState(), définissant le paramètre "idle" sur faux et arrêtant l'animation d'inactivité. Le StateManager fait ensuite passer l'ennemi à un nouvel état, tel que AttackState ou PatrolState.

En utilisant la classe IdleState, nous pouvons nous assurer que notre ennemi peut entrer et sortir du comportement d'inactivité en douceur, le rendant plus dynamique et réaliste. Cette structure facilite également l'ajout ou la modification du comportement d'inactivité de l'ennemi sans affecter d'autres parties du code de l'ennemi.