TP : Le joueur personnalise le héros.

But : Le joueur pourra, via des fenêtres de sélection, choisir l'habillement du héros. Ce TP n'ira pas jusqu'à enregistrer le héros afin de jouer avec (sera vu plus tard)





Ce tutorial est très bien puisqu'il est répétitif ... rien de mieux pour rentrer dans la tête la notion de scène, Sprite et fenêtre de sélection.

Les ressources : Templates RMXP

Ce que nous aurons besoin :



- Une fenêtre de sélection principale qui sera toujours visible
- 2 fenêtres de sélection cachées au départ dont une fenêtre pour sélectionner la tête et l'autre le corps. La fenêtre sera visible seulement quand on choisit celle ci dans la fenêtre de sélection principale
- Un Sprite pour la tête du héros
- Un Sprite pour le corps du héros
- Et le tout dans une scène :)

I) La structure de notre classe.

La classe est une scène. Nous allons l'appeler "Scene_Character_Custom". Nous allons avoir 5 méthodes :
- "main" : comme d'habitude. On va initialiser le tout dedans.
- "update" : sans surprise : les mises à jour du tout.
- "update_command" : Pour la fenêtre de sélection principal : interactivité
- "select_tete" : quand le joueur sera sur la fenêtre de sélection "Tête"
- "select_corps" : quand le joueur sera sur la fenêtre de sélection "Corps"

Voici notre classe :

Code Ruby

class Scene_Character_Custom
  def main  
   
  end
  def update
 
  end  
  def update_command
 
  end
  def select_tete
 
  end
  def select_corps

  end
end

II) La méthode "main"

a) Fenêtre de sélection principale
C'est la méthode la plus longue à écrire. Nous allons créé les fenêtres comme d'habitude. On va commencer à faire la fenêtre de sélection principale :

Code Ruby

def main
  # Les commandes principales : c'est un tableau
  array_command_principal = [
  "Têtes",
  "Corps",
  "Valider"
  ]
  # On crée une nouvelle commande
  @command_window_principal = Window_Command.new(192, array_command_principal)
  # On la place
  @command_window_principal.x = 5
  @command_window_principal.y = 5

Rien de nouveau. On fait une fenêtre de sélection avec les différentes commandes. La nouveauté, peut être, intervient avec les méthodes "x" et "y" qu'on applique sur "@command_window_principal". On fait, cela permet juste de positionner la fenêtre sur l'écran.

Mais, on le fait pas avec "super" dans les classes "Window" ?

Si, on peut le faire. Mais ici c'est une autre manière : plus simple car cela évite de réécrire des classes "Window".

b) Fenêtre de sélection "Tête"

Passons à notre deuxième fenêtre de sélection,la fenêtre "Tête" :

Code Ruby

# ------- Fenêtre de Sélection 2 ------------  
# Les commandes pour la tête du héros
array_command_tete = [
"Blond",
"Gris",
"Brun"
]
# Les images correspondant aux têtes
@array_filename_tete = [
"nom de l'image tête 1",
"nom de l'image tête 2",
"nom de l'image tête 3"
]
# Création de la fenêtre de sélection pour les têtes
@command_window_tete = Window_Command.new(192, array_command_tete)
# Positions X et Y
@command_window_tete.x = 5
@command_window_tete.y = @command_window_principal.width + 10
# Rend invisible et non active
@command_window_tete.active = false
@command_window_tete.visible = false

Il y a déjà plus de chose, n'est ce pas ? ^^.
Le premier tableau nommé "array_command_tete" contient les commandes comme la première fenêtre créée. Le deuxième tableau contient les images respectives aux commandes. Ainsi, "nom de l'image tête 1" sera pour la commande "Blond" ...etc. Ce tableau, on s'en servira plus tard.

Attention : N'oubliez pas de mettre un "@" à la variable "array_filename_tete" car on se servira de cette variable dans d'autres méthodes de cette classe.

Remarquez ensuite que pour positionner cette fenêtre sur l'ordonnée Y de la fenêtre, on utilise "@command_window_principal.width + 10". Cela signifie que vous prenez la largeur de fenêtre de sélection principale et vaut rajouter 10. ça le place automatiquement en dessous de la fenêtre de sélection principale sans la superposer.

Enfin, voici deux codes importants :

Code Ruby

@command_window_tete.active = false
@command_window_tete.visible = false

"active" permet d'activer ou non le curseur sur la fenêtre. Ainsi quand la fenêtre n'est plus active, le joueur ne plus plus déplacer le curseur.

b) Fenêtre de sélection "Corps"

Maintenant, créons la troisième fenêtre de sélection, la fenêtre "Corps". Si vous avez compris, vous pouvez la faire toute seule. C'est la même démarche que ci-dessus :

Code Ruby

# ------- Fenêtre de Sélection 3 ------------
     
# Les commandes pour le corps du héros
array_command_corp = [
"Snob",
"Archer",
"Cape"  
]  
# Les images correspondant aux corps
@array_filename_corp = [
"nom de l'image corps 1",
"nom de l'image corps 2",
"nom de l'image corps 3"
]
# Création de la fenêtre de sélection pour les corps
@command_window_corp = Window_Command.new(192, array_command_corp)
# Positions X et Y
@command_window_corp.x = 5
@command_window_corp.y = @command_window_tete.y
# Rend invisible et non active
@command_window_corp.active = false
@command_window_corp.visible = false

Pour la position Y, on a donné la même valeur que la fenêtre de sélection "Tête" pour que ces deux fenêtres soient à la même hauteur.

d) Les Sprites "Tête" et "Corps"

Cela sera très rapide. Il suffit de créer deux Sprites et de les positionner :

Code Ruby

# ------- Sprite 1 ------------  
@sprite_for_tete = Sprite.new
@sprite_for_tete.x = 300
@sprite_for_tete.y = 200    
   
# ------- Sprite 2 ------------
@sprite_for_corp = Sprite.new
@sprite_for_corp.x = 300
@sprite_for_corp.y = 200

Mais ... on ne mets pas de "Bitmap" ?

Vous pouvez mettre un Bitmap par défaut mais celui ci est facultatif. En fait, pour changer le Sprite, nous allons changer tout bêtement le Bitmap du Sprite (plus tard)

e) La fin de "main"

Pour finir la méthode "main", nous allons faire le fameux code qui faut à chaque fois mettre dans une scène :

Code Ruby

# Mise à jour de la scène
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @command_window_principal.dispose
    @command_window_tete.dispose
    @command_window_corp.dispose
   @sprite_for_tete.dispose
   @sprite_for_corps.dispose
   @sprite_for_tete.bitmap.dispose if @sprite_for_tete.bitmap != nil
   @sprite_for_corp.bitmap.dispose if @sprite_for_corp.bitmap != nil
 end # Fin de "main"

Note : On vérifie que les deux Bitmap des deux Sprites ne sont pas égal à "nil" pour les supprimer (sinon cela provoquera une erreur)

II) La méthode "update"

Cette méthode, déjà vu plusieurs fois, mettra à jour les fenêtres :

Code Ruby

def update
    @command_window_principal.update
    @command_window_tete.update
    @command_window_corp.update
   
    # Selon la fenêtre de sélection active
    if @command_window_principal.active
      update_command
    elsif @command_window_tete.active
      select_tete      
    elsif @command_window_corp.active
      select_corps
    end
  end

Ce qui va plus nous intéresser, c'est la condition :

=> Si la fenêtre de sélection principal est active (qu'on peut bouger le curseur) alors on appelle la méthode "update_command".
=> Sinon si la fenêtre de sélection "Tête" est active alors on appelle la méthode "select_tete".
=> Sinon si la fenêtre de sélection "Corps" est active alors on appelle la méthode "select_corps".

Selon, la fenêtre active, on appellera sa méthode qui permettra de faire les actions ce celle ci.

III) La méthode "update_command"

La méthode "update_command" intervient si le joueur est sur la fenêtre principal (donc qu'elle est active). Comme on l'a vu pour les fenêtres de sélection, on va prendre l'index de la sélection et faire les instructions :

Code Ruby

def update_command
    # Quand le joueur appuie sur Entrée
    if Input.trigger?(Input::C)
      # On désactive la fenêtre de séléction principal
      @command_window_principal.active = false
      # Selon la position du curseur
      case @command_window_principal.index
      when 0
        # On active et rend visible la fenêtre de séléction "Tete"
         @command_window_tete.active = true
         @command_window_tete.visible = true
      when 1
        # On active et rend visible la fenêtre de séléction "Corps"
         @command_window_corp.active = true
         @command_window_corp.visible = true
      when 2
        # "Valider" : Sera fait dans un autre TP
      end
    end
  end

Pas de nouveauté pour la démarche. Quand le joueur appuie sur Entrée, on désactive automatiquement la fenêtre principale : le joueur ne peut plus bouger le curseur. Ensuite, on regarde qu'est ce que le joueur a sélectionné. Dans ce cas, on active la nouvelle fenêtre ("Tête" ou "Corps") et on la rends visible. Ainsi, le joueur pourra librement bouger le curseur dans la nouvelle fenêtre qui a apparut mais plus dans la fenêtre principale.

IV) La méthode "select_tete"

Imaginons que le joueur a sélectionné ci-dessus la fenêtre "Tête". Dans ce cas, la fenêtre "Tête" est active mais plus (je me répète) la fenêtre principale donc dans la méthode "update", ça sera maintenant "select_tete" qui sera appelé.

Voici comment commence la méthode "select_tete" :

Code Ruby

def select_tete
  #Affiche le Sprite "Tête" selon la position du curseur  
  index = @command_window_tete.index
  @sprite_for_tete.bitmap = RPG::Cache.picture(@array_filename_tete[index])
# @sprite_for_tete.bitmap = Cache.picture(@array_filename_tete[index])- RGSS 2

Et c'est là qu'intervient le changement de Sprites ^^. On va donner au Bitmap du Sprite "Tête", l'image dans le tableau créé dans "main" selon l'index du curseur.

Note : "RPG::Cache.picture(nom_image)" revient à faire "Bitmap.new(Graphics/Pictures/nom_image)"

Pour terminer la méthode "select_tete" :

Code Ruby

if Input.trigger?(Input::B)
      # Activation de la fenêtre principale
      @command_window_principal.active = true
      # Rend invisible et inactive cette fenêtre
      @command_window_tete.active = false
      @command_window_tete.visible = false
    end
  end # Fin de "select_tete"

Si le joueur appuie sur "Echap" ou "B", on va faire le processus inverse de tout à l'heure : on active la fenêtre principale et on désactive cette fenêtre et on la cache. Du coup, le joueur pourra re choisir dans la fenêtre principale la tête ou le corps du héros. Notez que le Sprite disparait pas ! Seulement la fenêtre, évidemment.

V) La méthode "select_corps"

La dernière méthode permettra au joueur de choisir le corps du héros. C'est strictement la même chose que ci-dessus. Normalement, vous êtes capable de faire cette méthode tout seul ^^ :

Code Ruby

def select_corps
  #Affiche le Sprite "Corps" selon la position du curseur  
  index = @command_window_corp.index
  @sprite_for_corp.bitmap = RPG::Cache.picture(@array_filename_corp[index])
  # @sprite_for_corp.bitmap = Cache.picture(@array_filename_corp[index]) - RGSS 2
   
   # Si on revient à la fenêtre principale en appuyant sur Echap
    if Input.trigger?(Input::B)
    # Activation de la fenêtre principale
      @command_window_principal.active = true
       # Rend invisible et inactive cette fenêtre
       @command_window_corp.active = false
      @command_window_corp.visible = false
    end
  end
end # Fin de la classe et du script :)

VI) Conclusion

Si vous avez compris le changement de fenêtres avec "active" et la visibilité avec "visible", vous êtes capables de faire des scènes déjà intéressantes :) Sachez que le script de base "Scene_Menu" est la même chose que ci-dessus même en plus simple, peut être. Vous voyez : en quelques tutoriels, on est capable de faire des scripts ^^