Bonjour à tous !

Voilà, je vais tenter de vous apprendre quelque trucs RUBY, ou plus exactement du RGSS, car en effet, beaucoup font la confusion ^^
Je commencerais d'abord par là...

Ce tuto à pour but de donner quelque connaissance en RGSS qui vous éviterons bien des déconvenues ^^ et vous permettront de régler vos blems seuls, et de construire des scripts simples (partie 2) ... mais utiles !

Petites précision, je n'ai pas le niveau absolue en RGSS, c'est à dire que je ne prétend pas tout savoir en RGSS, loin de là, cependant je pense en savoir assez pour ne plus me considérer comme débutant, et donc avoir la capacité "d'enseigner" une partie de ce que je sais.
J'ai entièrement rédigé ce tuto, et il n'est basé que sur quelque élément du fichier d'aide du jeu, où vous pourrez retrouver la plupart des choses que je vais dire, mais bien moins expliqué ^^
Le fichier d'aide est dispo ici :
http://www.megaupload.com/?d=3NT6OHMQ

Voici le sommaire :

1) Ruby / RGSS, c'est quoi la différence ?
2) Fonctionnement du RGSS
3) Vocabulaire important
4) Quelques codes
5) Construire un script
6) Régler ses erreurs tout seul

[]

I) RUBY / RGSS, c'est quoi la différence ?

Et bien à proprement parler le Ruby est un langage de programmation (comme le BASIC, le C/C++ ou le Java) moyennement utilisé.
C'est dans ce langage qu'est programmé notre logiciel : RPG Maker XP...
Cependant, ce n'est pas en Ruby que fonctionne les jeux, mais avec un langage adaptatif, issue du Ruby, qui lui même fonctionne en Ruby, c'est en quelque sorte un traducteur, une interface qui nous permet de programmer plus facilement le Ruby, et ce langage, c'est, vous l'aurez deviné, le RGSS (Ruby Game Scripting System).

Donc nous parlerons plus de RGSS que de Ruby, même si, comme vous l'avez vu, la différence n'est pas si énorme

[]

II) Fonctionnement du RGSS

Déjà, une des premières choses à savoir, est l'organisation des scripts...
En effet, l'ensemble du code permettant à jeu de fonctionner est divisé en plusieurs feuillets, non numérotés, que l'on appel couramment "scripts", car en effet, ce classement est totalement symbolique ! On pourrait très bien dans un seul script, mettre tout les scripts du jeu ! celui marcherai tout aussi bien, le seul problème, c'est qu'on n'y comprendrait plus rien, et que ce script ferait au moins 10000 lignes, si ce n'est plus...
C'est pour ça que le codage à été divisé en plusieurs scripts, classés par type...
Nous allons apprendre à reconnaitre ces types, et à voir comment sont classés les scripts.

Tout, d'abord, il faut savoir que la lecture des script commence par le bas ("hein ? mais comment ça se fait ??) et bien c'est par ce que le logiciel commence par ce qui est le plus futile, pour finir par les bases...
En effet, la lecture commence par le script "Main" (tout en bas donc ^^) dans lequel vous pouvoir marqué le mot "begin" qui signifie "début" (c'était dur hein ? lol).
Ainsi, le logiciel commence par "Main" puis par toute les "Scene_" (qui correspondent aux scènes qui peuvent se dérouler durant le jeu,c'est un premier type de script) cependant, comme ces scène font appels à des fenêtres, ou à d'autres choses comme les informations concernant la map ou le héros, par exemple, et bien le logiciel va aller cherchez plus haut !

Il va par exemple allez chercher dans les "Interpreter" qui sont les script qui font la liaison entre les évènements et les scripts :p
Il peut avoir besoin aussi des scripts "Arrow" qui concernent la petites flèches de position (vous savez dans les combats, quand vous choisissez l'ennemi ou les héros).
Il va surtout aller voir les scripts "Window_" (fenêtre) à cause des nombreuses fenêtre qu'on lui a demandé d'afficher dans les divers scènes.
Enfin, il peut avoir avoir besoin des informations et du traitement visuel qu'offre les scripts "Spriteset" et "Sprite" qui concernent donc les apparence des héros et de la map, entre autre.

Or, tous les derniers scripts dont on vient de parler (de Interpreter à Sprite) on eux même besoin d'information et de codes qui ont été définis et écrit précédemment, c'est pour celà que le logiciel va aller lire les scripts "Game_" qui sont le dernier type de script...

C'est ça l'esprit programmation, je subdivise tout mon code en plusieurs fractions de codes interdépendants, on fait une sorte de système de cascade à l'envers quoi...

[]

III) Vocabulaire important

Nous allons désormais abordé le vocabulaire important concernant le RGSS, j'ai décidé de le faire sous forme de liste, qui fonctionne en cascade, comme les scripts, car au fur et à mesure vous aurez besoin du mot suivant pour comprendre la définition précédente :

- Script : C'est un ensemble de codes contenant généralement une classe. Ce mot désigne ainsi les feuillets de codes.


- Classe : C'est la définition de l'état d'un objet, et c'est la définition de plusieurs méthodes. Les classes s'écrivent toujours comme ceci :

Code: Tout sélectionner

class Nom_de_la_classe
end

"Nom_de_la_classe" est le nom de votre classe, il s'écrit TOUJOURS avec une majuscule au début (seulement au début) et pas d'espace.


- Méthode : Les méthodes contiennent directement les instructions. Les méthodes peuvent posséder des attributs.
Les méthodes s'écrivent à l'intérieur des classes (généralement) comme ceci :

Code: Tout sélectionner

def nom_de_la_methode
end

"nom_de_la_methode" s'écrit toujours en minuscule, sans espace.


- Attribut : Ce sont des variables qui ne se transmettent que par l'intermédiaire de méthodes, et qui ne peuvent s'utiliser que dans une méthode. Les attributs sont extrêmement utiles, mais à utiliser avec prudence... Il se définissent de cette manière :

Code: Tout sélectionner

def nom_de_la_methode(nom_de_l'attridbut1, nom_de_l'attridbut2)
end

"nom_de_l'attribut" s'écrit en minuscule et sans espace.


- Instructions : Ce sont les codes même des scripts, se sont des algorithmes, des définitions de variables, des renvoies vers des méthodes ou vers d'autres classes...

- Algorithme : C'est la base même de tout jeux vidéos ! Ce sont des traitements mathématiques successifs de un ou plusieurs nombre (ou variables) par l'intermédiaire de fonction.
:shock feront certains ^^ en fait c'est plus simple que ça en à l'air.
Par exemple le calcul des dégât de votre héros sur un monstre est un algorithme : on prend la force de votre héros, on la multiplie par 2, puis on soustrait la défense du monstre, et vous obtenez les dégâts ! (cet exemple ne reflète pas le vrai calcul que fait RPG Maker, c'est juste un exemple ^^)
Wikipedia peut vous expliquer mieux que moi ^^ :
http://fr.wikipedia.org/wiki/Algorithmique

- Variable : La encore, c'est la chose la plus importante dans un jeu-vidéo ! Ouvrez grand vos yeux ! Les variables sont des expressions symboliques qui contiennent soit un nombre soit une chaine de caractères. (en fait elle peut contenir d'autre chose, mais contentons nous de cette définition théorique pour l'instant ^^)
Il existe plusieurs type de variables, ces types correspondent à leur protée dans le programme :
Note : "nom_de_la_variable" peut être écrit en minuscule ou en majuscule, ou les deux, mais pas d'espace.

=> Les variables globales : elles sont valable partout, dans tous les scripts ! Alors attention à ne pas faire d'interférence en appelant 2 variables globales par le même nom ! Voici comment on les reconnait :

Code: Tout sélectionner

$nom_de_la_variable

Elles commencent par un dollar ($)

=> Les variables d'instances : elles ne sont valables que dans une classe, ainsi, deux classe différentes peuvent avoir des variables d'instances qui ont le même noms. Leur syntaxe :

Code: Tout sélectionner

@nom_de_la_variable

Elles commencent donc par un arrowbase (aerobase pour les non anglophones, soit @).

=> Les variables locales : Elles ne sont valables que dans les méthodes, ainsi, dans une même classe, mais dans 2 méthodes différentes, on peut avoir deux variables globales au noms identique. Leur syntaxe :

Code: Tout sélectionner

nom_de_la_variable

Il n'y a rien devant, mais "nom_de_la_variable" doit s'écrire en minuscule uniquement.

=> Les constantes : Ce sont des variables qui ne varient pas lol, leur portée est globale (tout le programme) leur syntaxe :

Code: Tout sélectionner

NOM_DE_LA_CONSTANTE

Il n'y a rien devant, mais elles s'écrivent tout en majuscule...

Maintenant, voici comment on définit une variable :
On peut assigner un nombre à une variable, comme ceci :

Code: Tout sélectionner

@variable = 2008

On peut assigner une chaine de caractères (string pour les anglais), comme ceci :

Code: Tout sélectionner

@variable = "Nous sommes en 2008 !"

De plus, il est possible de manipuler une variables, dans un algorithme par exemples, par l'intermédiaire d'opérateurs.

Opérateurs : Se sont des symbole qui correspond à une opérations mathématiques. Voici la liste des opérateurs :
"+" : addition

Code: Tout sélectionner

@variable = @variable1 + @variable 2

"-" : soustraction, vous l'aurez compris ^^
"*" : multiplication
"/" : division (attention à ne pas diviser par 0, c'est impossible)
"+=" : ajouter à une variable un nombre :

Code: Tout sélectionner

@variable += 1

j'ai ajouté 1 à ma variable.
"-=" : soustraire un nombre à une variable
"*=" : multiplier une variable par un nombre
"/=" : diviser une variable par un nombre
Voilà, vous n'aurez pas trop besoin d'autre chose pour l'instant

[]

IV) Quelques codes

Voici la liste des mots qu'il ne faudra jamais utiliser comme variable ou méthode (mots réservés) :

Code: Tout sélectionner

BEGIN    class    ensure   nil      self     when
END      def      false    not      super    while
alias    defined? for      or       then     yield
and      do       if       redo     true
begin    else     in       rescue   undef
break    elsif    module   retry    unless
case     end      next     return   until

Une chose très importante à savoir, c'est que la plupart ces mots, en particulier : "class", "when", "def, "if", "elsif" et "case" sont TOUJOURS suivit d'un "end", et entre les deux vous mettez les instructions.

Dans le fichier d'aide, allez dans "Manuel de référence RGSS" => "Librairie Du Jeu" => "RPGXP Structures des données"
Vous trouverez à cet endroit toute la syntaxe utile pour désigner toute sorte de chose en RGSS, cela va des HP du héros, à l'ID d'une map, etc...

Voyons maintenant trois choses : les appels de classes et de méthodes, les comparables et les conditions et enfin les commentaires.

Appel de classes : Il suffit d'écrire :

Code: Tout sélectionner

$scene = Scene_Machin.new

pour aller vers Scene_Machin !
N'oubliez pas le ".new" qui signifie qu'il faut se rendre à la méthode "initialize".

Appel de méthodes : Si vous êtes dans une classe, et que vous voulez allez dans une méthode qui se trouve dans cette même classe, il suffit décrire le nom de la méthode, et c'est bon !

En revanche, si dans une classe vous voulez aller dans une méthode qui se trouve dans une autre classe, il faut d'abord définir une variable, et la rendre égale à l'autre classe (celle ou se trouve la méthode, et non celle où vous êtes) comme ceci :

Code: Tout sélectionner

@window_truc = Window_Truc.new
@window_truc.nom_de_la_méthode

Ainsi, le logiciel va exécuter lé méthode qui s'appelle "nom_de_la_méthode" et qui se trouve dans la classe "Window_Truc".

Enfin, si vous voulez appeler une méthode qui se trouve dans aucune classe (dans le vide si vous voulez), il suffit de marquer le nom de la méthode, et ça ira tout seul !


Conditions : évidemment, il y a des instructions qui ne s'exécuteront que sous certaines condition, par exemple, aller à la scène "Game Over" si les HPs de l'équipe sont nuls ou encore rendre égale tel variable si tel autre variable à une valeurs comprises entre tel nombre et tel autre nombre.
Deux mots désigne les conditions (y'en a plus en réalité, mais ceux-là sont les plus simples à utiliser)

Code: Tout sélectionner

if
end

et

Code: Tout sélectionner

case @variable
when valeur1
when valeur 2
      ...
      ...
end

On a donc "if" (si) et "case" (vérifiez le cas de) qui va avec les "when" (quand c'est égale à)
Vous comprendrez mieux avec ce qui va suivre.


Comparable : On les utilisent dans les conditions, pour comparer des variable entre elles où avec des valeurs :
- "==" : est égale à
- "!=" : n'est pas égale à
- ">" : est supérieur à (plus grand que)
- "<" : est inférieur à (plus petit que :p)
- ">=" : est supérieur ou égale à
- "<=" : est inférieur ou égale à

Voici comment écrire "Si la variable @ma_variable est égale à 1 alors rendre égale @mon_autre_variable à 5" (ce n'est qu'un exemple hein ^^)

Code: Tout sélectionner

 if @ma_variable == 1
    @mon_autre_variable = 5
end

Mais on peut avoir besoin de dire : "Si @ma_variable vaut 1, alors rendre @mon_autre_variable égale à 8, si @ma_variable vaut 2, alors rendre @mon_autre_variable égale à 22..."
On va utiliser "case" dans ces cas là :

Code: Tout sélectionner

case @ma_variable
when 1
    @mon_autre_variable = 8
when 2
    @mon_autre_variable = 22
end

Commentaire : Ils apparaissent en vert, ce sont des phrases, des commentaires que vous écrivez, et qui ne servent qu'a vous indiquer certaines choses, ou clarifier vos scripts. Il ne sont pas lu par le logiciel, c'est juste pour vous...
Il suffit d'écrire un diez (#) devant une ligne pour la faire devenir un commentaire.
Si vous voulez écrire beaucoup de ligne de suite en commentaire il suffit de faire comme ça :

Code: Tout sélectionner

=begin
blablabla
blabla
blablaaaaaaaa
=end

Edit Sh4k4: J'ai déplacé dans la section appropriée et en post-it, et je te donne 5 Pa pour ce tuto. Merci.

[]

V) Construire un script

Nous avons désormais toutes les clefs en main, pour s'intéresser à la construction d'un script, ou plus exactement d'une classe (vous souvenez ce que c'est hein ? )

Déjà, intéressons-nous à la structure d'une classe :
Il faut toujours commencer par un commentaire qui donne le titre de la Classe, puis il faut mettre l'auteur, la version du script, la date de création, et enfin des explications pour permettre à tout le monde de pouvoir utiliser le script...
Il aussi important pour la lisibilité du script de bien indenter vos scripts, c'est à dire qu'a chaque qu'il y a un mot bleu, hop, ce qui est en dessous doit être décalé vers la droite grâce à la touche tabulation et puis faire revenir chaque "end" à la même hauteur que le mot en bleu qui lui correspond, comme dans cette exemple :

Code: Tout sélectionner

class Machin
  def truc
    if @bidule == 1
      if @machin_truc == 2
        @chose = 1
      end
    end
  end
end

Ce sont des conventions qu'il faut respecter, et puis, ça rend vos scripts plus jolie en plus !
Voici donc la structure de base d'une classe (exemple de présentation par défaut) :

Code: Tout sélectionner

#==============================================================================
# ■ Nom_de_la_classe
#------------------------------------------------------------------------------
#  Auteur
#  Version
#  Date
#------------------------------------------------------------------------------
#  Explications
#==============================================================================

class Nom_de_la_classe
 
  #--------------------------------------------------------------------------
  # ● Initialisation
  #--------------------------------------------------------------------------
  def initialize
    @variable = 0
    nom_de_la_methode
  end
 
  #--------------------------------------------------------------------------
  # ● nom_de_la_methode
  #--------------------------------------------------------------------------
  def nom_de_la_methode
  end
end

Et vous pouvez mettre autant de méthode que vous voulez !
Le schéma des scènes est le suivant (non conforme à la syntaxe, c'est juste des mots pour expliquer :

Code: Tout sélectionner

Définition de la classe
   méthode d'initialisation
      définition des variables
      boucle {
         méthode de mise à jour
      } fin de la boucle
      procédure d'effacement des variable lorsque l'on quitte la scène
   end
   méthode de mise à jour
      mise à jour des variables
      algorithmes
   end
end

Maintenant, je vais vous donnez le code de base que vous pouvez copié coller (faites un nouveau script au dessus de "Main" (vous savez pourquoi désormais) pour créer un menu (faites attention aux commentaire que j'ai mis, ils permettent de mieux comprendre ) :

Code: Tout sélectionner

#==============================================================================
# ■ Scene_Menu
#==============================================================================

class Scene_Menu # Début de la classe
  #--------------------------------------------------------------------------
  # ●  menu_index
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0) # Initialisation de l'index
    @menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # ● Principal
  #--------------------------------------------------------------------------
  def main # Initialisation des variables
    s1 = ""
    s2 = ""
    s3 = ""
    s4 = ""
    s5 = ""
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5]) # Création d'une fenêtre de commande
    @command_window.index = @menu_index
    Graphics.transition # Transition graphique lorsque l'on quitte le menu
    loop do # Début de la boucle
      Graphics.update
      Input.update
      update # On dit au script d'aller voir la méthode "update"
      if $scene != self
        break
      end
    end
    Graphics.freeze # On gèle l'écran
    @command_window.dispose # On efface la fenêtre de commande
  end
  #--------------------------------------------------------------------------
  # ● Mise à jour
  #--------------------------------------------------------------------------
  def update # On définie la méthode "update"
    @command_window.update # Mise à jour de la fenêtre de commande en disant d'aller voir la méthode "update" de la classe contenue dans @command_window, c'est à dire "Command_Window.new".
    if @command_window.active # Si la fenêtre de commande est active
      update_command # Aller voir la méthode "update_command"
      return # Retourné le résultat
    end
  end
  #--------------------------------------------------------------------------
  # ● Mise à jour de la commande
  #--------------------------------------------------------------------------
  def update_command # Définition de la méthode "update_command"
    # B
    if Input.trigger?(Input::B) #Si l'on appuis sur B (c'est à dire Echap, X, ou 0)
      $game_system.se_play($data_system.cancel_se) #On joue le son "SE" dont le nom ($data_system.cancel_se) est  renvoyer par la méthode "cancel_se" de la classe contenue dans "$data_system".
      $scene = Scene_Map.new # Aller à la scène : "Scene_Map"
      return
    end
    # C
    if Input.trigger?(Input::C) # Si l'on appuis sur C (c'est à dire Entrée, ou Espace).
      case @command_window.index # Etudions les valeurs que peuvent prendre l'index de la fenêtre de commande (c'est à dire la position du curseur dans la commande : premier choix, deuxième choix, etc...) sachant que le premier choix à pour numéro 0.
      when 0  # Si l'on est sur le premier choix
        $game_system.se_play($data_system.decision_se) # Jouer la SE
      when 1  # Si l'on est sur le deuxième choix
        $game_system.se_play($data_system.decision_se)
      when 2
        $game_system.se_play($data_system.decision_se)
      when 3 
        $game_system.se_play($data_system.decision_se)
      when 4
        $game_system.se_play($data_system.decision_se)
      when 5 
        $game_system.se_play($data_system.decision_se)
      end # Fin de la condition
      return
    end # Fin la condition (appuis touche)
  end # Fin de la méthode
end # Fin de la classe

Evidemment, il en fait pas grand chose ce menu... mais c'est un début !
On peut remarquer plusieurs choses :
- Pour créer une fenêtre de commande, il suffit de définir une variable :

Code: Tout sélectionner

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5])

160 correspond à la largeur de la fenêtre de commande et s1, s2, s3 sont les choix multiple que vous donnez à votre fenêtre de commande, vous pouvez en mettre autant que vous voulez ! Mais le tout est de bien les marquer, et de dire juste avant, à quoi est égale s1, s2, etc... car se sont les mots qui s'afficheront dans la fenêtre de commande.

- Il ne faut pas oublié de faire "disposer" (effacer) vos variables(uniquement celles qui sont assignées à des choses qui s'affichent) en faisant appel à la méthode "dispose" comme ici :

Code: Tout sélectionner

@command_window.dispose

- Il ne faut pas oublier de mettre à jour vos affichages, et surtout vos commandes dans la méthode "update", en faisant comme ceci :

Code: Tout sélectionner

@command_window.update

Notez que "Window_Command" et "Window_Selectable" sont des exceptions par rapport aux autre fenêtre habituelles, car on les met à jour avec la méthode "update", alors que normalement, c'est "refresh" pour les fenêtres.

- Notez enfin que dans la méthode "update_command" selon la position ou se trouve le joueur dans la fenêtre de commande, si le joueur appuis sur C, il peut se passer des choses différentes (moi j'ai laissé vide, je n'ai mis que les SE, mais en fait, cela mène à des scènes différentes).
Imaginez si l'affichage de votre menu changeait en fonction de la position du joueur ? on pourrait faire des choses très sympa avec ça ! et bien c'est comme ça qu'on fait un CTS ou un Custom Menu System !

[]

VI) Régler ses erreurs tout seul

Quand on écrit des script, quand on programme, on a des erreurs tout le temps (même quand on est fort ^^).
Et parfois, quand on prend des script du net aussi :p
Alors le mieux, est de savoir corriger les erreurs (du moins certaines des tiennes car celles des autres... c'est à eux ! :hihi

Tout d'abord, lisez attentivement le message d'erreur ! le system de debuggage du RM XP est plutôt bien perfectionné, et assez précis, alors servez vous en !
Alors je ne veux plus voir dans les forums : "bouh ... y'a une érreur à la ligne 158 !!!..."

Lorsque vous faites part d'une erreur à un scripteur, précisez le type d'érreur, car savez vous qu'il y a près de 30 types d'erreurs concernant les script ?! Alors il vos mieux donner le type d'erreur pour savoir quoi faire... (vous verrez que quand vous aurez sous les yeux une ligne de code qui vous parait irréprochable, vous serez bien content de savoir quel est le problème ^^)

Heureusement, en plus de la ligne, le logiciel vous indique (pas dans tous les cas mais souvent) le mot qui n'est pas bon... (de quoi vous vous plaignez ? ^^)

Avant de voir 2-3 types d'erreurs, surtout, un mauvais geste à ne jamais faire, c'est de mettre un diez (#) avant la ligne !
Cela est énervant au plus haut point quand vous savez que cela transforme en commentaire la ligne concernée, et la rend donc inexistante au yeux du logiciel, ce qui ne va pas résoudre le problème, bien au contraire !

Déjà, si une érreur est marquée à la fin d'un script, sur un "end", c'est que vous avez oublié un "end", et il n'y a pas plus embêtant que ça ^^ il faut vérifié qu'a chaque condition, classe ou méthode, il y est le "end" qui lui corresponde, et il ne faut pas non plus qu'il y en ait un de trop ! Faites donc bien attention aux "end" !

- SyntaxError : C'est l'erreur la plus courante. Elle survient lorsque l'on n'a pas respecté la syntaxe du RGSS.
Dans ce cas là, il faut bien vérifier que la ligne concernée ne possède pas de fautes (ou de mots simplement mal écrit), à l'aide de vos connaissance que vous venez d'apprendre dans les parties précédentes. (syntaxes des variables respectées).


- NoMethodError : Le logiciel ne connait pas la méthode que vous avez marqué. Soit Il vous avez mal écrit le nom de votre méthode, soit vous l'avez pas définie, soit vous ne l'avez pas définie au bon endroit ! :p Relisez la partie du cours sur les méthodes pour savoir où vous devez la mettre si c'est le cas.


- NameError : La variable ou la constante que vous utilisez n'est pas définie ! N'oublie pas de définir à un moment donné (début de la classe par exemple). Par exemple, vous ne pouvez pas mettre

Code: Tout sélectionner

@ma_variable += 1

si vous n'avez jamais parler de "@ma_variable" avant ! :


- ArgumentError : Le nombre d'arguments de l'attribut de votre méthode n'est pas bon ! (prenez le temps de relire cette phrase plusieurs fois ^^) Lisez attentivement après "wrong number of arguments" il y a marqué entre parenthèse : "nombre1 for nombre2" en français ça donne "tu as mis nombre1 d'arguments alors qu'il en fallait nombre2" ^^
Donc il faut que le nombre d'argument de votre attribut soit égale à nombre2 pour être bon !

Voilà, je crois avoir faire le tour des erreurs courantes ! Mais comme dit plus haut, il y beaucoup de type d'erreur possible, alors cherchez bien comme je vous l'ai dit !


=> Conclusion :
Voilà, merci d'avoir lu jusqu'ici ! J'espère que vous aurez eu un bon aperçu de comment fonctionnent les scripts, une classe, et surtout une scene... evidemment, les scripts normaux sont bien plus élaborés que ça... mais moi je vous ait appris les bases, et à partir de ça, à partir de ce déclic, vous devriez être en mesure de comprendre d'autre chose par vous même, et par un effet boules de neige, comprendre de plus en plus de chose tout seul...

Cependant, sachez que ce tuto fait partie d'une suite de tutos qui ont pour but de faire apprendre le maniement du RGSS... donc si vous n'avez pas trouvé grand choses tout seul, ben la suite arrive !

Quelques petites objections...
mon post peut etre supprimé, vu qu'il gêne la lecture de tes remarquables tutos !

Graphics.transition est appelée avant la boucle de màj de la scene, et après chargement des différentes composantes. Elle est appelé pour faire un fondu de, je crois, 20 frames.
le return, seul, renvoie le 'curseur', j'aime l'appeler ainsi, de l'interpreter au bloc parent, celui d'où a été appelée la méthode.

Au niveau de la lecture des scripts, l'interpreteur effectue une prélecture, chargeant en memoire les Constantes et Modules, et verifiant la syntaxe, ensuite, le 'curseur' est placé dans le premier bloc 'begin' flottant (pas dans un autre bloc) qu'il rencontre.

T'aurais peut etre du parler de la methode main de la scene, appelée par la boucle while dans main.

mais je suis trop pointilleux !
Bravo pour ce tuto, qui j'espère incitera de nombreuses personnes à toucher aux scripts !

berka

Tu as raison sur tous les points ^^ mais bon, le but est d'approcher le scripting d'une manière assez générale pour le début, et faite pour les débutants, un peu à la manière du site du zéro...

Mais tu verras dans les partie suivantes (en cours de rédaction ) que les termes seront de plus en plus techniques, et la manière d'aborder les choses un peu plus théorique...

Néanmoins, le deuxième but de cette suite de tutos est de pouvoir directement après la lecture faire un Custom Menu System, un CTS ou un Custom Battle System (bon pas avec la partie 1 qui introduit, mais plutôt à partir de la partie 2).

Merci d'avoir regardé mon tuto
J'espère qu'il plaira aux forumers de Creative

Rien que ça, c'est faux. Ça commence bien.
RGSS est une librairie Ruby, au même titre que stdio pour du C.


Absolument pas. La lecture des scripts se fait belle est bien dans l'ordre où ils sont écrits.


Absolument pas.


Ou pas. Une variable contient un objet tout simplement. Mais qu'est-ce qu'un objet ? Ah bah c'est pas expliquer dans ce tuto. Dommage...


Ah bon ? Donc je peux très bien écrire:

Code: Tout sélectionner

true
   a = 1
end


puisque "true" est dans la liste ?

Bon j'ai pas tout relevé, mais le reste semble correct à priori même si trop banal pour aider quiconque à réaliser un système.

Ben je suis désolé, mais je te conteste les deux points.

Pour le premier point, tu as raison et moi aussi : http://fr.wikipedia.org/wiki/Ruby :
Le RGSS est un interprète embarqué (voir à la section éponyme de l'article dont je t'ai fournie le lien) après évidemment, tu vas surement me dire que l'article peut-être écrit par le premier couillon venu... alors tu n'as qu'a voir le site officiel d'RM XP, sur ce lien, dans le paragraphe "Introducing RGSS"... ptetr que là tu sera convaincu : http://tkool.jp/products/rpgxp/eng/newfunctions.html

Pour le deuxième point, du point de vue purement pratique le logiciel lit effectivement dans le bon sens, mais du point de vue sémantique (et c'est de ça dont je parlais) il lit "l'envers", c'est du moins ce que mes profs mon appris (à moins que tu ais un niveau supérieur au doctorat...)

Et sinon cette partie n'est que la première du tuto (faut savoir lire un peu) donc c'est normal qu'elle te paraisse banale, mais c'est pourtant important pour quelqu'un qui débute...

Je suis désolé mais quand j'écris un truc, c'est que j'ai des sources... j'écris pas dans le vent en me disant "a tiens ça doit marcher comme ça ..." je suis pas un charlatan, avant d'écrire un tuto qui sera vu par plein de monde, je vérifie mes dires, et je suis navré que tu ne m'est pas prit pour quelqu'un de sérieux... (mdr ce smiley ^^)

EDIT : tiens tu as édité pour contester d'autre truc... c'est un peu nul (sauf pour le "true" ça c'est vrai, faut que je le sépare de la liste )
Et pour les variables, chaque choses en son temps, toutes les explications arriveront quand elles devront arriver...

En fait je crois que tu n'as pas très bien compris le principe... le but est de formuler les choses simplement, pas faire des tutos imbaisables comme j'en vois plein sur ce site ou la plupart des gens n'y comprenne rien, alors qu'il suffit de dire les choses différemment, même si la définition n'est pas exact à 100% mais c'est ça la vulgarisation scientifique...
Toi quand tu étais en 5° et qu'on t'as appris que la plus petite particule de matière était l'atome, et qu'en suite au lycée on t'as dit que dans un atome y'a des protons et des neutrons (et des électrons autour), est-ce que t'as été embêter ton prof de 5° et tu lui as dit "mais attendez monsieur vous m'avez menti !" non car il ne t'avait pas vraiment menti !
Combien de fois on dit pas les choses exactement, puis après on revient dessus quand les gens sont plus apte à comprendre les choses ?
C'est ça l'enseignement, entre autre...

Alors que tu dises que les choses sont formulées de façon simpliste et un peu fausse, Ok, mais de là à dire que c'est tout faux...

Le RGSS n'a pas de différence avec le Ruby, si ce n'est que toutes les fonctions des librairies standards.
C'est comme si on disait que JSE et JME sont 2 langages différents.

Pour le deuxième point. Je suis d'accord avec cette manière de voir. Mais l'explication n'est pas clair et risque d'embrouiller plus qu'autre chose.

Et les autres points que j'ai souligné, tu comptes pas les traités ? Parce que personnellement, je m'en fout moi que ton tuto soit bon ou pas, j'ai pas besoin de ça, mais j'essaye juste de corriger tes erreurs.

On est entrain d'écrire en même temps ^^
Alors forcément...

j'ai édité mon post

Sinon c'est gentil à toi de vouloir corriger mon tuto... (dslé pour le "c'est un peu nul" mais j'étais énervé :p )

PS : Je viens de voir sur ton mini-profil que tu as marqué en point faible : "trop technique", ptetr que moi je te parait trop pratique... ^^

Ça ne me dérange pas que tu procèdes comme ça. Le problème vient que pour quelqu'un qui lirait le tuto et qui n'y connaitrait rien, il trouverait pas mal d'incohérence.

Exemple:




Donc $scene est soit un nombre soit une chaine de caractères.
Je me doute bien que toi tu sais que non, pourtant je ne fais que citer ce qui est écrit.

Ne pas tout divulguer d'un coup pour ne pas brusquer le lecteur, j'ai rien contre (quoique =p), mais il ne faut pas que ça engendre des incohérences pour autant.

Oué t'as raison...
Pour cet exemple, ben quand tu regarde bien, je dis rien de faux :p
Je dis ce qu'est une variable, puis je dis comment appeler une scene ^^

Non en fait, sérieusement, je parlais de la définition générale d'une variable, comme on peut l'avoir en maths par exemple... alors bien sur, qu'est-ce qu'on en a à faire puisque qu'on parle d'un langage... mais bon, c'est surtout du vocabulaire pour se faire comprendre que je donnais, après je suppose dans le reste du tuto qu'une variable est un truc qui peut contenir d'autre truc ^^ pour faire avec des mots simples...
En fait c'est vrai que y'a des éléments qui sont pas très clean, mais je pense que je me suis permis ça par ce que ça allait dans l'intérêt de ce que je voulais dire... y'a pas mal de feeling c'est vrai, et le tuto n'est pas hyper rigoureux je l'avoue, mais en fait j'ai compris que c'est ça qui fait la force d'un tuto qui se veut à la portée de tous... j'aimerais que plus de gens, même des non-scientifiques s'intéressent au scripting... donc j'ai essayé de parler du RGSS comme si j'étais monsieur tout le monde ^^
Le plus important était de structurer les infos, et les faire coller le plus possibles à ce que constatent les gens quand ils trifouilles les scripts...

Bon sinon je m'en vais corriger quelques petits truc quand même...

PS :
Au fait merci Sh4k4 ! j'avais pas vu ton edit dans le premier post ^^