Tutorial Création et Adaptation de personnages sous Mugen par Sunny : 4eme Partie
Principes généraux
Programmer un perso sous Mugen se résume en grande partie à décrire les différents états dans lesquels il peut se retrouver :
marcher, sauter, attaquer... sont des états dans lesquels un perso peut se trouver. En anglais, un état se dit State. Dans Mugen, nous
programmerons donc des states.
Le state de base est celui du stance : le perso est debout, immobile, attendant que vous lui
fassiez faire une action. En appuyant sur la direction avant, le perso entre dans un autre état : celui de la marche. En appuyant sur
la direction haut, le perso entre dans un état aérien : le saut. En appuyant sur un bouton d'attaque, le perso entre dans un état d'attaque.
Etc...
Pour résumer, chaque fois que le personnage effectue une action, il entre dans un état différent.
Dans Mugen, un perso n'est jamais inactif ; ce dernier est toujours en train d'effectuer une action et en conséquence, il se trouve toujours dans un certain état.
Le but de la construction du CNS est donc de dire :
(1)- quand le perso doit entrer dans un certain état
(2)- ce que le programme
doit faire lorsque le perso est dans cet état
(3)- quand le perso peut ou doit sortir de cet état
(4)- dans quel état il doit
ensuite allerGénéralement, un perso entre dans un nouvel état lorsque le joueur lui fait effectuer une nouvelle action ;
par exemple il appuie sur un bouton d'attaque (1). Dans cet état, le moteur de jeu devra effectuer certaines actions ; ici regarder
si le coup du joueur touche son adversaire (2). Une fois cette action terminée, c'est à dire une fois le coup donné (3), le perso
ressort de ce state et retourne au stance (4). Ce dernier point est une règle immuable : tout perso ayant terminé son action finit
par revenir au stance, directement ou indirectement (si le perso est en l'air par exemple, il faudra d'abord qu'il atterrisse).
Quelles sont les actions que peut effectuer le moteur de jeu dans un state (Note : afin d'éviter les confusions, dorénavant je nommerai
les actions du moteur de jeu actions et celle du personnage mouvements) ? Il peut modifier la vitesse de déplacement du personnage,
changer son animation, regarder si une attaque a touché un ennemi... Certaines de ces actions sont effectuées automatiquement
(exemple : afficher l'image suivante d'une animation, appliquer la gravité sur un personnage en train de sauter...) ; d'autres sont
faites à la demande du joueur. La liste complète des actions que peut demander le joueur se trouvent dans le fichier State Controller
Reference ( sctrls.txt) fourni par Elecbyte avec Mugen. Voici concrètement comment se présente une action (nous expliquerons les
différents éléments de cette action un peu plus tard) :
[State 200, 1]
type = null
trigger1 = time = 1
Pour qu'une
action demandée par le joueur soit effectuée, il faut que certaines conditions soient réunies. Dans cet objectif, chaque action doit
comporter des déclencheurs : les triggers (littéralement : gâchette). Si certaines conditions sont réunies, le trigger s'active et
l'action est effectuée. La liste des conditions pouvant être détectées par les triggers se trouve dans le fichier Trigger List
( trigger.txt) également fourni par Elecbyte avec Mugen.
Voici en gros la structure du CNS :Etat 1
---Action 1
------déclencheur 01
---Action 2
------déclencheur 01
------déclencheur 02
Etat 2
---Action 1
------déclencheur 01
------déclencheur 02
---Action 2
------déclencheur 01
(...)
Comment fonctionne tout ceci ?
Dans chaque state, à chaque tick, le programme regarde où en est le personnage : sa vitesse de déplacement, sa position par rapport à
son adversaire, etc... Puis il regarde si dans son état actuel le personnage remplit les conditions de l'une des actions du state.
Si les conditions de l'une de ces actions sont remplies, le ou les triggers de cette action sont enclenchés et l'action est réalisée.
Puis le programme effectue les actions automatiques (passer à l'image suivante de l'animation par ex) en tenant compte des actions
qui ont pu être enclenchées. Enfin, il passe au tick suivant et reprend ce processus depuis le départ.
