Ce sont les actions qui se passent lorsque vous êtes avec un nombre
important de personnes.
Ce tutoriel va mettre en place l'algorithme flack and swarm.
Cet algorithme est issue de l'observation des "essaims" de poissons :
Lorsqu'un poissons voit un prédateur, il fuit. Le poisson a coté voit celui
qui fuit et fuit a son tour, etc... Ce mécanisme est tellement rapide
qu'un observateur à l'impression que ceci se fait directement.
C'est ça les mécanismes de groupe.

Ces mécanismes sont souvent utilisés dans des jeu de type total war,
ou un groupe de personnes n'a en fait qu'une vrai personnes qui va
"réfléchir", le reste va copier les mouvement de celui qui réfléchit.

Mais quels sont les avantages d'utiliser cette technique ?

Tout d'abord, cela consomme moins de processeur car une seule personne
réfléchit, fait son action, et tout le monde copie son action. Du coup,
personnes d'autre ne réfléchit. (vous faites aussi cela en cours, tout
le monde copie sur une unique personne, cela prend moins de temps aux
autre cerveaux pour réfléchir, donc c'est bien )
Cela permet aussi d'assurer une cohérence dans le groupe
vous imaginer une armée où chacun peut faire ce qu'il veut ?
limiter le nombre de personnes qui réfléchit permet donc de limiter les incohérences
dans le jeu pour le joueur.

Donc pour le code, il faut faire cela :
"l'entité" leader fait cela :

typedef struct t_leader
{
    char etat;
    void(*p_fonction)(t_info *);
}t_leader;

Si vous ne savez pas se que signifie etat, aller voir le tutoriel précédent.
p_fonction est un pointeur de fonction.
Allez voir le tutoriel d'AlexMog qui est très bien fait.

Utiliser les pointeur sur fonction permet d'exécuter très rapidement la fonction,
au lieu de mettre un ID de fonction et faire un immense switch ou if, else if ...

Dès lors, afin que les sbires, où ceux qui suivent le leader fassent les même actions,
il suffit de faire :

typedef struct t_sbire
{
    void(*p_fonction)(t_info *);
}t_sbire;

la structure t_info contient toutes les infos utiles pour exécuter les actions
Aller encore regarder mon tutoriel précédent pour comprendre se que c'est

t_leader leader;
t_info info;
/* vous mettez le pointeur sur fonction en fonction de l'état du pnj
par exemple : */
leader.p_fonction = &attack_near_enemy;

t_sbire sbire[16]; /* 16 est un exemple */
int i;

for(i = 0 ; i < 16 ; i++)
{
    sbire[i].p_fonction = leader.p_fonction;
}
/* tout les sbires vont maintenant pouvoir faire la même action que le leader */

et on exécute le tout

leader.p_fonction(&info); /* on envoie la structure d'info a la fonction (un pointeur)*/

for(i = 0 ; i < 16 ; i++)
{
    sbire[i].p_fonction(&info);
}

Et voila, vous pouvez maintenant créer facilement des mécaniques de groupe, afin de créer
des immense batailles, ou encore une joli danse (chacun fait la même chose que son voisin) .