Tuto RME base: Interrupteur/varriable/labels + locaux

Before: Tuto RME base: RME builder utilisation

Yahallo,

Voici un pitit explicatif de comment que ca marche les variable/ interrupteur et blabla sur RME.

Une syntaxe plus légère

Les variables et les interrupteurs sont très utilisés dans la création de jeu RPG Maker. En général, les fenêtres du logiciel permettent d'affecter des variables à certaines valeurs (par exemple la position x et y d'une image ou encore les coordonnées de téléportation du héros), cependant, leur utilisation dans un appel de script est long. Pour appeler une variable et un interrupteur, la syntaxe est comme ceci :

$game_variables[id désiré] pour accéder à une variable
$game_switches[id désiré] pour accéder à un interrupteur

Le premier objectif de ce script aura été de simplifier l'accès aux variables et aux interrupteurs. Maintenant il suffit d'utiliser les lettres V (pour les variables) et S (pour les interrupteurs).
Leur syntaxe est donc comme ceci :

V[id désiré] pour accéder à une variable



S[id désiré] pour accéder à un interrupteur


L'attribution de valeur à une variable devient donc très facile. Par exemple, pour donner la valeur 134 à la variable 98, il suffira de faire, dans un appel de script (ou dans un script complet) : V[98] = 134

Étant donné qu'il est possible d'utiliser cette syntaxe partout, il serait tout à fait envisageable de faire : V[V[12]] = V[1]+V[2]*V[3]
Ce qui correspond à dire que la valeur de la variable 12 sera l'ID de la variable que l'on modifie, et qu'on lui donnera la valeur de la variable 1 plus le produit de la variable 2 et de la variable 3. Il existe une série d'opérateur en plus de + et *, voici une liste rapide (et potentiellement non exhaustive) des opérateurs possibles :

Opérations arithmétiques

+ Addition, par exemple V[1] = V[2] + V[3]
- Soustraction, par exemple V[5] = V[3] - 3
* Multiplication, par exemple V[10] = 7 * V[9]
/ Division entière (5/2 = 2), par exemple V[8] = 2/4 + (V[11] / 3)
** Puissance (3 ** 2 = 9), par exemple V[6] = V[1] ** V[2]
% Modulo, le reste de la division entière, par exemple V[1] = V[2] % 4

Simplification syntaxique

Il existe un petit raccourcis syntaxique pour compresser certaines expressions :

x += y : x = x + y
x -= y : x = x - y
x /= y : x = x / y
x *= y : x = x * y
x %= y : x = x % y

Cette notation peut être évidemment plus complexe. Par exemple : V[1] += (10 * (V[2] ** 2)). Comme pour les opérations arithmétiques classiques, les parenthèses permettent de changer les priorités des opérations.

Même si cette extension peut sembler superflue, elle permet de gagner un temps incroyable. Je vous invite à essayer de faire l'expression précédente (V[1] += (10 * (V[2] ** 2))) en Event Making classique, vous verrez que ça prendra beaucoup plus de lignes et de temps.

Les variables locales

Pour certains, cette partie peut paraître plus abstraite, cependant, je vous assure que les variables locales permettent beaucoup de flexibilité dans la construction de systèmes avec les évènements.

Une variable locale est presque identique à une variable globale (les variables normales de RPGMaker, accessibles via V[ID]), si ce n'est qu'elles sont référencées par 3 ID's et non un seul.

L'ID de la map
L'ID de l'évènement
L'ID de la variable

L'avantage est qu'il est possible de créer une variable en ne spécifiant que son ID à elle, et le script automatisera l'attribution des deux autres ID.
Quel est l'avantage ? Cela évite la création de variables globales pour des utilisations uniquement au sein d'un évènement, ça permet de copier/coller ses évènements (qui utilisent des variables locales) sans devoir modifier les variables qu'ils utilisent et ça augmente aussi considérablement le nombre de variables disponibles.

Personnellement, je m'en sers souvent pour stocker des résultats dont je n'ai besoin QUE dans un évènement ou qui sont propres à cet évènement. De plus il est possible d’accéder aux variables d'un autre évènement et même d'une autre map car ces adresses sont purement virtuelles, donc il est possible d'associer des variables à des évènements qui n'existent pas.

Syntaxe des variables locales

A la différence des variables globales, on utilise cette fois SV[id_de_la_map, id_de_levenement, id]. SV pour self variables.
Comme il a été dit dans le paragraphe précédent, on peut ne spécifier que l'ID d'une variable locale et RME inférera l'ID de l'évènement qui l'appelle et l'ID de la carte où se trouve l'évènement.
Imaginons une carte (numéro 23) sur laquelle on peut trouver plusieurs évènements dont l'évènement 4 qui appellera ces différentes variables locales :

SV[5], comme c'est l'évènement 4 de la carte 23 qui appelle cette variable locale, la variable sera donc la variable SV[23, 4, 5].
SV[2, 8], cette fois on appelle en fait la variable SV[23, 2, 8]
SV[12, 3, 1], ici toutes les informations sont données, on appelle donc la variable n°1 de l'évènement 3, se trouvant sur la carte numéro 12

Opérations sur les variables locales

Tous les opérateurs présentés dans la section sur les variables sont compatibles avec les variables locales. Par exemple :

SV[5] += V[6] : Ajoute à la variable locale 5 (située dans un évènement quelconque) la valeur de la variable 6
SV[1,2,3], V[2] = V[2], SV[1,2,3] : intervertit les valeurs de la locale 3 située dans l'évènement 2 de la carte n°1 avec la valeur de la variable 2.

Attention!, l'utilisation des intervalles (V[1...10], par exemple)ne fonctionnent pas pour les variables locales.

Quand faut-il privilégier les variables locales

A priori, les variables locales peuvent faire tout ce que permettent de faire les variables normales. Cependant, je conseille de ne s'en servir que pour des variables propres à un seul évènement. Par exemple, les points de vie des ennemis dans un A-RPG, ou encore pour les points de réputation pour les rendre propres à chaque évènement.


Comme pour les variables, les interrupteurs sont accessibles via un raccourci, S[ID]. On ne peut donner que deux valeurs à des interrupteurs, true, signifiant que l'interrupteur est activé ou false, indiquant que l'interrupteur est désactivé. Voici quelques expressions :

S[1] = true : active l'interrupteur 1
S[2] = false : désactive l'interrupteur 2
S[3] = S[1] : donne à l'interrupteur 3, la valeur de l'interrupteur 1

Opérations logiques

Alors que les variables étaient munies d'opérations arithmétiques, les interrupteurs sont liés d'opérations logiques. On peut donc combiner des interrupteurs:

S[1] or S[2], pouvant s'écrire aussi S[1] || S[2] renverra une expression vraie si l'un des deux est vrai
S[1] and S[2], pouvant s'écrire aussi S[1] && S[2] renverra une expression vraie si les deux sont vrais
!S[1], pouvant s'écrire aussi not S[1] renverra l'inverse de l'expression.

Comme pour les opérations arithmétiques, les opérations logiques peuvent être composées. Par exemple une expression telle que : (S[1] and S[2]) or (not S[3]) (strictement équivalente à (S[1] && S[2]) || (!S[3])) est parfaitement valide.

Constructions de valeur pour les interrupteurs

Dans RPGMaker, on a tendance à ne faire que "activer" ou "désactiver" des interrupteurs. Pour activer (ou désactiver) un interrupteur on utilise en général une condition. Par exemple : Si ma variable 5 est plus grande que 6, alors j'active l'interrupteur 3, sinon je le désactive".

C'est assez verbeux et long, alors que concrètement, l'expression de la variable 5 est plus grande que 6 est déjà une expression qui vaut true ou false. Donc on pourrait simplifier ce genre de comportement par :S[3] = ma variable 5 est plus grande que 6?`. Nous allons survoler, dans cette section, comment produire des valeurs valides pour un interrupteur. Combinés avec des opérateurs logiques, vous verrez qu'il sera possible de représenter énormément de cas de figure et donc d'économiser des conditions !
Opérateurs de comparaison

Il existe, dans Ruby, des opérateurs permettant la comparaison de valeurs. Nous allons en survoler quelques uns.

x == y : renvoie true si est x égal à y, false sinon
x != y : renvoie true si est x différent de y, false sinon. (Donc x != y est identique à !(x == y)`
x > y : renvoie true si est x est strictement superieur à y, false sinon
x < y : renvoie true si est x est strictement inférieur à y, false sinon
x >= y : renvoie true si est x est superieur ou égal à y, false sinon
x <= y : renvoie true si est x est inférieur ou égal à y, false sinon.

Au travers de ces opérateurs il est possible de composer des expressions plus complexes. Par exemple, si je veux activer un interrupteur si ma variable 13 est plus grande que ma variable 12, et que la somme de ma variable 7 et de ma variable 8 donne un multiple de deux ou simplement que l'interrupteur est déjà activé, je pourrais simplement écrire ça : S[1] = S[1] or ((V[13] > V[12]) and (V[7] + V[8])%2 == 0). Comme vous pouvez le voir, le parenthèsage me permet de m'en sortir lors de la rédaction d'expressions complexes.

Note sur les conditions

Une condition (en Ruby ou dans un évènement) n'est exécutée que si son entrée vaut true. Sinon, elle rentre dans le Sinon, le else. Donc comme un interrupteur est, en amont, toujours égal à true ou false, la condition ne s'exécutant que si un interrupteur est activé peut se limiter à :

Si Script : S[1] alors
code si l'interrupteur est acitvé
Sinon
code si l'interrupteur n'est pas activé
fin condition

Tout ce qui a été survolé précédemment est donc toujours d'actualité dans les conditions. Par exemple, je peux tout à fait formuler une question de cette forme : Si Script > V[1] == 10 and (V[3] + 4 > V[10]) and (not S[5]) Qui en français, correspondrait à "Si la variable 1 est égal à 10 et que la somme de la valeur de la variable 3 et 4 est plus grand que la valeur de la variable 10 et que l'interrupteur 5 est désactivé".

Pointeurs

On peut spécifier n'importe quelle expression Ruby valide qui retourne un entier comme index de variable ou d'interrupteur. Par exemple S[1+2+3] désigne l'interrupteur 6. Ou encore S[V[10]] qui désigne l'interrupteur dont l'index est défini par la valeur de la variable 10 ou encore V[(V[10]+V[11])*3] qui désignera la variable dont le numéro est la somme de la variable 10 et de la variable 11 multiplié par trois. Quand nous verrons les commandes, dans une section suivante, vous verrez que certaines des commandes renvoient des entiers, il serait donc très original, mais possible, en utilisant, par exemple, la commande mouse_x, qui renvoie la position X de la souris sur l'écran, de faire une expression de cette sorte : V[mouse_x], mais je ne connais pas de cas de figure où ce serait utile !

Jutsus complémentaires

Nous allons voir quelques petites techniques particulières, capables de faire gagner du temps dans des cas précis. Ces techniques ne sont pas primordiales, mais permettent de comprendre quelques petits points servant l'expressivité de RME (les exemples sont donnés pour les variables et les interrupteurs mais fonctionnent toujours que ce soit pour les variables ou pour les interrupteurs).

V[1], V[2] = V[2], V[1] intervertit les valeurs de la variable 1 et 2
S[7..29] = true active du 7ème interrupteur au 29ème interrupteur

Les interrupteurs locaux

Cette fois ci, il ne s'agit pas d'un ajout, mais comme pour les variables et les interrupteurs, il s'agit d'un simple raccourci syntaxique.
Les interrupteurs locaux fonctionnent comme les interrupteurs normaux avec le même système d'adressage que les variables locales. La seule différence est qu'ils sont limités à 4. Et on y accède via une lettre (A, B, C ou D) ou via un entier, 1, 2, 3 ou 4 (1 = A , 2 = B etc.) et qu'on utilise la primitive SS (pour self switches) pour y accéder par exemple : SS["A"] (le A doit bien être entre guillemet) ou alors SS[1]. Son système d'adressage fonctionne exactement de la même manière que les variables locales donc il est possible d'accéder aux interrupteurs locaux d'autres évènements.
Comme pour les variables locales, les opérateurs logiques et la négation sont compatibles avec les interrupteurs locaux.



Les labels et les labels locaux fonctionnent exactement comme les variables et les variables locales à la différence que leur identifiant (l'identifiant de variable dans le cas des labels locaux) sont référencés par des symboles (un mot commençant par :, par exemple :truc, :chevre, :point_de_vie) et non par des nombres.

En gros, c'et le mariage des variables et des intterupteurs.

Syntaxe

L[:symbol] : Accès au label :symbol
L[:symbol] = 10 : Donne 10 comme valeur au label :symbol
SL[:symbol] : Accès au label local :symbol
SL[id_map, id_event, ] : Pour un accès complet
SL[id_map, id_event, ] = 45

Utilité

Lorsque vous faites vos système avec RME, au début sa va mais à force de manipuler V[1], V[2], V[666], etc... vous perdrez vite les pédale.
C'est pourquoi les labels sont magique, vous transformez vos V[1] = 42 en L[:position_X_héro] = 42

Conseils de Kingdo

Il faut faire attention à la syntaxe, si vous utiliser:
L[:position X image] = 666 puis vous voulez changer par L[:position ximage] = 777, l'image ne bougera pas pourquoi?
Parce que la syntaxe n'est pas exactement la même.

Pour éviter tout problème de ce côté je conseille:
-Utiliser _ du 8 à la place des espaces pour éviter les patés genre L[:positionXhéro]
-Copier/Coller l'original s'il est long


Comme les variables sont affichables dans les messages, il est aussi possible d'afficher les labels, les labels locaux et évidemment les variables locales. Pour ce faire, il suffit de précéder leur appel par \. Exactement comme pour les variables normales. Par exemple

Afficher_message "Hey, la variable locale n°5 de l'événement n°2
de la map n°1 est égale à \SV[1,2,5], sans déconner !
Même que le label :salut vaut : \L[:salut] !"

Comme dans un appel de script, vous pouvez spécifier partiellement les arguments pour les éléments locaux.

Merci pour ton tutoriel ! =)
Des points!