Apprendre


Vous êtes
nouveau sur
Oniromancie?

Visite guidée
du site


Découvrir
RPG Maker

RM 95
RM 2000/2003
RM XP
RM VX/VX Ace
RM MV/MZ

Apprendre
RPG Maker

Tutoriels
Guides
Making-of

Dans le
Forum

Section Entraide

Jeux: Dymunia / Sorties: Dymunia - Final Act / Tutos: Traduire son jeu du français (...) / Tests: SPZ : Déclarations / Scripts: MV Core Script / Chat

Bienvenue
visiteur !




publicité RPG Maker!

Statistiques

Liste des
membres


Contact

Mentions légales

135 connectés actuellement

10957586 visiteurs
depuis l'ouverture

6 visiteurs
aujourd'hui



Barre de séparation

Partenaires

Indiexpo

Akademiya RPG Maker

Hellsoft

Planète Glutko

Alex d'Or

RPG Maker Détente

RPG Maker VX

Eclipso

Tous nos partenaires

Devenir
partenaire



Guide sur le RGSS

Explications sur l'utilisation du ruby avec le RGSS de RPG Maker XP et VX afin d'écrire facilement des scripts.

Ecrit par Fabien Nicolas


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 rappellerai les choses les plus utiles, mais pour quelque chose plus approfondi, 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-moi : ç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 tutoriaux. 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)

Portion de code : Tout sélectionner

1
2
3
4
$image=Sprite.new
$image.bitmap=RPG ::Cache.picture(“Fabien”)
$image.x=320
$image.y=240





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 :

Portion de code : Tout sélectionner

1
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 :

Portion de code : Tout sélectionner

1
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

Portion de code : Tout sélectionner

1
nom.attribut


Attributs :

Portion de code : Tout sélectionner

1
x

: position horizontale, en pixel. 0 est le bord gauche de l’écran, 640 le bord droit.

Portion de code : Tout sélectionner

1
y

: position verticale, en pixel. 0 est le bord supérieur, 480 le bord inférieur

Portion de code : Tout sélectionner

1
z

: « altitude ». Une image de z supérieur recouvre les images de z inférieur.

Portion de code : Tout sélectionner

1
zoom_x

: étirement horizontal du bitmap. A 1, le bitmap n’est pas étiré.

Portion de code : Tout sélectionner

1
zoom_y

: étirement vertical du bitmap. A 1, le bitmap n’est pas étiré.

Portion de code : Tout sélectionner

1
opacity

: l’oppose de la transparence. A 0 le sprite est totalement transparent, à 255 il est totalement visible.

Portion de code : Tout sélectionner

1
angle

: angle de rotation du bitmap, en degrés.

Portion de code : Tout sélectionner

1
blend_type

: littéralement “type de mélange”. Voir couleurs et blend_type

Portion de code : Tout sélectionner

1
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)

Portion de code : Tout sélectionner

1
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

Portion de code : Tout sélectionner

1
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).

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
$truc =Sprite.new
$truc.x=320
$truc.y=240
$truc.bitmap=Bitmap.new(100,100)
$truc.bitmap.font.name=”Arial”
$truc.bitmap.font.size=24
$truc.bitmap.font.color=Color.new(255,255,255,255)
$truc.bitmap.draw_text(0, 0, $truc.bitmap.width ,
 $truc.bitmap.height ,”Barbapapa!”)




Afficher le contenu d'une variable
C’est comme pour afficher un texte, sauf qu’on convertit le nombre en texte avec la commande

Portion de code : Tout sélectionner

1
.to_s


Par exemple les variables rpg maker sont accessibles en ruby avec

Portion de code : Tout sélectionner

1
$game_variables[num]

.
Num étant le numéro de la variable. Si dans l’exemple de l’article « afficher un texte » vous remplacez,

Portion de code : Tout sélectionner

1
”Barbapapa!”

par

Portion de code : Tout sélectionner

1
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)

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
10
11
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.

Portion de code : Tout sélectionner

1
a = = b

renvoie true si a et b sont parfaitement identiques. (Exemple : 1= =2 est false)

Portion de code : Tout sélectionner

1
a != b

renvoie true si a et b ne sont pas parfaitement identiques.

Portion de code : Tout sélectionner

1
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).

Portion de code : Tout sélectionner

1
a< b

renvoie true si a est inférieur a b.

Portion de code : Tout sélectionner

1
a>=b

supérieur ou égal

Portion de code : Tout sélectionner

1
a<=b

inférieur ou égal

Les opérateurs :

Portion de code : Tout sélectionner

1
a=b


Portion de code : Tout sélectionner

1
a=b+c


Portion de code : Tout sélectionner

1
a=b-c


Portion de code : Tout sélectionner

1
a=b*c

#c’est la multiplication

Portion de code : Tout sélectionner

1
a=b/c

#c’est la division

Portion de code : Tout sélectionner

1
a=b**c

# b est mis à la puissance c.

Portion de code : Tout sélectionner

1
a=b%c

# b modulo c. C’est le reste de la division euclidienne.

# syntaxes contractées :

Portion de code : Tout sélectionner

1
a+=b

# modifie a en lui ajoutant b

Portion de code : Tout sélectionner

1
a-=b


Portion de code : Tout sélectionner

1
a*=b


Portion de code : Tout sélectionner

1
a/=b



Portion de code : Tout sélectionner

1
a**=b


Portion de code : Tout sélectionner

1
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 :

Portion de code : Tout sélectionner

1
Bitmap.new(taille_x,taille_y)


Les tailles étant en pixel, et le bitmap créé étant totalement transparent.
On peut aussi faire :

Portion de code : Tout sélectionner

1
Bitmap.new(Chemin_du_fichier+nom_du fichier)


Où Chemin_du_fichier est le chemin depuis le répertoire de l’exe. Par exemple :

Portion de code : Tout sélectionner

1
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 :

Portion de code : Tout sélectionner

1
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

Portion de code : Tout sélectionner

1
RPG ::Cache.picture(nom_de_fichier)


Pour charger un bitmap.

Classe
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 :
https://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 initialize, 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 :

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 :

Portion de code : Tout sélectionner

1
$ma_voiture=Voiture.new(Rouge,Renault,876)


et plus loin on pourra faire, par exemple :

Portion de code : Tout sélectionner

1
$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 :
https://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 :

Portion de code : Tout sélectionner

1
2
3
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 :

Portion de code : Tout sélectionner

1
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

Portion de code : Tout sélectionner

1
2
3
4
def addition(a,b)
  résultat = a+b
  return résultat
end


On pourra alors faire ceci avec cette fonction :

Portion de code : Tout sélectionner

1
addition(2,3)



Ceci équivaut à écrire : 5

On peut donner des valeurs par défaut aux arguments, simplement en faisant =

Portion de code : Tout sélectionner

1
2
3
4
def addition(a=4,b=2)
  résultat = a+b
  return résultat
end



On pourra alors faire ceci avec cette fonction :

Portion de code : Tout sélectionner

1
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.

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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

Portion de code : Tout sélectionner

1
event(id)


Portion de code : Tout sélectionner

1
2
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 :

Portion de code : Tout sélectionner

1
2
3
       while $scene != nil 
         $scene.main
       end



Juste avant

Portion de code : Tout sélectionner

1
$scene

a été défini par :

Portion de code : Tout sélectionner

1
       $scene = Scene_Title.new


donc

Portion de code : Tout sélectionner

1
$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 :

Portion de code : Tout sélectionner

1
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 (

Portion de code : Tout sélectionner

1
sprite.color=Color

) et les bitmaps (

Portion de code : Tout sélectionner

1
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 :
https://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 !

Portion de code : Tout sélectionner

1
2
3
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.

Portion de code : Tout sélectionner

1
loop do

– fait se répéter le segment de code compris entre

Portion de code : Tout sélectionner

1
loop do

et

Portion de code : Tout sélectionner

1
end

jusqu’à ce que le code rencontre la commande

Portion de code : Tout sélectionner

1
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’initialize 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’initialize 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)

Portion de code : Tout sélectionner

1
2
3
if $variable != nil
$variable.update
end




On commence d’abord par écrire la définition de la classe, en lui donnant un nom quelconque :

Portion de code : Tout sélectionner

1
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.

Portion de code : Tout sélectionner

1
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 :

Portion de code : Tout sélectionner

1
@temps=0


Mais on peut aussi avoir un tableau destiné à stocker les images qui seront utilisées,

Portion de code : Tout sélectionner

1
@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 !

Portion de code : Tout sélectionner

1
2
3
4
5
6
7
8
9
@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 :

Portion de code : Tout sélectionner

1
2
3
4
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…

Portion de code : Tout sélectionner

1
2
3
4
5
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

Portion de code : Tout sélectionner

1
a=b+c


ou

Portion de code : Tout sélectionner

1
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 :

Portion de code : Tout sélectionner

1
2
3
4
5
a=1
b=8
c=2
d=92
e=9


Vous pouvez écrire :

Portion de code : Tout sélectionner

1
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

Portion de code : Tout sélectionner

1
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.



La Meche - posté le 16/08/2009 à 16:17:28 (324 messages postés)

❤ 0

...

Sympa comme tuto juste un truc :

Citation:

Par contre vous êtres obligés de sauter des lignes entre les instructions.


C'est faux =°

Portion de code : Tout sélectionner

1
2
3
a = 1
b = 2
c = 3


C'est pareil que

Portion de code : Tout sélectionner

1
a = 1; b = 2; c = 3


^^

Diaries


Star-Wolf - posté le 26/10/2009 à 21:39:38 (12 messages postés)

❤ 0

Je suis gelé

Est-ce que quelqu'un c'est ce que veut dire "trigger input" ?

Entre le dessin, le making, la musique et le collège, j'ai plus de temps libre !


Killer-de-rpg - posté le 26/12/2009 à 20:59:36 (191 messages postés)

❤ 0

http://www.ClaraVenger.com/?id=567577 siou plaît un clic =D

Erf je comprend rien ...si quelqu'un pouvait m'expliquer la tranche d'âge de compréhension minimum sachant que j'ai 11 ans o_O


pele - posté le 09/01/2010 à 10:41:36 (53 messages postés)

❤ 0

Kalki

"trigger input" signifie "interrupteur activer"ou quelque chose du genre.ça depend de là où tu l'as vu.
Pour la tranche d'âge, à 14 ans je croyais que c'etait impossible à
comprendre mais 1 ans plus tard je suis allé sur RPG CREATIVE
et je et aujourd'hui à 15 ans je comprend mieux.
Crée un script dans lequel il y a:

Portion de code : Tout sélectionner

1
2
3
4
5
6
class Nom
def initialize
@milk= 2
print @milk
end
end


Pour l'appeller tu fais un appel de script:
$nom = Nom.new

ET je cherche des variables pour rgss1
du genre modifier le nom d'une arme(je la connais)

Apprendre le ruby RGSS1/2? https://Chalcie.overblog.com


chaipokoi - posté le 20/08/2010 à 19:11:56 (271 messages postés)

❤ 0

excuse moi mais j'ai 14 et dès 12 je programmais en basic puis a 13 en c et maintenant je maitrise le rgss2.:D


reelie - posté le 23/09/2010 à 01:53:35 (35 messages postés)

❤ 0

Marine

:hurle Ça fait longtemps que je cherche un truc comme ça !!!!
Merci dieu !:ange

YAY:sonic

Hell, it's about time !


linkv - posté le 20/10/2010 à 17:52:14 (5 messages postés)

❤ 0

Non, trigger input sert, par exemple, quand on écrit :
trigger input :: A
(c'est un truc du genre), c'est comme si on faisais une condition disant : si la touche "A" est appuyée alors : ...
Si c'est pas ça, merci de me corriger ^^ :ange


Killer-de-rpg - posté le 20/12/2010 à 11:47:44 (191 messages postés)

❤ 0

http://www.ClaraVenger.com/?id=567577 siou plaît un clic =D

Normalement t'as raison mais c'est pas plutot :

Portion de code : Tout sélectionner

1
if trigger input :: A 


?


freethinker - posté le 08/08/2011 à 14:57:31 (1 messages postés)

❤ 0

Merci pour ce tuto !!:banane

Suite à de nombreux abus, le post en invités a été désactivé. Veuillez vous inscrire si vous souhaitez participer à la conversation.

Haut de page

Merci de ne pas reproduire le contenu de ce site sans autorisation.
Contacter l'équipe - Mentions légales

Plan du site

Communauté: Accueil | Forum | Chat | Commentaires | News | Flash-news | Screen de la semaine | Sorties | Tests | Gaming-Live | Interviews | Galerie | OST | Blogs | Recherche
Apprendre: Visite guidée | RPG Maker 95 | RPG Maker 2003 | RPG Maker XP | RPG Maker VX | RPG Maker MV | Tutoriels | Guides | Making-of
Télécharger: Programmes | Scripts | Packs de ressources | Midis | Eléments séparés | Sprites
Jeux: Au hasard | Notre sélection | Sélection des membres | Jeux complets | Tous les jeux | Le cimetière | RPG Maker 95 | RPG Maker 2000 | RPG Maker 2003 | RPG Maker XP | RPG Maker VX | RPG Maker VX Ace | RPG Maker MV | Autres | Proposer
Ressources RPG Maker 2000/2003: Chipsets | Charsets | Panoramas | Backdrops | Facesets | Battle anims | Battle charsets | Monstres | Systems | Templates
Ressources RPG Maker XP: Tilesets | Autotiles | Characters | Battlers | Window skins | Icônes | Transitions | Fogs | Templates
Ressources RPG Maker VX: Tilesets | Charsets | Facesets | Systèmes
Ressources RPG Maker MV: Tilesets | Characters | Faces | Systèmes | Title | Battlebacks | Animations | SV/Ennemis
Archives: Palmarès | L'Annuaire | Livre d'or | Le Wiki | Divers