Bienvenue
visiteur !

Par Fabien Nicolas
(que nous remercions chaleureusement!)

Afficher l'introduction

Utiliser le ruby sous Rmxp

Ceci s'adresse au gens qui maîtrisent les bases de Rpg maker, par exemple ceux qui font la transition de RM2K3 vers RMXP. Je ne vais pas réécrire l'aide rmxp, qui est déjà très complète. Je veux seulement donner une approche pratique je rappellerais les choses les plus utiles, mais pour quelque chose plus approfondie, voyez l'aide RMXP et des documents plus généraux sur la programmation.

La plupart des langages ont des points communs, ceux qui maîtrisent déjà la programmation n'auront pas de problème avec le ruby.

Juste quelques précisions avant de commencer ce tuto : Je n'ai jamais suivi aucun cours de programmation, j'ai tout appris sur le tas, parfois en grappillant des infos sur le net, parfois en épluchant des scripts d'autrui, mais surtout en faisant des essais et en m'en prenant plein la gueule parce que ça ne marchait pas. (et croyez moins : ça ne voulait pas marcher ! j'en ai bavé.) alors même si tout ceci peut vous servir de base, je n'ai pas l'ambition d'être capable de rédiger un tutorial de professionnel, tant au niveau des connaissances en programmation qu'au niveau rédaction. De plus, ous comprendrez bien mieux comment fonctionnent les choses si vous faites vingt essais (tous des échecs bien sur !) que si vous lisez vingt fois le meilleur des tutoriels. En fait à mon gout il faut lire une présentation avant de commencer, pour saisir à quoi les choses ressemblent, puis faire un gros paquet de pratique, puis revenir vers la théorie. Puis osciller entre les deux.
Autre chose : j'ai conçu ceci comme un ensemble d'article reliés entre eux par des liens, un peu comme pour une encyclopédie. Pour partir, je vous propose quelques questions directrices :
Utiliser le ruby dans un jeu
Afficher une image
Afficher un texte
Faire un script

Si vous avez des questions, posez les moi sur msn ou sur la ligue. Si elles sont intéressantes, je les intégrerai à ce guide. N'hésitez pas non plus, si vous trouvez que certains point du guide ne sont pas clairs ( et je sais que beaucoup ne le sont pas), à réclamer. J'améliorerai.

Utiliser le ruby dans un jeu

Il y a deux parties disctintes sous Rmxp : le logiciel normal, l'une avec les évents, les cartes et la base de donnée, l'autre est l'éditeur de script en ruby.
Il y a trois accès au ruby dans RMXP : l'éditeur de script est évident, mais il y a aussi deux commandes Rpg Maker qui permettent d'utiliser le code, toutes les deux extrêmement utiles : l'insérer script et les conditions.
L'éditeur de code permet de faire des modifications sur les systèmes de bases, mais aussi, et c'est très important, de créer de nouveaux systèmes. C'est le cœur du ruby.
Insérer script, la dernière commande de la troisième page, permet d'insérer quelques lignes de code à un endroit précis. C'est très utile pour faire de petits systèmes et surtout pour appeler des systèmes que l'on a fabriqués dans l'éditeur de script. Un effet de fumée pour du feu par exemple : on code une classe « Fumée » dans l'éditeur de script, et on démarre l'effet de fumée depuis une commande insérer script, que l'on place au moment approprié de notre scène. C'est donc une passerelle entre nos outils pratiques de Rpg Maker et les outils sophistiqués du ruby.
Enfin les conditions : dans la quatrième page de la commande condition, il y a la possibilité de mettre un morceau de code en ruby. Si le code est vérifié, la condition sera remplie. (cf les Booléens) Plus précisément :si ce morceau renvoie True, la condition sera remplie. Si elle renvoie False, ce sera le « sinon » (ou « else », en anglais) qui sera exécuté. Si le code renvoie autre chose, rien ne se passera.

Afficher une image

La classe à utiliser est Sprite. C'est la classe clef, que vous utiliserez à chaque fois que vous voulez afficher quelque chose. Ce sprite doit posséder un Bitmap, c'est-à-dire une image. On créé un Sprite, on lui attribue un bitmap, puis on joue avec les attributs du Sprite pour positionner l'image et en faire ce que l'on veut.

Typiquement, voila comment afficher au centre de l'écranl'image nommée « Fabien » et qui se trouve dans le répertoire pictures : ( on utilise ici une variable globale)

Sprite

La classe à utiliser est Sprite. C'est la classe clef, que vous utiliserez à chaque fois que vous voulez afficher quelque chose.
Cette classe possède un bon nombre d'attributs incroyablement utiles.

Pour créer un sprite : nom=Sprite.new
Nom étant une variable
Vous pouvez mettre un viewport en argument, comme ceci : Sprite.new(viewport), mais vous pouvez aussi ne rien mettre.
Mais pour que votre sprite devienne utile, il vous faut lui donner une image, c'est-à-dire un Bitmap. Si bitmap est la variable contenant votre bitmap, il faut écrire :
nom.bitmap=bitmap
Référez vous à l'article Bitmap pour savoir comment créer votre bitmap

S'ensuivent différents attributs propres aux sprites, tous extrêmement utiles. Pour s'en servir on écrira nom.attribut Attributs :
x : position horizontale, en pixel. 0 est le bord gauche de l'écran, 640 le bord droit.
y : position verticale, en pixel. 0 est le bord supérieur, 480 le bord inférieur
z : « altitude ». Une image de z supérieur recouvre les images de z inférieur.
zoom_x : étirement horizontal du bitmap. A 1, le bitmap n'est pas étiré.
zoom_y : étirement vertical du bitmap. A 1, le bitmap n'est pas étiré.
opacity : l'oppose de la transparence. A 0 le sprite est totalement transparent, à 255 il est totalement visible.
angle : angle de rotation du bitmap, en degrés.
blend_type : littéralement "type de mélange". Voir couleurs et blend_type
ox : l'origine horizontale, en pixel. C'est le point de l'image qui sera placé à la coordonnée x. L'origine est aussi le centre du zoom ( ce sera très important si vous voulez déplacer une image zoomée)
oy : l'origine verticale, en pixel. Idem que pour ox.

Pour d'autre attributs et des méthodes également extrêmement utiles, consultez l'aide RMXP.

Les Variables

Une variable, c'est l'élément de base de toute programmation.

Les variables en ruby peuvent être à peu près n'importe quoi. Des chiffres, des objets, tout.
Mais il y a une différence importante à retenir: les variables globales, de classes, et locales. On les définit en foncton de la première lettre du nom de la variable :
$blabla est une variable globale
@blabla est une variable de classe
blabla est une variable locale

Une variable globale peut être utilisée n'importe où, n'importe quand.
Une variable de classe ne peut-être utilisée que dans la classe ou elle a été crée.
Une variable locale ne peut être utilisée que dans la fonction où elle a été crée.
A quoi ça sert ? A éviter la collision de variable et la multiplication des noms. Qu'est ce que c'est ? Eh bien imaginez que vous ayez un parking avec 200 voitures. Vous voulez savoir la couleur de chacune d'entre elles. Comment allez-vous appelez les variables contenant ces couleurs ? Il leur faut toutes des noms différents, sinon elles se confondent et on perd l'info ( collision de variables). Mais si on les appelle $couleur_voiture1, $couleur_voiture2, $couleur_voiture3, etc. on n'a pas fini. grâce aux variables locales, chaque voiture peut avoir sa variable @couleur, et elles ne se percutent pas !
Pour mieux comprendre ça, il faut comprendre le concept de classe.

Notez qu'on peut aussi définir des constantes, c'est-à-dire des variables non modifiables. Il suffit pour cela de les noter en majuscules : BLABLA. Un bon exemple de constante est pi : MATH ::PI renvoie 3.1415.. avec un paquet de décimales.

Par contre attention, interdit de commencer le nom d'une variable par une majuscule : cela est réservé aux classes.( donc Blabla est interdit)

Viewport

Viewport.new(x, y, width, height)
Les viewports sont un peu comme des couches. Les sprites appartiennent aux différents viewports. Je leur connais trois utilités pratiques :
1-On peut utiliser les méthodes flash(color, duration) et les attributs color ( comme pour les sprites) pour affecter tous les sprites qui appartiennent à ce viewport d'un coup. C'est le principe des commandes RMXP qui affecte tout l'écran.
2-Les z classiques ne permettent pas d'intercaler des images entre les evements et la map, car les images n'appartiennent pas au même viewport que la carte et les évents. En créant des sprites appartenant à ce viewport, on pourra intercaler des objets entre elle et les évents. Ce viewport est dans la classe Spriteset_Map, c'est @viewport1. Pour plus de facilité, personnellement je l'ai transformé en $viewport1, pour pouvoir y accéder facilement et sans syntaxe de trois kilomètre. ( voir les variables globales et de classes)
3- En définissant des viewport plus petits que l'écran, on pourrait afficher plusieurs choses différentes comme dans des cases de BD, rendant la mise en scène trèèès dynamique. Mais cela n'a encore jamais été tenté.

Afficher un texte

On va afficher une image, sur laquelle on va écrire.
Pour résumer le contenu de l'article « afficher une image », on va créer un objet Sprite qui possède une bitmap. Ici on va créer ce bitmap vide, lui attribuer une police de caractère, une taille et une couleur, et utiliser draw_text pour écrire le texte voulu dessus. Voir l'article Bitmap pour le détail de ces opérations.
Exemple : ( on utilise une variable globale et affichons « Barbapapa! » au milieu de l'écran)

Afficher le contenu d'une variable

C'est comme pour afficher un texte, sauf qu'on convertit le nombre en texte avec la commande .to_s
Par exemple les variables rpg maker sont accessibles en ruby avec $game_variables[num].
Num étant le numéro de la variable. Si dans l'exemple de l'article « afficher un texte » vous remplacez, "Barbapapa!" par game_variables[num].to_s , cela affichera le contenu de la variable numéro « num ».

Booléens

True : Signfie vrai
False : Signifie faux
Les expressions d'évaluations renvoie l'une ces deux valeurs.
On peut aussi s'en servir pour vérifier si quelque chose s'en bien passé, dans des systèmes avec plusieurs fonctions s'appellent les unes les autres.
A utiliser avec : les expressions d'évaluations
A utiliser pour : Les fonctions, les conditions dans l'interface

Expressions

Expressions d'évaluations : Pour savoir si quelque chose est vrai ou faux.
Expressions opération, opérateurs : Pour effectuer une opération de base.

Expressions d'évaluations :
Opérateur : la principale opérateur pour ceci est if ( le mot « si » en anglais)
if condition
Code
End
Ceci effectue Code si condition est true.
Notons les deux synthaxes abrégées du if, qui tiennent en une ligne :
If condition then code end
Mais aussi :
if condition then code else code2 end
Il a aussi et surtout :
condition ? Code : code2 Code étant le code à effectuer la condition est true, code2 si elle est false

Notons a et b et c des objets quelconques. Cela peut être n'importe quoi, depuis des chiffres jusqu'à des programmes entiers.
Ces opérateurs renvoient true ou false, selon que l'expression est vraie ou fausse.
a = = b renvoie true si a et b sont parfaitement identiques. (Exemple : 1= =2 est false)
a != b renvoie true si a et b ne sont pas parfaitement identiques.
a>b renvoie true si a est supérieur a b. S'utilise surtout pour les chiffres, mais marche aussi pour les lettres (pour l'ordre alphabétique par exemple).
a< b renvoie true si a est inférieur a b.
a>=b supérieur ou égal
a<=b inférieur ou égal
Les opérateurs :
a=b
a=b+c
a=b-c
a=b*c #c'est la multiplication
a=b/c #c'est la division
a=b**c # b est mis à la puissance c.
a=b%c # b modulo c. C'est le reste de la division euclidienne.
# syntaxes contractées :
a+=b # modifie a en lui ajoutant b
a-=b
a*=b
a/=b
a**=b
a%=b

Bitmap

Un bitmap, littéralement traduit " carte de pixel", est la forme brute d'une image. C'est une sorte de tableau de pixel, chacun d'entre eux étant d'une couleur donnée, avec ses attributs rouge, vert, bleu et alpha (la transparence).
Les bitmaps sont la base des trucs qu'on affiche à l'écran. On s'en sert pour définir l'image des Sprites

Les bitmaps étant de gros objets (une image 640*480 contient 640 fois 480 fois 4 nombres, soit plus d'un million de nombres. ) le RGSS comprend des trucs pour le pas avoir à trop les faire manipuler les jeux. Sans cela ils rameraient sans cesse.
Basiquement on peut créer un bitmap en faisant :
Bitmap.new(taille_x,taille_y)
Les tailles étant en pixel, et le bitmap créé étant totalement transparent.
On peut aussi faire :
Bitmap.new(Chemin_du_fichier+nom_du fichier)
Où Chemin_du_fichier est le chemin depuis le répertoire de l'exe. Par exemple :
Bitmap.new("Graphics/Pictures/"+"JVF2")
Chargera l'image "JVF2" qui se trouve dans le répertoire Pictures , qui se trouve lui-même dans le répertoire Graphics, qui se trouve lui-même dans le même répertoire que l'exe du jeu. Notons que l'extension n'a jamais à être précisée : « JVF2 » pourrait être un jpg où un png, on l'appellerait exactement pareil.
(Evidement, il faut avoir coller une image portant ce nom dans le répertoire picture. On peut soit la déplacer à la main en faisant copier-coller, plus rapide, soit utiliser le gestionnaire de ressource de RM, qui permet de régler un peu de transparence.)
Mais cette méthode obligerait à recharger les bitmaps à chaque fois qu'on les affiche. On utilise donc un autre outil que le RGSS nous fournit :
RPG ::Cache.picture("JVF2")
Ce code renverra la meme chose que le précédent, mais si on a de nouveau besoin de l'image contenue dans "JVF2", la même synthaxe renverra le même bitmap, sans consommer de notre précieux temps de calcul.

Bref, pour résumer, on se sert de
RPG ::Cache.picture(nom_de_fichier)
Pour charger un bitmap.

Pour comprendre les classes, il est très fortement conseillé de comprendre les Fonctions
Et en fait pour comprendre les classes, plutôt que de travailler sur mon exemple fait à la va-vite, je vous conseille de vous référer à un tuto de professionnel. Par exemple :
http://www.ruby-doc.org/docs/beginner-fr/xhtml/ch04s02.html
Cependant vous pourrez aussi vous reportez à la rubrique Faire un script , qui explique en fait aussi pas mal comment programmer une classe.

Les classes sont les bases de la programmation moderne. C'est un concept très proche de la vie quotidienne ( par rapport à ce que se faisait avant en programmation). Une classe possède des variables et des méthodes qui lui sont propres.
L'exemple classique est la voiture. Une classe de voiture, c'est le concept de voiture. Une voiture à plusieurs attributs : une couleur, une marque, un poids, etc. Ce sont ses variables, que l'on note avec un @ devant pour montrer qu'elles lui sont propres. Et elle a plusieurs fonctions : démarrer, accélérer, freiner, activer l'essuie-glace, etc. Ce sont ses méthodes. On va donc définir une classe Voiture avec ces éléments, ensuite on créera des voitures sur ce modèle. On créé des objets voitures, dont on choisit la couleur, la marque, le poids, etc. On pourra les faire démarrer, accélérer, freiner, activer l'essuie-glace, etc.

Toute classe possède une méthode intialize, qui est appelée à la création de l'objet. Lors de cette même création, il faut passer les arguments requis.

C'est sûrement dans la pratique que vous comprendrez mieux le concept de classe. En voici un exemple :

class Voiture
def initialize(couleur, marque,poids)
@couleur=couleur
@marque=marque
@poids=poids
end

def repeindre(couleur)
@couleur=couleur
end

def vanter
p « Ma voiture est de une « + @marque
end

end Ce paquet de code définit notre classe voiture. Pour nous en servir, nous devons créer un objet de cette classe, de cette manière :
$ma_voiture=Voiture.new(Rouge,Renault,876)
et plus loin on pourra faire, par exemple :
$ma_voiture.vanter
Cela aura pour éffet d'afficher un message « Ma voiture est une Renault »

Fonction et méthode

Fonction et méthode ne sont pas clairement différentes en ruby, on pourra confondre les deux mots sans difficultés.
Pour apprendre ce font il s'agit, puisqu'il s'agit d'un concept fondamental de programmation, je conseille un article de pro :
http://www.ruby-doc.org/docs/beginner-fr/xhtml/ch04.html

(Pour ceux qui veulent connaître les détails : une fonction renvoie quelque chose, une procédure ne renvoie rien, et une méthode est une fonction où procédure qui se trouve dans une classe. dans la pratique on ne différencie pas ou peu les trois)

Une fonction est un segment de code réutilisable. Cela permet de ne pas avoir à copier-coller des parties entières de code sans arrêt.

Pour définir une fonction, on écrit :
def nom_fonction
code
end
nom_fonction pouvant être presque n'importe quoi, du moment que c'est en minuscules.
Pour se servir de la fonction, on écrit alors tout simplement :
nom_fonction
On a appelé la fonction. C'est exactement comme si on avait écrit code .Si code est très long, la fonction est un outil fabuleux !

Un élément fondamental des fonctions est qu'elles peuvent recevoir des arguments. Ce sont des variables qui seront utilisées dans la fonction, sauf que leur valeur ne sera donnée qu'au moment de l'appel. La fonction peut aussi renvoyer une valeur grace à l'opérateur return
def addition(a,b)
résultat = a+b
return résultat
end
On pourra alors faire ceci avec cette fonction :
addition(2,3)
Ceci équivaut à écrire : 5

On peut donner des valeurs par défaut aux arguments, simplement en faisant =
def addition(a=4,b=2)
résultat = a+b
return résultat
end
On pourra alors faire ceci avec cette fonction :
addition
Ceci équivaut à écrire : 6

Voici maintenant un exemple de véritable fonction, tirée de mon jeu. Elle reçoit en argument l'id d'un événement (un chiffre quoi), et renvoie les coordonnées à l'écran de cette événement. Sa longueur vient du fait qu'elle gère tout les cas possibles : les arguments sont des coordonnées, les arguments sont un id d'évent. si l'id vaut 0, renvoie les coords du héros. C'est une bonne fonction dans le sens où elle peut être utilisée dès que j'ai besoin d'afficher quelque chose sur un événement. Elle raccourcit beaucoup mes scripts.

def coords(x=0,y="")
if y.is_a?(String)
if x==0
x=$game_player.screen_x
y=$game_player.screen_y
else
y=$game_map.events[x].screen_y
x=$game_map.events[x].screen_x
end
return [x,y]
end
if x.is_a?(String)
if y==0
x=$game_player.screen_x
y=$game_player.screen_y
else
x=$game_map.events[y].screen_x
y=$game_map.events[y].screen_y
end
return [x,y]
end
Cependant on notera que, adaptée au fur et à mesure à mes besoins et connaissances, elle pourrait être plus courte. Par exemple je me sers de :
def event(id)
if id==0 then return $game_player else return $game_map.events[id] end
end
dans les mêmes circonstances, et c'est presque aussi efficace. Mais pas aussi souple. Bien des fonctions peuvent remplir la même tache, tout en étant très différentes.

Structure et fonctionnement des jeux RMXP

Vous devez connaître les variables, les fonctions et la boucle while pour comprendre ce point.
Lorsque le jeu s'allume, c'est le code contenu dans le script Main qui s'exécute, cela grâce à l'opérateur begin. La seule chose que le jeu exécute automatiquement, c'est le fragment de code entre begin et son end.
Dans ce code il y a une boucle while :
while $scene != nil
$scene.main
end
Juste avant $scene a été défini par :
$scene = Scene_Title.new
donc $scene != nil est true. La seule chose qui va se produire dans le jeu est cette fonction main de$scene. Comme $scene est un objet Scene_Title, il faudra se référer à cette classe pour savoir ce qu'elle fait. (mais on aura compris que c'est l'écran titre) Sachez cependant qu'au moment de se fermer, l'écran titre fait quelque chose du genre $scene=Scene_Map.new, et que ce Scene_Map est la scène qui servira le plus. Il existe aussi Scene_Menu, Scene_Save, etc.

Changer de scène peut être utile pour faire un scipt, car si l'on fabrique une scène personnalisé sa fonction main sera appelée automatiquement, et plus rien d'autre ne fonctionnera.C'est ce que l'on utilise lorsqu'on a besoin de puissance et/ou que l'on a pas besoin de la carte.

Couleurs et blending

Les objets Color se créent en donnant quatre arguments : Color.new(rouge,vert,bleu,alpha)
Ce sont les trois couleurs primaires, plus la transparence. Les quatre peuvent varier de 0 à 255. Le noir c'est (0,0,0,255) et le blanc c'est (255, 255, 255, 255). On peut se servir des objets Color sur les sprites ( sprite.color=Color) et les bitmaps (bitmap.set_pixel(x,y,Color) ).

HS/ Saviez-vous que les trois couleurs primaires étaient en faite les trois seules couleurs que perçoit l'oeil humain ? C'est pour cela que l'on peut gruger et reconstituer toutes les couleurs du spectre à partir de trois couleurs seulement : en réalité, les couleurs autres que primaires ne sont pas des vraies couleurs, mais c'est notre cerveau qui les imagine./HS

Le blending est en fait la façon dont les couleurs superposées se mélangent. On s'en servira surtout pour faire des effets de lumière et d'ombre. Dans le RGSS il y en a trois : remplacement, adition et soustraction. Pour les choisir, on modifie l'attribut blend_type des sprites . Celui-ci peut avoir trois valeurs, 0,1 et 2, qui correspondent respectivement au bending de remplacement, d'adition et de soustraction.

Le blend_type est à 0 par défaut. C'est l'affichage normal, une couleur appartenant à un sprite de z supérieur remplace tout simplement la couleur d'en dessous.
A 1, la couleur du sprite supérieur sera additionnée à celle du sprite inférieur. On s'en servira pour des effets de lumières.
A 2 , elle sera soustraite. On s'en servira pour des effets d'ombres.
Pour comprendre comment cela fonctionne, il faut se rappeler les objets colors. Chaque pixel est composé de rouge, de vert et de bleu. Selon le blend_type donc, la couleur affichée sera soit celle de l'image la plus haute, soit celle de la somme de plusieurs images, soit celle de la différence.
Par exemple si on a une image rouge vive, c'est-à-dire de Color=(255,0,0,255), et que l'on met une image de couleur Rouge moins vif dessus disons Color=(100,0,0,255), le pixel affiché sera de couleur (155,0,0,255).
Cela est particulièrement utile avec le noir et le blanc. En effet le noir vaut (0,0,0,255). ainsi, qu'il soit soustrait ou additioné, il ne se passera jamais rien. Si on met du noir dans un image et qu'on lui donne un blend_type différent de 0, tout ce qui est noir sera transparent ! Et les zones sombres de l'images seront d'autant plus transparentes qu'elles étaient sombres.
Le blanc quand à lui vaut (255,255,255,255). Son effet en adition ou soustraction sera donc maximal. En addition il rendra blanc les images, en soustraction il les blanchira. C'est-à-dire qu'il éclairera ou obscurcira.
Ainsi, en faisant une image en nuance de noir et de blanc, vous pouvez faire une carte des lumières où des ombres. Pas les deux en mêmes temps cependant.
De nombreux éffets sont possibles, mais ils restent à découvrir. Si l'on additionne du rouge et du vert, on a du jaune. Si l'on soustrait du jaune à du vert, on obtient du bleu.

Les classes fréquentes

Les chiffres, les tableaux et les chaînes de caractères sont les types de données de base.
Les chiffres se manipulent avec les opérations mathématiques normales. Il y a diverses classes affiliées.
Les tableaux sont de la classe Array. Ils servent à stocker les objets pour y accéder facilement, sans avoir trop de noms de variables. Lien conseil pour apprendre à les manipuler :
http://www.ruby-doc.org/docs/beginner-fr/xhtml/ch03.html#id2807881

Les Chaines de caractères sont de la classe String, et on peut les manipuler exactement comme les Array. Elles servent à écrire du texte.

Les Boucles

Les boucles permettent de répéter certaines instructions.
La boucle la plus utile est à mon goût le for. Voici comment on s'en sert !
for variable in domaine
code
end
on doit remplacer variable, domaine et code par les éléments désirés.
Variable est une variable locale qui sera créée pour l'occasion, on peut lui donner n'importe quel nom. Ce qui est important, c'est que l'on pourra se servir de cette variable dans le code à l'intérieur du for. La valeur de la variable va changer, code va être répété une fois pour chaque valeur de la variable.
Domaine contient justement les valeurs possibles pour la variable. Cela peut être un intervalle de nombre : 3..28 ( là boucle sera répétée 28-3=25 fois, et variable prendra les valeurs de tous les chiffres de 3 à 28, ce deux chiffres étant inclus. ) mais on peut aussi se servir directement d'un Array , un tableau. Chaque élément du tableau sera une valeur de variable.
Enfin code est une série d'instruction, dont le but est d'utiliser la variable pour effectuer un traitement sur une masse d'objet.

Pour plus de détails sur les autres boucles, se référer à l'aide rmxp. Notez que la plupart sont des boucles classiques en programmation, et que leur principe n'est pas spécifique au ruby.
loop do – fait se répéter le segment de code compris entre loop do et end jusqu'à ce que le code rencontre la commande break
while condition- fait se répéter le segment de code compris entre while et end jusqu'à ce que condition soit false
until condition - fait se répéter le segment de code compris entre until condition et end jusqu'à ce que condition soit true

Faire un script

Pour faire un script, on va commencer par créer une nouvelle page dans l'éditeur de script (F11 sous rmxp).
Apprenez les Classes d'abord. Un script à base de fonction est tout à fait envisageable, mais c'est « inesthétique ».
Pour faire des scripts on fait des classes : L'intialize est chargé de poser les bases de tout ce qu'on va faire. L'update est une fonction chargée de faire ce qu'il y a à faire en permanence. Tout le reste n'existe que pour ces deux là. Par exemple dans la classe Sprite_character, qui est chargé de l'apparence des évents, l'initialise créé l'image de l'évent (le sprite), et l'update la déplace à chaque instant aux coordonnées où se trouve l'évent, en changeant sa pose en celle requise à cet instant.

Il y a six choses différentes en tout et pour tout dans votre script : en voici une liste exhaustive :
l'appel de l'initialize,
l'initialize,
l'appel de l'update,
l'update
les fonctions travailleuses
les fonctions d'interface.

Les fonctions travailleuses sont des outils pour l'intialize et l'update. Les fonctions d'interfaces sont de petites fonctions bricolées pour simplifier les ordres que vous donnerez à votre script. Ni l'une ni l'autre ne sont indispensables, loin de là, mais les travailleuses simplifieront la programmation de votre script et les interfaces simplifieront son utilisation, surtout par l'utilisateur lambda.

Il faut préciser que la fonction update doit être appelée à chaque frame. et que cela ne se fait pas tout seul ! Il faut trouver un endroit d'où on peut l'appeler et où cela sera fait tout le temps.
Personnellement je me mets au début de l'update, Scene_map, qui est elle-même appelée par le script main. (voir la structure de RMXP). Un autre problème qui émerge alors est que si la fonction update est appelée alors que la classe n'existe pas, il y aura une érreur. Pour éviter cela le plus simple est encore de savoir dans quelle variable va contenir l'objet, et d'écrire quelque chose comme : ( voir nil et les opérateurs)
if $variable != nil
$variable.update
end

On commence d'abord par écrire la définition de la classe, en lui donnant un nom quelconque :
class Trucmuche
Rappelons que le nom doit comporter une majuscule, comme ici Trucmuche.

L'initialize est ensuite la première chose que vous concevez, avec ou sans argument.
def initialize(argument,argument)

A l'intérieur de cette fonction vous créez plusieurs variables locales, que vous initliserez en leur donnant leur valeur de départ. Par exemple un compteur de temps, qui commence à 0 :
@temps=0
Mais on peut aussi avoir un tableau destiné à stocker les images qui seront utilisées,
@images=[]
etc.

Dans l'initalize on fait aussi certaines taches qui n'ont à être exécutées une fois. Par exemple charger les bitmap dont on aura besoin, puis créér des sprites !
@bitmap_de_base=RPG ::Cache.picture(« script_tuto »)
for n in 1..10
sprite=Sprite.new
sprite.bitmap=@bitmap_de_base
sprite.x=0
sprite.y=rand(480)
@images+=[sprite]
end
rand(x) est une commande pour renvoyer un chiffre aléatoire entre 0 et x. Donc ce code créer 10 images « script_tuto », et les places au hasard sur le bord gauche de l'écran.

La deuxième étape consiste à créer l'update. On va manipuler toutes les variables qu'on a créées dans l'initialise, pour qu'elle fasse ce que nous voulons. Par exemple on peut déplacer les sprites que l'on a créés :
for sprite in @images
sprite.x+=1
end
Si l'on utilise ceci et qu'on lance la classe, les différentes images traverseront l'écran de gauche à droite
A propos, pour faire des éssais généralement on met un event sur la map, et on y met quelque chose du genre $nom_bidon=Nom_de_la_classe.new(arguments), et, lorsqu'on lance le jeu on va parler à cette évent pour lancer le script. Evidement il faut avoir pensé à appeler l'update.
On pourrait aussi utiliser la variable @t pour gérer un temps qui s'écoulerait. for sprite in @images
sprite.x+=10-@t
end
@t+=0.1
Ceci fera avancer les images de gauche à droites, d'abord vite, plus de plus lentement. Au bout d'un certain temps les images s'immobiliseront avant de repartir vers la droite, jusqu'à sortir de l'écran.

Après avoir fait ce genre de petit traitement, il est bon de prévoir des cas divers, par exemple effacer les images, et quand. faites preuve d'ingéniosité pour déterminer comment faire quoi !

Dès que votre classe est un peu grande, il est bon de placer les différentes taches dans différentes fonctions définies juste en dessous, que vous appellerez dans l'update au lieu d'y taper directement leur code.

Nil

nl est l'élément rien. Il n'a aucune propriété particulière, ce n'est qu'une valeur conventionnelle pour dire « rien ». nil est valeur que renvoie une variable non définie.

La Syntaxe du Ruby

Le ruby est de ces langages où les espaces n'ont aucune importance. Vous pouvez écrire indifféremment
a=b+c
ou
a = b + c
cela revient exactement au même.
Par contre vous êtres obligés de sauter des lignes entre les instructions. (Contrairement par exemple au C, où c'est le point virgule qui signale la fin de l'instruction)

J'aimerai également attirer votre attention sur un outil du ruby : l'attribution en chaîne. Au lieu de :
a=1
b=8
c=2
d=92
e=9
Vous pouvez écrire :
a,b,c,d,e=1,8,2,92,9

Cette technique a d'autres utilités. On peut s'en servir pour les tableaux.
Le code
a,b,c,d,e=[1,8,2,92,9]
fait exactement la même chose que l'exemple précédent. Cette technique peut être utilisé pour stocker des données sous forme de tableau, avant de les séparer en différents variables.