public class RageState : State
{
    Animator animator;
    System.Action addHealth;
    System.Action changingAttackDmg;

    public RageState(Animator animator, System.Action addHealth, System.Action changeAttack)
    {
        this.animator = animator;
        this.addHealth = addHealth;
        changingAttackDmg = changeAttack;
    }

    public override void StartState()
    {
        animator.SetBool("rage", true);
        isStateFinished = false;
        changingAttackDmg(); // add the enemy dmg after raging
    }

    public override void UpdateState(float deltaTime)
    {
        addHealth();
    }

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

Explication de la classe RageState

La classe RageState représente un état spécifique qui gère le comportement de l’ennemi lorsqu’il entre en mode rage. Cette classe hérite de la classe State et inclut des méthodes pour démarrer, mettre à jour et terminer l’état de rage. Elle comprend également des actions pour ajouter de la santé et modifier les dégâts d’attaque lorsque l’ennemi est en mode rage.

Définition de la classe et variables membres

Définition de la classe :

public class RageState : State Cette classe hérite de la classe State, ce qui signifie qu’elle doit implémenter les méthodes abstraites définies dans State.

Variables membres :

Animator animator; Contrôle les animations.
System.Action addHealth; Action permettant d’ajouter de la santé à l’ennemi.
System.Action changingAttackDmg; Action permettant de modifier les dégâts d’attaque de l’ennemi.

Constructeur

Le constructeur initialise le RageState avec les composants nécessaires : un Animator pour les animations et deux actions pour l'ajout de santé et la modification des dégâts d'attaque. Il assigne ces valeurs aux variables membres correspondantes.

Méthode StartState

Cette méthode définit isStateFinished sur false, déclenche l'animation de rage en définissant le paramètre booléen "rage" de l'animator sur true, et appelle changingAttackDmg pour augmenter les dégâts de l'ennemi.

Méthode UpdateState

Cette méthode est appelée à chaque frame et appelle addHealth pour ajouter continuellement de la santé à l'ennemi tant qu'il est en état de rage.

Méthode EndState

Cette méthode arrête l'animation de rage en définissant le paramètre booléen "rage" dans l'animator à false.

Pourquoi cette approche

Comportement ennemi amélioré ;

Le RageState améliore le comportement de l'ennemi en augmentant ses dégâts d'attaque et en ajoutant continuellement de la santé, ce qui le rend plus difficile à vaincre pour le joueur ; L'utilisation d'actions (System.Action) permet des modifications flexibles et modulaires des attributs de l'ennemi.

Jouabilité dynamique et captivante :

Le fait que l'ennemi entre dans un état de rage rend la jouabilité plus dynamique et captivante, car le joueur doit s'adapter à un ennemi plus puissant et résistant.

Fonctionnement dans le contexte

Entrée en RageState : Lorsque l'ennemi entre dans le RageState, la méthode StartState est appelée, déclenchant l'animation de rage et augmentant les dégâts d'attaque de l'ennemi.

Pendant la rage : La méthode UpdateState est appelée à chaque frame. Elle ajoute continuellement de la santé à l'ennemi, rendant sa défaite plus difficile pour le joueur.

Sortie de RageState : Lorsque l'ennemi quitte le RageState, la méthode EndState est appelée, arrêtant l'animation de rage.

En structurant le RageState de cette manière, on s'assure que l'ennemi peut devenir nettement plus puissant et résistant, offrant un défi accru au joueur et enrichissant l'expérience de jeu globale.

Initialiser l'état de Rage

rage = new RageState(animator, () => { health += 10f * Time.deltaTime; }, () => { attack1.ChangeAttackDmg(15); attack2.ChangeAttackDmg(25); });

Explication

Initialisation de RageState :

rage = new RageState(animator, (...) => {...}, (...) => {...}); Crée une nouvelle instance de RageState nommée rage ;

Animator :

animator : Passe l'animateur pour contrôler les animations ;

Augmentation de la santé :

() => { health += 10f * Time.deltaTime; } Fonction lambda qui augmente la santé de 10 unités par seconde ;

Modification des dégâts d'attaque :

() => { attack1.ChangeAttackDmg(15); attack2.ChangeAttackDmg(25); } Fonction lambda qui modifie les dégâts d'attaque de attack1 à 15 et de attack2 à 25.

Transition vers la Rage

rageTransition = new Transition(() =>
{
    if (health <= 40f && haveRaged == false)
    {
        haveRaged = true;
        return true;
    }
    return false;
}, new StatePourcentage(rage, 100f));

La rageTransition est une transition qui fait passer l’ennemi dans un RageState lorsque certaines conditions sont remplies. Cette transition est conçue pour rendre l’ennemi plus redoutable lorsque sa santé tombe en dessous d’un certain seuil et qu’il n’est pas encore entré dans l’état de rage.

Définition de la transition

Condition :

La transition vérifie si la santé de l’ennemi est inférieure ou égale à 40 et si l’ennemi n’est pas déjà entré dans l’état de rage (haveRaged est false). Si les deux conditions sont remplies, elle définit haveRaged sur true pour garantir que l’ennemi n’entre qu’une seule fois dans l’état de rage et retourne true pour déclencher la transition.

State Pourcentage :

La transition utilise new StatePourcentage(rage, 100f) pour indiquer que lorsque la condition est remplie, l’ennemi passera à l’état RageState avec une probabilité de 100 %.

Raisons de cette approche

Déclenchement d’un comportement puissant : La rageTransition permet à l’ennemi de devenir plus puissant lorsque sa santé est critique, augmentant ainsi le défi pour le joueur. Cette transition garantit que l’ennemi n’entre qu’une seule fois dans l’état de rage, évitant ainsi les transitions répétées vers cet état.

Gameplay dynamique et stimulant : En introduisant l’état de rage dans des conditions de santé critiques, le gameplay devient plus dynamique et stimulant, obligeant le joueur à adapter sa stratégie.

Fonctionnement dans le contexte

Vérification de la santé : Pendant le jeu, la santé de l'ennemi est surveillée au fur et à mesure qu'il subit des dégâts. Lorsque la santé de l'ennemi tombe à 40 ou moins et qu'il n'est pas encore entré en rage, la condition rageTransition est remplie.

Déclenchement de l'état de rage : Une fois la condition remplie, haveRaged est défini sur true, et la transition vers le RageState est déclenchée avec une probabilité de 100 %.

Entrée dans l'état de rage : Le RageState est activé, augmentant les dégâts d'attaque de l'ennemi et ajoutant continuellement de la santé, rendant l'ennemi nettement plus difficile à vaincre.