Bienvenue dans le tutorial : création d’un sous menu.

Le but du présent tutorial est de vous faire parvenir un niveau de maîtrise suffisant de certains scripts de rpg maker xp pour créer votre propre sous menu.

L’utilité est assez évidente, un nouveau sous-menu autorise une personnalisation plus poussée et des commandes plus complexes.

L’exemple ici traité est celui d’un sous-menu autorisant le héros à changer de classe. Ce sont les premiers scripts que j'ai appris à créer en étudiant la structure des scripts existants et en demandant de l'aide sur ce forum (merci avec 6 mois de retard à Sh4k4 en passant).

Ce tuto est volontairement long et très détaillé. Les scripteurs débutant y trouveront beaucoup de réponses et ceux qui le souhaitent peuvent sauter les parties explicatives.

Travail préliminaire :

Bien la difficulté est présente dès le début car il faut avoir une vue d’ensemble de ce que l’on veut faire (comme souvent en programmation).

L’utilité de votre sous-menu va se traduire par la création de méthodes, d’attributs et de classes en ruby.

Exemple :

Ici nous voulons que le héros choisisse une classe parmi une liste. Il faut donc créer une liste de classes disponibles pour chaque héros.

Pour cela on va dans le script Game_Actor et on ajoute ce qu’il faut.

Code: Tout sélectionner

 attr_reader   :class_list               # tableau des classes dispos

Avec les autres attr_reader

Code: Tout sélectionner

 @class_list = [@class_id]

Dans setup_actor on définie les caractéristiques de base du héros au début du jeu, on veut donc que la classe disponible au départ et bien soit celle de départ !

Code: Tout sélectionner

  #---------------------------------------------------------------------------
  # class_list
  #---------------------------------------------------------------------------
  def class_list=(array)
    @class_list = [@class_id] if @class_list == nil
    return @class_list = array
  end

Alors voilà à la fin du script (mais avant le end final) on crée la méthode class_list qui définit un tableau (array) contenant les classes disponibles pour le héros, enfin c’est plus compliqué car il s’agit en fait des identifiants des classes, c'est-à-dire leur numéro dans la liste de votre base de données.

Pour ajouter une classe au cours du jeux il suffit de mettre dans un event la commande insérer script (page trois tout en bas) et d’y taper :

Code: Tout sélectionner

$game_party.actors[A].class_list.push(B)

En remplaçant A par le numéro du héros concerné (attention le premier héros de l’équipe a pour numéro 0, le deuxième 1 et ainsi de suite) et B par le numéro de la classe à ajouter.

Avant d’aller plus loin je signale que certaines versions de rpg maker xp ont un principe de changement de classe assez stupide (seul le nom de la classe change, pas les compétences).

Pour y remédier ajoutez ce script sous Game_Actor

Code: Tout sélectionner

 class Game_Actor < Game_Battler
 def class_id=(id)
  @class_id = id
  for skill in @skills
    forget_skill(skill)
  end
  for i in 1..@level
    for j in $data_classes[@class_id].learnings
      if j.level == i
        learn_skill(j.skill_id)
      end
    end
  end
      unless equippable?($data_weapons[@weapon_id])
        equip(0, 0)
      end
 end
end

Modification du menu principal :

On va ici ajouter notre commande dans le menu principal, si vous utilisez un menu personnalisé, les instructions suivantes devront être modifiées pour s’adapter à votre cas.

Le script en question est bien évidemment Scene_Menu.

Code: Tout sélectionner

 def main
    # コマンドウィンドウを作成
    s1 = $data_system.words.item
    s2 = $data_system.words.skill
    s3 = $data_system.words.equip
    s4 = "Classe"
    s5 = "État"
    s6 = "Sauvegarder"
    s7 = "Quitter"
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6 ,s7])

A l’origine cette portion de code ne comprend pas la ligne « classe », je l’ai insérée et bien sûr décalé les numéros.
Window_Command invoque la classe du même nom avec pour paramètres, la largeur de la fenêtre et la liste des commandes sous forme d’un tableau (n’oubliez pas de la modifier).

Allez un peu plus loin dans le script et vous verrez la méthode update_command, c’est là que vous allez gérer l’appel de votre sous-menu.

Vous voyez la succession de when ? Vous y êtes !

Code: Tout sélectionner

 case @command_window.index

Cette instruction signifie que vous testez la position du curseur qui varie à l’origine entre 0 et 5. Nous la faisons maintenant varier entre 0 et 6 ! Mais en plus (dans un simple souci d’esthétique) nous avons décalé les trois derniers numéros. Décalez les donc de même.
/ ! Attention les nombres à côté des when sont inférieurs de 1 à ceux à côté des s plus haut.

Exemple :

On a ajouté « classe » en s4 on doit donc ajouter when 3 (vous me suivez ?)

Code: Tout sélectionner

      when 3  # ステータス
        # 決定 SE を演奏
        $game_system.se_play($data_system.decision_se)
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0

Cela impose le passage du menu sur le bord gauche de l’écran à la sélection des personnages.

Cette nouvelle fenêtre s’appelle @window_status et fait appel au script Window_MenuStatus, qu’il ne vous est pas nécessaire de connaître.

Poursuivons, il faut maintenant indiquer l’appel de notre sous-menu.

Pour cela il faut aller dans la méthode update_status (quelle coïncidence).

Il faut refaire le même décalage que précédemment et insérer :

Code: Tout sélectionner

 when 3
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Classe.new(@status_window.index)

La variable $scene désigne ce qu’il y a à l’écran, vous devez comprendre qu’ici on appelle le script Scene_Classe, qui, vous vous en rendez compte, n’existe pas… Ce qui signifie que nous allons le créer.
L’argument @status_window.index permet de désigner le personnage auquel votre sous-menu va faire des misères (ou autre chose, après tout, c’est vous qui décidez).
Le nom du script à appeler devrait être explicite de la fonction du sous menu.

Maintenant créez un nouveau script entre Scene_Menu et Main.

Code: Tout sélectionner

class Scene_Classe
end

Lancez le jeu et que voyez-vous ? Il y a chevauchement des fenêtres. Pourquoi ? Ben voyons, on a ajouté une commande, il faut bien la mettre quelque part.

Il y a deux solutions : donner plus d’espace ou diminuer la taille des commandes.

La première est la plus simple mais aussi la plus contraignante puisqu’il faut renoncer à une autre fenêtre. Je doute que vous renoncerez à l’or, donc supprimons le stepomètre !

C’est assez simple, il suffit de ne pas demander l’affichage de la fenêtre dans Scene_Menu, supprimez donc les trois lignes :

Code: Tout sélectionner

 @steps_window = Window_Steps.new
    @steps_window.x = 0
    @steps_window.y = 320

Un peu plus bas supprimez :

Code: Tout sélectionner

 @steps_window.dispose

Puis dans update supprimez :

Code: Tout sélectionner

 @steps_window.update

Ou mettez un # devant chacune de ces ligne.

Maintenant il faut décaler l’or vers le haut : jouez avec

Code: Tout sélectionner

 @gold_window.y = 416

La bande de base est de 32 pixels donc décalez à 352.

Et le temps de jeu vers le bas :

Code: Tout sélectionner

 @playtime_window.y = 256

Relancez le jeu, il reste un trou…



Pour le boucher créez un script Window_Bouche au dessus de Main et en dessous de Window_Base :

Code: Tout sélectionner

 class Window_Bouche < Window_Base
     def initialize
    super(0, 416, 160, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
  end
end

416 ici désigne l’ordonnée (y) où l’on doit placer la fenêtre dans notre cas (480-64).

Et dans Scene_Menu on invoque le petit bout là où sont invoqués l’or et tout le reste, sous

Code: Tout sélectionner

 @gold_window.y = 352

Code: Tout sélectionner

@bouche_trou = Window_Bouche.new

Sous

Code: Tout sélectionner

@status_window.dispose

Mettez :

Code: Tout sélectionner

   @bouche_trou.dispose

Bon alors on supprime une fenêtre, on en déplace deux autres et on colle du mastic dans les trous… C’est assez lourd non ?

Rien ne nous empêche de redimensionner la fenêtre indiquant la quantité d’or pour boucher le trou, ou même plutôt que de supprimer la fenêtre du nombre de pas, en réduire la taille. Pour cela voyez les annexes du tuto à la fin.

Une autre solution est possible mais elle impose de réduire la police de caractère, et çà c’est lourd de conséquences.

Je disais que la largeur de base était de 32 pixels, il ne tient qu’à vous de la modifier. Ici on veut gagner la place de mettre un sous-menu supplémentaire soit en tout 7 sous-menus. La place que l’on a est de 6 x 32 = 192 pixels. 192 / 7 =~ 27,4. On va donc passer de 32 pixels à 27 pixels.

Commencez par copier les scripts Window_Command et Window_Selectable et rajoutez les sous les noms de Window_Command2 et Window_Selectable2. Ainsi nous ne modifierons que ce qui concerne notre menu.
/ ! N’oubliez pas de changer le nom de la classe au début de ces nouveaux scripts de la même manière.

Dans Window_Selectable2 trouvez la méthode update_cursor_rect et modifiez la ainsi :

Code: Tout sélectionner

 def update_cursor_rect
    # カーソル位置が 0 未満の場合
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # 現在の行を取得
    row = @index / @column_max
    # 現在の行が、表示されている先頭の行より前の場合
    if row < self.top_row
      # 現在の行が先頭になるようにスクロール
      self.top_row = row
    end
    # 現在の行が、表示されている最後尾の行より後ろの場合
    if row > self.top_row + (self.page_row_max - 1)
      # 現在の行が最後尾になるようにスクロール
      self.top_row = row - (self.page_row_max - 1)
    end
    # カーソルの幅を計算
    cursor_width = self.width / @column_max - 32
    # カーソルの座標を計算
    x = @index % @column_max * (cursor_width + 32)
    y = @index / @column_max * 27 - self.oy
    # カーソルの矩形を更新
    self.cursor_rect.set(x, y, cursor_width, 27)
  end

Vous avez modifié l’ordonnée du curseur et sa hauteur à 27 pixels.

Window_Command2 devient une sous-classe de Window_Selectable2 :

Code: Tout sélectionner

 class Window_Command2 < Window_Selectable2

Dans Window_Command2 changez la taille de la police (20 çà va bien ici).

Code: Tout sélectionner

 self.contents.font.size = 20

Et changez également l’ordonnée à laquelle doit s’écrire le nom des sous-menus dans draw_item.

Code: Tout sélectionner

 rect = Rect.new(4, 27 * index, self.contents.width - 8, 27)

Reste à dire dans Scene_Menu que ce sont ces nouvelles directives qu’il faut suivre, pour cela mettez Window_Command2 là où il y a Window_Command.

Et voilà le résultat :

Il reste encore quelques détails graphiques à régler, mais laissons çà de côté pour l’instant. Si vous voulez plus de détails concernant ce point adressez vous à un scripteur ou envoyez moi un MP.

Bien considérons la phase d’aménagement terminée et passons à la suite.

Fenêtres du sous-menu :

Bien nous allons ici créer des scripts présentant l’interface du sous-menu, l’interaction sera vue dans la partie suivante. Courage, ce n’est pas encore fini.

Tout d’abord vous devez vous mettre en tête une image de votre menu, un découpage des fenêtres, l’emplacement des fonctions, les images… Tout cela dépend bien sûr de la fonctionnalité de votre sous-menu et de vos envies.

Les cadres définissant les fenêtres sont créés à partir de script de type Window. Nous allons expliquer tout çà sur un exemple.

Exemple :

Nous allons créer l’interface permettant de choisir une classe parmi une liste. Pour cela nous avons besoin d’une ligne indiquant la classe actuelle, une ligne où l’on voit les caractéristiques du héros et un cadre où l’on choisit la classe. On sépare en général ce genre de demande en deux scripts, l’un est le principal et l’autre porte l’épithète Status, qui comme l’indique son nom présente les caractéristiques du personnage.

Occupons nous de notre ClasseStatus. Créez au milieu des autres Window le script Window_ClasseStatus.

Code: Tout sélectionner

 class Window_ClasseStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #     actor : アクター
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 64, 640, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_state(@actor, 140, 0)
    draw_actor_hp(@actor, 284, 0)
    draw_actor_sp(@actor, 460, 0)
  end
end

Le but est de bien comprendre le fonctionnement de ce script pour ensuite faire le votre.
Etudions le en détail.

Code: Tout sélectionner

 class Window_ClasseStatus < Window_Base

On crée ici une nouvelle classe d’objet qui qui dérive de la sur-classe Window_Base, cela signifie que toutes les méthodes de Window_Base restent valable ici. En fait ce procédé permet de créer des objets différents à partir d’une classe générale plus modulable (un moule amovible en quelque sorte).

Code: Tout sélectionner

 def initialize(actor)
    super(0, 64, 640, 64)

initialize est la méthode qui crée l’objet, on l’appelle par la méthode .new.
super permet de faire appel à la méthode du même non dans la super classe.

Allons donc voir la méthode initialize de Window_Base

Code: Tout sélectionner

 def initialize(x, y, width, height)

Cela vous permet de saisir la signification des chiffres que nous avons choisi.
0 pour l’abscisse (x), on place la fenêtre contre la bordure gauche de l’écran.
64 pour l’ordonnée (y), on laisse de la place pour la ligne présentant la classe actuelle du héros.
640 de largeur (width) cela fait tout l’écran.
64 de hauteur (height) une ligne d’écriture (32 pour écrire et 2 x 16 de bordure).

Code: Tout sélectionner

 self.contents = Bitmap.new(width - 32, height - 32)

Ici on crée véritablement notre fenêtre de largeur 640 (celle que l’on a indiqué) moins 32 pour faire les bordures (2 x 16). Idem pour la hauteur.

Les deux lignes suivantes règlent la police et la taille de caractères.

Code: Tout sélectionner

 @actor = actor

Souvenez vous que l’on a demandé en argument de notre initialize actor (le perso), on le place donc dans une variable disponible dans toute la classe (grâce au @).
Vous comprenez que le sous-menu est propre à chaque personnage (comme les compétences) donc il faut nécessairement préciser que l’on appelle le sous-menu dédié à un personnage particulier.

On appelle ensuite la méthode refresh qui comme son nom l’indique met à jour la fenêtre en fonction de plusieurs paramètres, ici en fonction du héros.

Code: Tout sélectionner

 def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_state(@actor, 140, 0)
    draw_actor_hp(@actor, 284, 0)
    draw_actor_sp(@actor, 460, 0)
  end

On efface (clear) ce qu’il y a dans la fenêtre (pour éviter que des données se chevauchent en cas de changement). Ensuite on écrit nom, état, hp et sp sur la ligne (y = 0) séparés (les x sont choisis pour).
Pour plus d’infos concernant ces méthodes regardez leur définition dans Window_Base.

Créons ensuite le corps de notre sous-menu, avec le script Window_Classe

Code: Tout sélectionner

 class Window_Classe < Window_Selectable
  #--------------------------------------------------------------------------
  # ● Initialise
  #     actor : choix du perso
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 128, 640, 352)
    @actor = actor
    @column_max = 2
    refresh
    self.index = 0
  end

On va créer un menu de choix qui dérive donc de Window_Selectable. Dans la définition, on choisit les mêmes paramètres que précédemment pour que notre cadre remplisse bien l’espace qui lui est dévolu (quelques calculs sur papier vous aideront grandement).

Notez que l’on choisit 2 colonnes car cela se présente assez bien.

Index désigne l’emplacement du curseur on le place au départ à 0.

Voici la règle de remplissage pour les index : on commence à 0 première ligne et première colonne puis on ajoute 1 en passant à la colonne suivante, quand il n’y a plus de colonne on passe au début de la ligne suivante en ajoutant encore 1 et ainsi de suite.

Code: Tout sélectionner

  #--------------------------------------------------------------------------
  # ● job
  #--------------------------------------------------------------------------
  def job
    return @data[self.index]
  end

Cette méthode à pour but de renvoyer l’élément du tableau nommé @data d’indice self.index (la position du curseur). C’est utile dans certains cas.

Code: Tout sélectionner

  #--------------------------------------------------------------------------
  # ● Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for i in 0...@actor.class_list.size
      job = @actor.class_list[i]
      if job != nil
        @data.push(job)
      end
    end
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end  

Admirez car vous voici au cœur du sous-menu. Ici vous réglez sa présentation.
Les premières lignes servent juste à remettre les pendules à 0.

Vous remarquez que l’on définit ici le fameux tableau @data, vide à l’origine.
Ensuite une boucle for.
Alors pour i variant de 0 à la longueur du tableau des classes du personnage sélectionné on effectue les commandes suivantes (en fait cela permet de passer en revue toutes les classes contenues dans le tableau des classes du perso).

job prend la valeur de l’élément en position i du tableau des classes du personnage sélectionné. En gros job c’est la ième classe du tableau.
Si job existe (le tableau n’est pas vide) alors on l’ajoute au tableau @data.
On appelle @item_max la longueur du tableau @data.

Si @item_max est plus grand que 0 (s’il y a des classes dans @data), on rempile sur une boucle for qui va appeler la méthode draw_item avec pour argument i.

Définissons cette méthode qui a simplement pour but d’écrire le nom des classes dans le menu.

Code: Tout sélectionner

  #--------------------------------------------------------------------------
  # ● 項目の描画
  #     index : 項目番号
  #--------------------------------------------------------------------------
  def draw_item(index)
    job = @data[index]
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.draw_text(x + 28, y, 204, 32, $data_classes[job].name, 0)
  end

Comprenez simplement que pour chaque i précédemment défini (ici appelé index), on pose x et y correspondant à la position de l’endroit où on écrit le nom de la classe.
Ensuite on dessine un rectangle, on définit l’opacité puis on écrit le texte dans le rectangle.

Code: Tout sélectionner

  #--------------------------------------------------------------------------
  # ● ヘルプテキスト更新
  #--------------------------------------------------------------------------
  def update_help
    @help_window.set_text(self.job == nil ? "" : "Classe actuelle: "+$data_classes[@actor.class_id].name.to_s)
  end
end 

Cette méthode permet de générer la ligne qui contiendra la phrase « Classe actuelle : nom de la classe ».

class_id renvoie en effet le numéro de la classe actuelle du héros.
$data_classes est le tableau des classes du jeu.
name permet d’appeler le nom de la classe en question.

Résumons ce que nous venons de faire. Nous avons créé deux fenêtres pour notre sous-menu. La première affiche le nom et les caractéristiques du héros, la seconde permet d’afficher la liste des classes disponibles.

Si vous avez quelques difficultés à comprendre le fonctionnement des boucles mises en jeu, je ne saurais que trop vous conseiller de consulter les cours de ruby sur ces boucles.

Script principal :

Reprenez le script Scene_Classe. Nous allons décrire la manière dont vont être disposées et gérées les différentes fenêtres.

En dessous de :

Code: Tout sélectionner

 class Scene_Classe

Placez :

Code: Tout sélectionner

 #--------------------------------------------------------------------------
  # ● Initialize
  #     actor_index : choix de perso
  #-------------------------------------------------------------------------- 
    def initialize(actor_index = 0)
    @actor_index = actor_index
  end

Ceci définit les paramètres dont dépend notre Scene. Je disais plus haut que le sous-menu est particulier à chaque héros, on désigne ce héros à travers son indice dans le menu principal : actor_index. Pour pouvoir utiliser cet indice partout dans la classe on crée une variable de classe @actor_index.

Code: Tout sélectionner

#--------------------------------------------------------------------------
  # ● Main
  #--------------------------------------------------------------------------
    def main
     @actor = $game_party.actors[@actor_index]
     @help_window = Window_Help.new
     @status_window = Window_ClasseStatus.new(@actor)
    @classe_window = Window_Classe.new(@actor)
    # ヘルプウィンドウを関連付け
    @classe_window.help_window = @help_window
    # トランジション実行
    Graphics.transition
    # メインループ
    loop do
      # ゲーム画面を更新
      Graphics.update
      # 入力情報を更新
      Input.update
      # フレーム更新
      update
      # 画面が切り替わったらループを中断
      if $scene != self
        break
      end
    end
    # トランジション準備
    Graphics.freeze
    # ウィンドウを解放
    @help_window.dispose
    @status_window.dispose
    @classe_window.dispose
  end   

Reprenons cette partie pas à pas. C’est ici que l’on dit quelles fenêtres on va placer et où on va les placer. Mais pas seulement, on commence d’ailleurs par chercher le héros concerné par le sous-menu. Ensuite on crée trois fenêtres. Vous objecterez que l’on n’en a créé que deux. En fait il suffit de regarder cette ligne pour comprendre :

Code: Tout sélectionner

 @classe_window.help_window = @help_window

Notre fenêtre Window_Classe possède bien une méthode help_window et c’est cette méthode qui définit ce qui sera affiché dans la troisième fenêtre (astucieux le deux en un non ?).

La suite permet de gérer le bon fonctionnement du sous-menu avec les mises à jours, etc… Il ne vous est pas utile de tout comprendre à ce niveau.

Les trois dernières lignes (sans compter le end) gèrent l’effacement des fenêtres, c’est une étape obligatoire.

Code: Tout sélectionner

#--------------------------------------------------------------------------
  # ● update
  #--------------------------------------------------------------------------
  def update
    # ウィンドウを更新
    @help_window.update
    @status_window.update
    @classe_window.update
    # アイテムウィンドウがアクティブの場合: update_item を呼ぶ
    if @classe_window.active
      update_classe
      return
    end
  end

Cette méthode demande la mise à jour de nos trois fenêtres. Cette mise à jour a les effets que nous avons demandés dans las scripts définissant ces fenêtres.
Si la fenêtre @classe_window est active, on appelle la méthode update_classe, que l’on va s’empresser de définir, vous commencez à avoir l’habitude.

Code: Tout sélectionner

 def update_classe
    
    #retourne au menu
    if Input.trigger?(Input::B)
      # キャンセル SE を演奏
      $game_system.se_play($data_system.cancel_se)
      # メニュー画面に切り替え
      $scene = Scene_Menu.new(3)
      return
    end  
   
    #change la classe du perso
      if Input.trigger?(Input::C)
      # 装備 SE を演奏
      $game_system.se_play($data_system.decision_se)
      @classe = @classe_window.job
      @actor.class_id = @classe
     
    # R ボタンが押された場合
    if Input.trigger?(Input::R)
      # カーソル SE を演奏
      $game_system.se_play($data_system.cursor_se)
      # 次のアクターへ
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # 別のステータス画面に切り替え
      $scene = Scene_Classe.new(@actor_index)
      return
    end
    # L ボタンが押された場合
    if Input.trigger?(Input::L)
      # カーソル SE を演奏
      $game_system.se_play($data_system.cursor_se)
      # 前のアクターへ
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # 別のステータス画面に切り替え
      $scene = Scene_Classe.new(@actor_index)
      return
    end

      @status_window.refresh
      @classe_window.refresh
      return
    end
  end 
end

Ici on gère ce qui se passe en fonction des touches appuyées.

Si c’est le bouton d’annulation (B) on demande un retour au menu principal par la même méthode que celle qui à servi à entrer dans le sous menu (en changeant la variable $scene).

Si c’est le bouton d’action (A) on met dans la variable @classe ceci @classe_window.job, je rappelle que job renvoie l’élément à la position du curseur du tableau @data de Window_Classe, soit pour faire simple le numéro de la classe sélectionnée avec le curseur. Enfin on change la classe du héros pour cette classe ci.

Les deux dernières commandes permettent de passer directement d’un personnage à l’autre par utilisation des touches Left et Right. Ce qui évite de repasser par le menu principal pour changer la classe de plusieurs personnages.

Et les deux dernières lignes actualisent nos fenêtres pour rendre compte de notre choix.

Voilà ce à quoi ressemble le sous-menu ainsi terminé.

Si vous avez beaucoup de commandes à rajouter ainsi, ou si vous voulez conservez l'affichage (indispensable !) du nombre de pas du héros, vous avez aussi la possibilité d'utiliser ce script.
Il permet de masquer une partie de la liste de commandes où vous avez rajouté un, deux ou ... beaucoup, de sous-menus.

Sur le tutoriel en lui même l'intérêt est assez limité (changer la classe d'un héros), mais son application vous permettra, au grès de votre imagination, de faire beaucoup plus.

Je ne connaissais pas l'existence de ce script, mais c'est encore une solution. Le tuto a beau être détaillé, il ne sera exhaustif ^^

Merci en tout cas.

Merci beaucoup !

Est-ce qu'on peut mettre une icône à côté du nom des classes?
Au fait le tuto est vraiment bien. Il m'en a appris des choses -_-"!

Extrait de Window_Base qui permet de dessiner l'icone d'un objet à coté de son nom :

Code: Tout sélectionner

  def draw_item_name(item, x, y)
    if item == nil
      return
    end
    bitmap = RPG::Cache.icon(item.icon_name)
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 28, y, 212, 32, item.name)
  end

T'as toutes les cartes en main.