En regardant le titre, vous avez sans doute penser : "kesako ?"
Et bah c'est très simple : un automate, c'est une machine qui fait ce qu'on lui dit,
et pourquoi a états finis ?

C'est parce que cet automate peut avoir plusieurs états différents, mais il ne
peut pas prendre les états que l'on n'a pas coder pour lui. Il ne peut aussi

prendre qu'un seul état à la fois.

Les automate à état fini sont très utilisés dans les jeux vidéos car ils sont
très simples à mettre en place et à débuggés. Le majeur inconvénients, c'est
qu'il sont prédictible, ce qui peut briser l'illusion qu'un véritable joueur,
est devant le joueur. Pour éviter la prédictibilité, une des solutions possibles
est d'augmenter le nombre d'états, ce qui permet plus de variations dans le pnj

Concrètement, prenons exemple sur un soldat dans un jeu qui protège un village par exemple :
On peut lui mettre deux états différents :
État 1 : patrouille
État 2 : attaque

Il faut maintenant dire ce qu'il faut pour changer d'état (c'est mieux non ?)
Par exemple, pour aller de l'état 1 à l'état 2, il faut que le soldat ai vu un intrus
et de l'état 2 au 1, il faut que le garde ai tuer l'intrus.

Pour reprendre l'exemple du soldats, on peut créer d'autre états :

État 3 : suivit d'un intrus qui veut s'enfuir.
État 4 : fuite car l'intrus est trop fort.
État 5 : va dormir (il a le droit de dormir non ?)

Bref vous l'avez compris, plus il y a d'états, plus le pnj sera réaliste.

Et maintenant le code :

/*
la structure qui va servir pour votre pnj
*/
typedef struct t_perso t_perso;
struct t_perso
{
    char etat;
    char type;
    t_info info;
}

l'état correspond a l'état actuel du pnj. par exemple, pour le soldat,
si l’état est égal a 1, alors le soldat patrouille, etc...
le type correspond au type de pnj que vous avez.

et la structure t_info, contient tout ce que le pnj a besoin de savoir pour changer
d'état. (il a besoin de savoir si un ennemi est proche de lui etc...)

void change_etat(t_perso *pnj)
{
    /*
    Je suppose que toutes les infos utiles sont dans la structure t_perso
    
    touts les mot en majuscules sont soit des define, soit des énumérations;
    faites ce qu'il vous plaît le plus
    */
    
    if(pnj->etat == PATROUILLE)
    {
        if(test_attaque(pnj))
        {
            pnj->etat = ATTAQUE;
        }
        else if(test_sommeil(pnj))
        {
            pnj->etat = DODO;
        }
    }
    if(pnj->etat == ATTAQUE)
    {
        if(test_intrus_mort(pnj))
        {
            pnj->etat = PATROUILLE;
        }
        else if(test_intrus_trop_fort(pnj))
        {
            pnj->etat = FUITE;
        }    
    }
    if(pnj->etat == DODO)
    {
        if(test_sommeil_fini(pnj))
        {
            pnj->etat = PATROUILLE;
        }    
    }
    if(pnj->etat == FUITE)
    {
        if(test_intrus_loin(pnj))
        {
            pnj->etat = PATROUILLE;
        }
    }
}

les fonctions test_quelquechose(), sont des fonctions booléenne : si la condition est vrai, alors on retourne
1, et on change d'état associé a la fonction, si la fonction retourne 0, la condition est fausse,
alors on ne change pas d'état. ces fonction nécessite une structure t_perso pour tester
les conditions, mais rien ne vous oblige à les utiliser.
Faites vos propres test avec ce qu'il faut pour changer d’état, il faut juste modifier un peu
le code.

Comme vous le voyez, ce code est simple, et est très facilement lisible, donc facilement modifiable et
débuggable.
Chaque type de personnage nécessite sa propre fonction de changement d'état(un fermier qui fabrique ses
propres vêtements n'est pas crédible, réservez cela au tailleur).

Afin de vous retrouver plus facilement dans la création de changement d'état, n'hésitez pas
à faire un graphique des différents état possible :

pour info, flee veut dire s'enfuir.

Et voila, vous avez maintenant un pnj qui peut réagir en fonction des événement

qu'il l'entoure