❤ 1Gari Domaine de compétences : RGSS
Niveau : Moyen
Ce tutorial vous expliquera le fonctionnement d’un écran quelconque sous RMXP, pour que vous puissiez créer les votre à l’avenir.
Le principe général du moteur de RMXP, est une grande boucle, tournant à l’infini jusqu’à ce qu'on lui dise de quitter.
Que voit-on en regardant le script Main ?
La création d’une variable globale $scene recevant pour valeur un nouvel objet de Scene_Title.
Puis une première boucle.
Cette boucle exécute la méthode « Main » de la classe Scene_xxxx actuelle tant que $scene est un objet de type Scene_xxxx (plus précisément tant que $scene n’est pas nulle).
Quand $scene sera nulle, la boucle s’arrêtera, et le jeu sera fermé en conséquence.
Maintenant intéressons nous à Scene_xxxx.
De quoi est composée une classe Scene_xxxx ?
- D’une méthode « Initialize » prenant, selon les besoins, des paramètres.
- D’une méthode « Main »
- D’une méthode « Update »
Ensuite selon les Scenes, et les besoins du programmeur, d’autres méthodes sont ajoutées ou non.
Décrivons ces 3 méthodes :
1. Initialize
Cette méthode, propre à toutes les classes (Scene ou autre) est appelée pour initialiser une instance (un objet), de cette classe. Ce qui se résume en terme de code à cela :
1
| $scene = Scene_xxxx.new() |
Le new correspond au Initialize.
Vous insèrerez donc dans cette méthode, les valeurs par défaut, nécessaire au fonctionnement de la Scene_xxxx. Pour les paramètres, j’y reviendrai un peu plus tard.
Cette méthode est facultative, vous n’êtes pas obligé de la définir si vous n’en avez pas besoin.
2. Main
Main, est la fonction principale (d’où son nom), de la classe Scene_xxxx. Toutes les classes de type Scene_xxxx suivent la même structure, et c’est cette structure que je vais vous détailler.
Voici la méthode sous sa forme la plus simple, c'est-à-dire comportant le minimum nécessaire à un fonctionnement correct.
1
2
3
4
5
6
7
8
9
10
11
12
| def main
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
end |
Ligne 2 : Exécution de la Transition Graphique.
. Ligne 3 à 10 : Boucle principale de la Scene_xxxx
___ . Ligne 4 : Mise à jour des graphismes, changement visible à l’écran.
___ . Ligne 5 : Mise à jour de l’état des touches, pour savoir quelles touches sont pressées ou pas.
___ . Ligne 6 : Appel de la méthode « Update » de la classe. C’est la que ce fait le fonctionnement de la classe, la gestion des actions voulues selon les touches appuyées, la mise à jour des fenêtres affichées...
___ . Ligne 7 à 9 : Test de changement de Scene. Si $Scene ne correspond pas à l’objet actuel du type de la classe Scene_xxxx alors :
___ ___ . Ligne 8 : On casse la boucle (pour en sortir).
. ]Ligne 11 : On gèle l’écran pour préparer le prochain objet Scene.
Ce qui varie dans « Main » entre les différentes classes de type Scene_xxxx, c’est le code disposé entre la ligne 1 et 2, et entre la ligne 10 et 11. Puis bien entendu le code de la méthode « Update ».
On a donc en général, la création des fenêtres nécessaires, entre les lignes 1 et 2, et leurs destructions entre les lignes 10 et 11.
La création se fait comme ceci :
1
| @fenetre = Window_xxxx.new() |
La destruction se fait comme ceci :
Il faut bien comprendre que la méthode « Main » n’est appelée qu’une fois, mais que la méthode « Update » est appelée à chaque frame.
Voyons maintenant la méthode « Update »
3. Update
Que doit comporter cette méthode ? Les appels pour la mise à jour des fenêtres affichées, le code pour quitter la scène en appuyant sur la touche voulue, et le code pour ce qui doit se passer avec cet écran…
Jusque là rien de bien compliqué…
Le code pour la mise à jour d’une fenêtre :
Voici le bout de code nécessaire pour quitter la scene (et donc en arriver sur une autre) :
1
2
3
4
5
| if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Map.new
return
end |
Donc Input::B correspond en général à la touché d’annulation qui par défaut correspond à la touche Echap.
Donc si cette touche Vient d’être pressée, on joue le son d’annulation, puis j’attribue à $scene, un nouvel objet de type Scene_xxxx, ici Scene_Map (on arrivera donc sur la map de jeu en cours).
$scene ne correspond plus à « self », la boucle de « Main » détectera ce changement et cassera la boucle et « Main » de Scene_xxxx s’arrêtera pour lancer le « Main » de Scene_Map. (Grâce à la boucle du Script « Main »).
J’espère avoir été assez clair pour l’explication du principe de fonctionnement.
Bon pour l’histoire des paramètres…
Disons que vous avez besoin de placez un curseur dans la prochaine scène selon la valeur de la variable truc dans la scène actuelle…
Et Bien à la création de la prochaine Scene vous donnerez en paramètre à « new » (donc à « initialize ») la valeur de la variable truc.
Bien sur cela implique que vous ayez prévu dans le code de « initialize » ce fameux paramètre pour vous en servir, sinon vous aurez droit à une erreur de syntaxe.
Ensuite le paramètre s’affectera (si vous lui dites) à une variable d’instance, et celle-ci sera utilisée dans votre main ou votre update…
Un ptit exemple :
1
2
3
4
| def Initialize(param)
@pos_curseur = param + 1
#vous vous servirez alors de @pos_curseur dans votre code.
end |
Votre appel du new ressemblera à cela :
1
| $scene = Scene_xxxx.new(truc) |
Voilà !!
| 
Chat
