Initialement posté ici : http://blog.gri.im

Motivations et contexte

Depuis peu, je me suis lancé dans la réalisation d'un système de jeu avec le logiciel RPG Maker VX Ace en me limitant aux commandes évènementielle du logiciel. Donc sans avoir le droit d'utiliser un "script" explicite.
C'est un exercice très intéressant car il me permet d'approcher les limites du logiciel quand on ne l'utilise sans aucun patch (et que, par extension, il me permet de voir des fonctionnalités que j'aurais oublié d'implémenter dans mon script "Event Extender" qui vise, rappellons le, à offrir plus de fonctionnalités aux évènements de RPG Maker).
Créer un système de jeu avec les évènements est souvent fort ingrat, car l'interface n'offre généralement que le strict minimum. Nous allons donc voir dans cet article, une petite ruse de sioux pour contourner un problème imposé par le logiciel et pour offrir à nos systèmes de jeu plus de modularité et prôner la réutilisabilité.
Une fois de plus, je m'esquive à parler de programmation, mais je pense qu'il est toujours intéressant de garder une trace écrite de nos petites découvertes.
Les initiés à RPG Maker trouveront sans aucun doute ce tutoriel inutile (parce qu'il présente une manière très logique et assez intuitive de contourner un soucis) mais j'espère que certains "plus" néophytes y trouveront un intérêt !
Bonne lecture.

Une fonction?

En programmation, il est très courant de manipuler des fonctions. Sans rentrer dans des explications historiques et terminologiques sur ce que sont les fonctions (et les nuances entre méthodes, fonctions et procédures), nous allons admettre qu'une fonction est une manière de transformer une portion de code en un outil pour le rendre facilement réutilisable.

Une fonction qui affiche un message
Admettons que dans un programme, nous ayons à afficher plusieurs fois "Hello World", plutôt que d'utiliser plusieurs fois l'affichage de chaine de texte, nous pourrions écrire une fonction, par exemple, en Ruby :

Code:

def hello
  p "Hello World"
end

A l'appel de "hello", notre application affichera "Hello World". Ce genre de comportement est très facilement réalisable avec RPG Maker, il suffirait d'utiliser un évènement commun, voici sa définition :



Et voici un exemple d'utilisation :



A chaque fois que j'utiliserai l'appel d'évènement commun "Hello", RPG Maker m'affichera un message avec "Hello World".
Rien de très compliqué, intéressons nous maintenant à une autre problèmatique.

Des fonctions qui prennent des arguments (et qui retournent des valeurs)

Par exemple, admettons que notre langage favoris ne dispose pas de manière de récupérer la valeur absolue d'un nombre, nous savons que si un nombre est positif, alors sa valeur absolue est lui même et que si il est négatif, sa valeur absolue est (0-lui même). Donc "sa version positif", son opposé.
Voici par exemple, une petite implémentation d'une fonction qui donne la valeur absolue d'un nombre en OCaML :

Code:

let abs x =
  if x < 0 then -x
  else x;;

En essayant de réaliser cette fonction avec un évènement commun, on se retrouve très vite confronté à plusieurs problèmes. Le premier est, comment spécifier un argument à une fonction. (Dans notre exemple, abs x, x est l'argument) et comment lui faire "renvoyer un résultat" ? Car dans mon exemple OCaML, notre fonction abs prend un nombre en argument et renvoi sa valeur absolue !
C'est ce genre de cas de figure que nous allons étudier dans cet article.

Les variables globales

Dans RPG Maker, une variable (des évènements) est toujours globale. Ce que je veux dire par là, c'est ce que ma variable est accessible de partout. Donc si je donne à une variable la valeur 8, et que je demande à un autre évènement d'afficher la valeur de ma variable, il m'affichera bien 8.
Nous allons donc pouvoir utiliser des variables "globales" qui auront pour rôles d'être injectée dans des évènements communs et faire office d'arguments. Il s'agit d'une forme de "bufferisation". En effet, on place notre variable à modifier dans un "tampon", on modifie ce tampon et ensuite on dit que notre variable est équivalente au tampon.

La bufferisation, concrètement
Concrètement, notre évènement commun ne se contentera "que" de modifier une variable dont nous connaissons l'identifiant, ce qui fait que pour simuler ce passage d'argument, on attribuera à une variable "tampon" la valeur sur laquelle on désire effectuer une transformation, ensuite, dans notre évènement commun, on travaillera sur cette variable et une fois que la procédure de l'évènement commun est finie, on sait que la variable tampon possède la bonne valeur et il est possible de l'attribuer à une autre variable.



Essayons de voir ce que cela donnerait avec une fonction qui a pour but de calculer une valeur absolue.
Premièrement, il faut un évènement commun que nous appellerons "Valeur absolue", voici le code que j'ai utilisé (merci Hiino pour la simplification )



Pour utiliser cette fonction, il suffit d'attribuer la variable que l'ont veut changer (pour qui on désire connaitre la valeur absolue) à notre variable 1, Buffer Absolu, appeler l'évènement commun "Valeur absolue" et je sais qu'une fois que l'évènement commun aura été exécuté, ma variable Buffer Absolu aura la valeur absolu de la valeur que je lui avais donnée avant d'appeler mon évènement commun.

Considérations
Cet exemple n'est pas excellent car le calcul d'une valeur absolue est vraiment trop court pour qu'en créer une fonction (qui, en Event-Making, est tout de même une procédure gourmande, car il faut donner la bonne valeur au bon "buffer" et ensuite il faut récupérer la valeur du buffer, soit 3 lignes, le même nombre de lignes que notre procédure ^^').
Nous allons donc voir deux cas de figure qui, selon moi, sont assez intéressants.

Isoler un entier dans un nombre

Imaginons que nous ayons un nombre, 12345 par exemple, et que nous voudrions uniquement sa dizaine?
Le calcul est assez simple, la dizaine correspond à la 2ème puissance de 10, donc notre dizaine serait égal à (12345%10^2)/10^1, donc (12345%100)/10 qui nous donnera 4.
Pour ceux qui ne sont pas familier avec les modulos, un modulo est le reste d'une division entière, donc 12345 divisé par 100 donne 123 et il reste 45, le modulo nous donne ce 45 et ce résultat divisé par 10 donne 4.
Voici un petit évènement commun que j'ai rédigé qui nous donnera donc, en fonction de deux variables, un nombre et la position du nombre à isoler (1 = unités, 2 = dizaines, 3 = centaines etc.) le chiffre s'y rapportant :



Dans cet exemple, on peut voir un autre soucis ennuyeux, l'absence de l'opérateur "puissance/exposant" que j'ai du simuler au moyen d'une boucle... ce n'est vraiment pas performant mais j'ai fait avec les moyens du bord.
Voici un exemple d'utilisation :



Je trouve personnellement que n'avoir plus qu'a écrire deux variables et un appel d'évènement est plus commode (et facile) que de copier/coller, chaque fois, la grosse séquence de code proposée en évènement commun.
Avec cette méthode, il devient très aisé de stocker plusieurs chiffres (et de les récupérer) dans une seule variable. Cela sera peut être le thème d'un prochain article !

Compter le nombre de chiffres qui composent un nombre

L'idée est ici, de diviser successivement le nombre avec un compteur jusqu'à ce qu'il atteigne zéro :



Le passage par la valeur absolue n'est absolument pas obligatoire c'était pour mettre un exemple de l'utilisation de l'évènement commun que nous avions précédemment créé.
Ce serait assez ennuyeux s'il fallait chaque fois copier/coller ce code, voyez plutôt comme je m'en sers dans cet exemple :



Avec un peu d'imagination, vous devriez comprendre en quoi l'association de ces deux derniers évènements communs pourrait servir de base à un outil de stockage de plusieurs chiffres dans une seule variable.

Conclusion

C'est ici que je conclu ce très court article.
Il présentait une approche qui vise à limite la réécriture. Je suis conscient de n'avoir rien "inventé", j'ai juste voulu partager une astuce dont je me sers régulièrement pour composer mes systèmes de jeu via les évènements.
J'espère que certains y auront trouver un intérêt, n'hésitez pas à partager vos évènements communs réutilisables dans les commentaires (olalala Pierre, ce que tu es utopiiiste... personne ne vient sur ce bloooog xD) ou formuler des critiques, positives comme négatives ! Joyeux carnaval ou nouvel an asiatique !
A bientôt !