public class Transition
{
    Func<bool> condition;
    List<StatePourcentage> availableStates;

    public Transition(Func<bool> condition, params StatePourcentage[] statePourcentage)
    {
        this.condition = condition;
        availableStates = new List<StatePourcentage>();
        for (int i = 0; i < statePourcentage.Length; i++)
        {
            availableStates.Add(statePourcentage[i]);
        }
    }

    public State GetState()
    {
        float percentage = UnityEngine.Random.Range(0, 100);
        float currentPercentage = 0;
        foreach (var statePer in availableStates)
        {
            currentPercentage += statePer.percentage;
            if (percentage <= currentPercentage)
            {
                return statePer.state;
            }
        }
        return null;
    }

    public bool IsConditionMet()
    {
        return condition();
    }
}

public class StatePourcentage
{
    public State state;
    public float percentage;

    public StatePourcentage(State state, float percentage)
    {
        this.state = state;
        this.percentage = percentage;
    }
}

Dans ces exemples, on observe une classe Transition et une classe StatePourcentage. Ces classes fonctionnent ensemble pour gérer les transitions entre différents états en fonction de certaines conditions et probabilités. Voici une explication simple du fonctionnement de ce code :

Explication

Classe StatePourcentage

Définition de la classe : La ligne public class StatePourcentage définit une classe nommée StatePourcentage. Cette classe contient des informations sur un état et le pourcentage de chance de transitionner vers cet état.

Variables membres :

public State state; contient une référence à un état. public float percentage; contient le pourcentage de chance de transitionner vers cet état.

Constructeur :

public StatePourcentage(State state, float percentage) est une méthode constructeur. Elle prend un State et un float en paramètres et les assigne aux variables membres.

Classe Transition

Définition de la classe : La ligne public class Transition définit une classe nommée Transition. Cette classe gère la logique de transition entre les états en fonction d'une condition et de pourcentages.

Variables membres : Func<bool> condition; est un délégué qui contient une fonction de condition. Cette fonction retourne un booléen indiquant si la condition de transition est remplie.

List<StatePourcentage> availableStates; est une liste qui contient plusieurs objets StatePourcentage, représentant les états potentiels vers lesquels effectuer la transition ainsi que leurs probabilités respectives.

Constructeur : public Transition(Func<bool> condition, params StatePourcentage[] statePourcentage) est une méthode constructeur. Elle prend une fonction de condition et un tableau d'objets StatePourcentage en paramètres. Elle initialise la variable membre condition avec la fonction de condition fournie et crée une nouvelle liste pour availableStates, en ajoutant chaque objet StatePourcentage du tableau à cette liste.

Méthode GetState : public State GetState() est une méthode qui détermine vers quel état effectuer la transition en fonction d'une sélection aléatoire et des pourcentages fournis. Elle génère un nombre aléatoire entre 0 et 100 et parcourt les états disponibles, en accumulant leurs pourcentages jusqu'à trouver l'état correspondant au nombre aléatoire.

Méthode IsConditionMet : public bool IsConditionMet() est une méthode qui vérifie si la condition de transition est remplie en appelant la fonction de condition. Elle retourne le résultat de la fonction de condition.

Fonctionnement pour notre ennemi

Configuration des transitions : Nous définissons des transitions entre les états, en spécifiant les conditions dans lesquelles ces transitions se produisent et les probabilités de transition vers chaque état.

Détermination du prochain état : Lorsqu'une transition est déclenchée, la méthode GetState() sélectionne aléatoirement le prochain état en fonction des probabilités définies. Cela ajoute un élément d'imprévisibilité au comportement de l'ennemi, le rendant plus dynamique et difficile à anticiper.

Vérification des conditions : La méthode IsConditionMet() est utilisée pour vérifier si les conditions d'une transition sont remplies. Si la condition est vraie, la transition peut avoir lieu et la méthode GetState() détermine le prochain état.

Gestionnaire d'États

public class StateManager
{
    State currentState;
    Dictionary<State, List<Transition>> stateTransitions;

    public StateManager(State startingState)
    {
        currentState = startingState;
        currentState.StartState();
        stateTransitions = new Dictionary<State, List<Transition>>();
    }

    public void AddStateTransition(State state, Transition transition)
    {
        if (!stateTransitions.ContainsKey(state))
        {
            stateTransitions.Add(state, new List<Transition>());
        }
        stateTransitions[state].Add(transition);
    }

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

    public void UpdateStates(float deltaTime)
    {
        currentState.UpdateState(deltaTime);
        List<Transition> stateTransitionsList = stateTransitions[currentState];
        if (stateTransitionsList == null || stateTransitionsList.Count == 0) return;
        foreach (var transition in stateTransitionsList)
        {
            if (transition.IsConditionMet())
            {
                ChangeState(transition.GetState());
                break;
            }
        }
    }
}

Modifications et Ajouts

Dictionnaire des Transitions d'État : Dictionary<State, List<Transition>> stateTransitions; est un dictionnaire qui contient des listes de transitions pour chaque état. Chaque état est associé à une liste de transitions possibles qui peuvent être vérifiées lors de la mise à jour de l'état.

Constructeur : stateTransitions = new Dictionary<State, List<Transition>>(); initialise le dictionnaire stateTransitions dans le constructeur, garantissant qu'il est prêt à stocker les transitions pour différents états.

Méthode AddStateTransition : public void AddStateTransition(State state, Transition transition) est une méthode qui ajoute une transition à la liste des transitions pour un état donné. Si l'état n'a pas déjà d'entrée dans le dictionnaire, une nouvelle entrée est créée avec une liste vide de transitions. La transition est ensuite ajoutée à la liste des transitions pour l'état spécifié.

Méthode UpdateStates : La méthode UpdateStates a été modifiée pour vérifier d'abord les transitions en récupérant la liste des transitions pour l'état actuel après l'avoir mis à jour avec currentState.UpdateState(deltaTime);. Elle évalue ensuite chaque transition de la liste pour vérifier si la condition de transition est remplie à l'aide de transition.IsConditionMet(). Si une condition de transition est remplie, elle change d'état avec ChangeState(transition.GetState()); et interrompt la boucle pour éviter plusieurs changements d'état lors d'une même mise à jour.

Raisons de ces Modifications

L'ajout du dictionnaire stateTransitions et de la méthode AddStateTransition permet au StateManager de gérer plusieurs transitions potentielles pour chaque état, augmentant ainsi la flexibilité et la complexité de la machine à états. En vérifiant dynamiquement les transitions dans la méthode UpdateStates, le StateManager permet à l'ennemi de réagir à différents événements et conditions en temps réel. La méthode mise à jour garantit que l'état actuel est d'abord mis à jour, puis que les transitions possibles sont vérifiées, ce qui assure une exécution correcte de la logique d'état avant de prendre des décisions de transition.

En mettant en œuvre ces modifications, le StateManager devient plus apte à gérer des comportements complexes et variés, rendant les actions de l'ennemi plus dynamiques et réactives à l'environnement du jeu.