[RGSS]I-Introduction - Les variables

Tutorial réalisé pour Zenith RPG par Bahamut 1.2, merci de demander l'autorisation avant de le copier ailleurs.

Ce tuto (monstrueux niveau longueur^^) a pour but d'introduire les bases du RGSS, le Ruby de RPG Maker XP. L'avantage si vous maîtrisez un minimum les événement c'est que le RGSS y ressemble énormément, en fait ce serait plutot l'inverse, logique puisque c'est le langage utilisé dans les projets RM.
Ce tutorial se veut surtout pratique, mes connaissances étant limitées sur ce sujet, je vais rapidement rentrer dans le vif du sujet, mais vous aurez déjà quelques possibilités, surtout qu'un deuxieme tuto arrivera bientot.
En tout cas ne soyez pas rebutés par le Ruby/RGSS, car aussi complexe qu'il ait l'air, il a été pensé pour être pratique et logique, au même titre que chaque langage de programmation !

Voici le plan de ce tutorial :

I-Les variables et booléens
II-Opérations sur les variables
II-Les flottants
IV-Opérations sur les booléens
V-Infos complémentaires sur les variables et booléens
VI-Les variables des événements de RPG Maker



I-Variables et booléens
On va donc directement commencer à parler variables. Si vous ne maîtrisez pas ça ce n'est pas la peine de continuer, je vous invite donc à lire un tuto sur le sujet.
Bon vous vous demandez surement ce qui se cache derriere le nom barbare de "booléen" ? Je vais mettre les choses au clair tout de suite, histoire d'éviter de vous prendre la tête ! Les booléens c'est ni plus ni moins que le "vrai" nom des interrupteurs, switchs et autres boutons qui désignent tous la meme chose sous RPG Maker (quand vous utilisez les événements). Comprenez bien que ces quatre noms désigent exactement la même chose, booléen est le nom que l'on leur donne en programmation, car vous vous doutez surement qu'ils sont utilisés ailleurs que dans RPG Maker ! Voilà maintenant vous savez ce qu'est une variable et un booléen, compliquons (un tout petit peu) les choses.
En ruby on distingue trois types de variables, voici d'abord un exemple de chaque :
$variable : variable globale
@variable : variable de classe
variable : variable locale
Vous en avez surement déjà croisé si vous avez exploré les scripts de RM...Quelles différences y a t il entre ces trois types de variables, pourquoi yen a-t-il trois d'ailleurs ??
Tout d'abord les variables globales, commençant par le signe $ sont déstinées à être utilisées dans tout le programme, autrement dit on peut s'en servir n'importe quand, par exemple les variables utilisées en événements sont des globales. Ainsi comprenez bien que les variables locales (commençant par @)et de classe (impérativement ecrites en minuscules)ne peuvent pas être utilisées n'importe quand ! En fait les variables locales et de classe sont automatiquement "détruites" dès que le programme n'a plus besoin d'elles, elles ne sont utilisables respectivement que dans une classe, ou une fonction. Classe ? Fonction ? Je vous parlerai de tout ça dans le prochain tutorial, pour l'instant nous travaillerons sur des globales, donc des variables utilisables n'importe où dans le logiciel.


II-Opérations sur les variables
Tout comme avec les événements il est évidemment possible d'effectuer toutes sortes d'opérations sur nos variables, additions, soustractions et compagnie. Voici quelques opérations réalisables, et à coté le symbole à utiliser pour demander au programme de les effectuer (vous allez voir c'est vraiment pas compliqué...) :
Addition : +
Soustraction : -
Division : /
Multiplication : *
Puissance : **
Rendre égal : =
Voici maintenant un exemple concret. On veut rendre notre variable égale à 5, tout simplement, ce qu'on aurait pu faire en événements bien sur. Il suffit d'ecrire :

Code:

$variable = 5

Avouez que ça aurait pu etre pire. Ainsi on a donné directement une valeur à notre variable, mais on peut faire bien d'autres choses plus intéressantes, comme ajouter 5 à notre variable. Voici comment on pourrait faire :

Code:

$variable = $variable + 5

On pourrait faire ça, ça marche très bien. Seulement ça fait bizarre de répéter "$variable", et le but de tout langage de programmation étant de vous simplifier la vie en vous faisant ecrire le moins possible, voilà une syntaxe plus appropriée :

Code:

$variable += 5

Evidemment ça semble tout de suite moins naturel, mais ça reste compréhensible, avant on disait "$variable vaut $variable + 5", et maintenant "on ajoute 5 à $variable". Ne soyez surtout pas rebutés par cette façon de faire, au bout de quelques opérations vous serez habitués. Ainsi on peut bien sûr effectuer d'autres opérations exactement de la meme maniere, comme par exemple :

Code:

$variable -= 1

Soustraction de 1

Code:

$variable *= 12

Multiplication par 12

Code:

$variable **= 2

Elevée à la puissance 2 (au carré)
Voici donc une vraie petite calculette. Mais souvenez vous des regles de priorités aux calculs, apprises au college :p Pourquoi je vous parle de ca ? Regardez cette exemple :

Code:

$variable *= 6+4

En mathématiques la multiplication a la priorité, ainsi si on fait 2*6+4, ca nous donne 12+4=16. Or si vous faites le code ci dessus avec votre $variable egale à 2 vous n'obtiendrez pas 16 comme résultat. En fait le programme va faire comme si vous aviez mis des parenthèses à 6+4, c'est a dire qu'il va commencer par additionner les deux chiffres et ensuite multiplier par $variable. Comprenez donc bien que Ruby va d'abord calculer l'expression de droite avec de faire l'opération "principale" que vous lui demandez.
Pour clore ce chapitre, sachez que vous pouvez effectuer exactement les memes opérations avec plusieurs variables, entre elles. Voici un exemple rapide, mais tout marche de la meme maniere.

Code:

$chiffre_1 += chiffre_2

J'en profite pour vous dire de ne jamais mettre d'espace dans le nom d'une variables, ni de tiret qui pourrait etre interprété comme un signe "moins".
L'heure est venue de parler des flottants, ça va nous détendre. Je ne sais pas si c'était la peine de leur dédier un chapitre mais celui là commence à etre long...


III-Les flottants
Encore un nom tres barbare pour pas grand chose, rassurez vous. Les nombres flottant désignent tout simplement les nombres à virgule. Si vous avez remarqué on n'en a pas encore utilisé, parcequ'en fait il ya quelques petites subtilités à connaître. Mais dans 2 minutes vous saurez tout !
Prenons en exemple une opération simple.

Code:

$variable = 10/2

Comprenez bien que dans la pratique ce code est idiot puisqu'on aurait pu mettre directement 5 au lieu de 10/2 (car 10 divisé par 2 ça fait 5 pour ceux qui en doutent encore^^). Donc bon ici pas de probleme, le programme fait l'opération et renvoie 5 en résultat. Prenons maintenant un autre exemple :

Code:

$variable = 5/2

$variable vaut alors en théorie 2,5. Oui mais non. Pour ruby variable vaut 2. Tout rond. En fait le programme ne va même pas se donner la pein d'arrondir, il tronque, c'est-à-dire qu'il ne garde que la partie entiere. En fait c'est parce qu'on n'a utilisé que des nombres entiers. Il faut donc "signaler" que nous, ce qu'on veut, c'est utiliser des chiffres à virgules, des flottants quoi. Pour le faire c'est simple il suffit dans l'opération d'utiliser des flottants. Ainsi il faudrait ecrire :

Code:

$variable = 5.0/2.0

On obtient alors le résultat de 2.5 et non plus 2. Notez qu'il faut mettre un point et non une virgule dans les flottants, car c'est la notation américaine et elle est utilisée dans tous les langages de programmation. Il suffit en fait de mettre un flottant pour que le programme détermine tout seul le nombre de chiffres à utiliser (c'est ma découverte du jour). Il suffit aussi d'avoir un chiffre flottant dans l'opération pour que le résultat soit un flottant.

Code:

$variable = 5.0/2.0
$variable = 5/2.0
$variable = 5.0/2
$variable = 5.000000000000000/2
$variable = 5.0000000/2.00000000000000000000000000000000

Toutes ces opérations donneront le même résultat, de 2.5.
Pour les nombres à virgules avec une infinité de chiffres décimaux il faudra se contenter de 15 chiffres apres la virgule (enfin ça devrait suffire^^"). Par exemple 10/3.0 donnera 3.333333333333333 (rappel : 10/3 donnera simplement 3).
Si vous faites une division, privilégiez les flottants car le résultat à de fortes chances d'être un chiffre à virgule. Ainsi se termine le chapitre des flottants, parlons un peu des booléens maintenant, ça va aller vite je vous rassure


IV-Opérations sur les booléens
Les booléens fonctionnent comme les variables, à la diffrérence qu'il ne peuvent prendre que 2 valeurs que l'on appelle true et false (respectivement "vrai" et "faux" en anglais), qui correspondent à ON et OFF pour les "boutons" utilisés dans les événements. Tout fonctionne comme enévenement, la seul différence est qu'on remplce ON par true et OFF par false. En toute logique on ne peut pas faire d'opérations à proprement parler sur des booléens, seulement les rendre égaux à true ou false. Pour ça on utilise le signe =.

Code:

$booleen = true

Vous remarquerez le $ qui montre bien que les booléens fonctionnent comme les variables, seule la valeur que vous lui donnez différencie un booléen d'une variable.

V-Infos complémentaires sur les variables et booléens
Voici deux trois trucs très importants qui différent de l'utlisation des variables et booléens dans les événements.
Tout d'abord les variables utilisées en événements sont toutes "réglées" au lancement du jeu sur la valeur 0, autrement dit au démarrage d'une partie toutes les variables utilisables en événements valent 0. De la même manière les interrupteurs sont sur OFF (false). Comprenez bien que ces variables et interrupteurs sont aussi manipulables avec le RGSS. Cependant les autres variables, avant que vous ne les créeez, ne sont pas égales à 0, elles n'existent pas, et il en va de même pour les booléen. Leur valeur est nil, c'est la valeur donnée en ruby à un "objet" qui n'existe pas. Je vais vous expliquer l'utilité de nil. Prenons par exemple ceci :

Code:

$variable += 1

On demande d'ajouter 1 à $variable. Mais si c'est la première fois qu'on utilise cette variable, le jeu va planter car $variable n'existe pas encore et n'a pas de valeur. De plus il ne sait pas si $variable fait référence à une variable ou un booléen...En revanche si on a déjà défini une valeur de $variable :

Code:

$variable = 0

on pourra ensuite lui faire subir toutes les opérations qu'on veut (nirak niark !), car on sait maintenant qu'elle vaut 0. Avant on voulait ajouter 1 à une variable qui n'avais aucune valeur, sa valeur était nil, donc forcément, c'est impossible. Justement, nil dans tout ça ? Il nous servira surtout dans les conditions, où on vérifiera d'abord que la variable existe (donc est différente de nil) avant de la manipuler. Mais les conditions seront abordées dans un autre tutorial. Abordons maintenant le sujet des string. Je savais que ça allait vous plaire !
En événement une variable peut avoir un quasi infinité de valeurs, de 1 à 99 999 999. Cependant en codant en RGSS on peut également donner aux variables (même à celle des événements, voire le dernier chapitre) des valeurs qui, au lieu d'etre des chiffres, sont des chaînes de caractères, string en anglais. Par exemple le nom d'un héros, c'est une variable, on n'a pas besoin d'aller dans le code source du jeu pour le définir, et il peut éventuellement changer au cours du jeu. Pour donner une valeur "string" à une variable, il suffit de la mettre entre guillemet et d'utiliser le signe =.

Code:

$nom = "Arshes"

Ainsi on pourra réutiliser cette valeur plus tard pour afficher le nom du héros^^ Bien évidemment on ne peut pas additionner, soustraire etc de chiffres à ce genre de variables.
Par contre on peut "additionner" ces variables entre elles ou avec d'autres chaines de caracteres. Par exemple :

Code:

$nom = "Arshes"
$presentation = "Je m'appelle " + $nom

$présentation aura pour valeur "Je m'appelle Arshes". Surtout ne mettez pas de guillemets à $nom ou bien il sera affiché tel quel. Et mettez un petit espace après "Je m'appelle" ou ce sera collé^^
Bon imaginons que l'on demande à Arshes de dire combien il a d'épées dans sa collection. On pourrait faire comme ceci :

Code:

$nombre_epees = "24"
$presentation = "Je possède " + $nombre_epees + "épées dans ma collection"

Ca marche. Mais $nombre_epees ne contient pas un chiffre mais une chaine de caractère, car on a mis des guillemets. Ruby ne fait donc pas la différence on aurait pu aussi bien écrire "tartiflette" que ça n'aurait dérangé personne (enfin si parceque la phrase ne voudrait plus rien dire). Enfin bref, tout ça pour dire qu'il serait plus logique d'utiliser une variable contenant un chiffre, comme ça on pourrait effectuer des opérations dessus. Par exemple rajouter 1 à chaque fois que Arshes trouve une épée...
Si on ecrit ce code :

Code:

$nombre_epees = 24
$presentation = "Je possède " + $nombre_epees + "épées dans ma collection"

Ca plante !! Pas de panique. Pour commencer j'esper que vous avez remarqué, on a simplement enlevé les guillemets de la premiere ligne, $nombre_epees est donc une variable contenant une valeur chiffrée, ici 24, et on pourrais lui faire subir des opérations. Mais bon notre bout de code ne marche pas, tout simplement parceque la variable $presentation est la somme de deux variables "string" et d'une chiffrée, on ne peut donc pas savoir si $presentation est un chiffre ou un texte. Bien sur, nous on veut que ce soit un texte. Il faut donc "transformer" $nombre_epees en un texte. Pour effectuer ce tour de magie on ajoute à la fin du nom de la variable .to_s , le s correspondant à "string". Et on fait ça dans la derniere ligne, pas la premiere !!

Code:

$nombre_epees = 24
$presentation = "Je possède " + $nombre_epees.to_s + "épées dans ma collection"

On laisse la premiere ligne telle quelle, le .to_s permet d'afficher la valeur de la variable, mais celle ci possède toujours une valeur chiffrée.
Si vous préférez, $nombre_epees a une valeur chiffrée alors que $nombre_epees.to_s contient du texte. Vous pourrez toujours utiliser $nombre_epees avec des chiffres.
Notez que l'opération inverse peut etre effectuée, si une chaine de caractere contient un chiffre on peut utiliser .to_i pour y faire des opérations. Par exemple en reprenant ce code :

Code:

$nombre_epees = "24"

on peut quand meme effectuer des opérations sur le chiffre 24 grâce à $nombre_epees.to_i Le i renvoie en fait à integer, qui désigne un nombre contrairement à string. Vous comprenez alors un peu mieux certains messages d'erreurs. Toujours est-il que c'est bien moins utilisé que .to_s, et que ça peut facilement provoquer un plantage si votre variable contient des lettres, car le jeu ne pourra pas les convertir en chiffres ("cannot convert string into integer" ça vous dit peut etre quelque chose).
En réalité en ruby les variables peuvent etre encore d'autre chose, en fait une variable peut etre absolument tout et n'importe quoi, mais c'est une autre histoire^^


VI-Les variables des événements de RPG Maker
Voici enfin le dernier chapitre de ce tutorial !
Je vais commencer par vous dire comment utiliser en Ruby les variables et interrupteurs des evenements. C'est tres simple :
: Variable dont l'ID est # (remplacer par le n°)
$game_switches[#] : Interrupteur dont l'ID est # (remplacer par le n°)
Comme je l'ai dit au debut vous remarquer que ces variables sont des globales car elles commencent par $. En fait toutes les variables dont je vais vous parler dans la suite sont des globales. En fait vous allez maintenant pouvoir tester ce que je vous ai appris. Comment ? Faites un evenement, insérez votre script, et affichez un message par cet evenement qui sera la valeur de la variable que vous manipulez, en faisant \v[1] pour afficher la valeur de la variable d'ID 1, c'est à dire $game_variables[1] (ou utilisez le debuggeur F9). Essayez donc les divers exemples que je vous ai montrés tout au long du tutorial.



Je ferai bientot une annexe présentant toutes les variables utilisées dans un projet, comme les HP d'un perso, son niveau etc.
Pour l'instant ce tutorial s'achève (enfin ç afit 3h que j'y suis !) et je reste ouvert à toutes les questions en attendant le prochain !!

Très bon tuto Bahamut 1.2.

Merci !

De rien, content d'avoir eu une réponse^^