Faire un système de chapitres.

But : Le joueur pourra choisir son chapitre après l'écran titre. Il sera téléporté vers la map selon le chapitre.
Connaissances en Ruby requises : Vous devez connaitre au moins les chapitres jusqu'au chapitre "Classes".

Aperçu :



Comme vous le voyez sur l'aperçu ci-dessus, nous aurons besoin de 2 fenêtres : une qui sera plutôt décorative et l'autre interactive. Nous aurons donc 2 classes :)

Nous allons commencer par la fenêtre dite "décorative", celle qui possède la phrase "Veuillez choisir un chapitre". On nommer la classe "Window_Chapitre" et héritera de la classe " Window_Base".

Remarque : Si le mot "hériter" est encore inconnu pour vous, lisez les cours "Programmation Orientée Objet". Pour la création de ce script, la notion d'héritage n'a pas vraiment d'importance, vous comprendrez fur et à mesure, à force de créer des scripts et d'utiliser la POO.

1) La fenêtre descriptive : "Window_Chapitre".

La classe "Window_Chapitre" aura deux méthodes : "initialize" permettra d'initialiser les variables et "refresh" pour afficher tout bêtement le texte. Voici la composition de la classe pour le moment :

Code Ruby

class Window_Chapitre < Window_Base
 def initialize(win_width, win_height)
 
  end
  def refresh
   
  end
end

a) La méthode "initalize"

Comme vous l'avez remarqué, la méthode contient deux paramètres : "win_width" et "win_height". Le premier permettra de définir la longueur de la fenêtre et l'autre sa hauteur. On aurait pu les définir aussi dans la méthode au lieu de les mettre en paramètre.
Nous allons définir donc la taille de la fenêtre. Pour cela, on va utiliser "super".

Remarque : "super" permet d'appeller la méthode du même nom dans la classe parente donc, ici, la méthode "initalize" de Window_Base.

Code Ruby

# super(postion x, position y, longeur, hauteur)
 super(x, y, win_width, win_height)

Nous allons mettre 4 variables : x, y et win_width, win_height où ces deux derniers on été défini comme paramètre. Nous allons initialiser les positions x et y. On va donner la valeur 200 à y mais pour x, nous allons faire un léger calcul pour pouvoir center la fenêtre.

La longeur de l'écran mesure 640px, la moitié est donc 640 / 2. Sur le shéma ci-dessus, la fenêtre ce situe actuellement sur la zon verte. Pour le centrer, il suffit de soustraire la moitié de la fenêtre.

Code Ruby

x = 640 / 2 - win_width / 2
y = 200
super(x, y, win_width, win_height)

Nous allons créer un Bitmap ... comme d'habitude quand on créé une fenêtre, avec en paramètre sa largeur et hauteur. On va définir le type et la taille d'écriture en reprenant les variables globales déjà créées dans le script "Main" : $fontface et $fonsize
Pour terminer cette méthode, on appelle la méthode "refresh" que l'on va créé après pour afficher le texte. On a donc actuellement :

Code Ruby

class Window_Chapitre < Window_Base
 def initialize(win_width, win_height)
        # On centre la fenêtre
    x = 640 / 2 - win_width / 2
    y = 200
    super(x, y, win_width, win_height)
        # On créé le Bitmap
    self.contents = Bitmap.new(width - 32, height - 32)
        # On définit le type et la taille d'écriture
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
        # On appelle la méthode "refresh" pour initialiser le texte te l'afficher sur le Bitmap.
    refresh
  end
  def refresh
   
  end
end

b) La méthode "refresh"

En une ligne, la méthode est écrite :

Code Ruby

# self.contents.draw_text(position x, position y, longueur, hauteur, "Texte")
 self.contents.draw_text(0, 0, 300, 32, "Veuillez choisir un chapitre")

c) La classe complète de "Window_Chapitre"

Voici donc la classe complète :

Code Ruby

class Window_Chapitre < Window_Base
 def initialize(win_width, win_height)
        # On centre la fenêtre
    x = 640 / 2 - win_width / 2
    y = 200
    super(x, y, win_width, win_height)
        # On créé le Bitmap
    self.contents = Bitmap.new(width - 32, height - 32)
        # On définit le type et la taille d'écriture
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
        # On appelle la méthode "refresh" pour initialiser et texte et l'afficher sur le Bitmap.
    refresh
  end
  def refresh
        # On écrit le texte
    self.contents.draw_text(0, 0, 300, 32, "Veuillez choisir un chapitre")
  end
end

2) La fenêtre interactive : "Scene_Chapitre"

En fait, étant donné que le joueur interagit, on appelle ça une scène :).
On aura 3 méthodes :
- "main" pour initialiser les variables
- "update" pour les mises à jour et le choix du joueur sur le chapitre.
- "game_position" qui placera le héros sur une map selon le chapitre choisit.

Voici la structure :

Code Ruby

class Scene_Chapitre
        def main
 
        end
        def update
 
        end
        def game_position(id = $data_system.start_map_id, x = $data_system.start_x, y = $data_system.start_y)
   
        end  
end

La méthode "game_position" aura comme paramètre : "id" pour l'ID de la map, "x" et "y" la position x et y.
Si un paramètre n'est pas précisé, il prendra l'ID ou la position x ou y du départ du héros.

a) La méthode "main".

On va afficher au fond de l'écran, l'image de l'écran titre.

Code Ruby

@sprite = Sprite.new
# "$data_system.title_name" est le nom enregistrée dans la base de données (BDD)
@sprite.bitmap = RPG::Cache.title($data_system.title_name)

On créé une variable d'instance @sprite et on met au fond de l'écran, l'image enregistrée dans la base de données.

Note : "Les Sprites sont un concept basique utilisé pour afficher les personnages, etc. à l'écran." - Aide RMXP

Nous allons créer la fenêtre des chapitres avec le curseur de sélection. En fait, la classe "Window_Command", qui déjà existant, permet de faire cette fenêtre.

Code Ruby

# Les éléments de la sélection
     s1 = "Chapitre 1"
     s2 = "Chapitre 2"
     s3 = "Chapitre 3"
    # Création de la fenêtre de sélection de largeur 192px et contenant les éléments ci-dessus
        # Window_Command.new(largeur, [commandes ...])
    @command_window = Window_Command.new(192, [s1, s2, s3])

En quelques lignes, vous créez une fenêtre avec une sélection :)

Nous allons donner une opacité et on va centrer encore une fois de la même manière que "Window_Chapitre".

Code Ruby

# On fixe l'opacité à 160 sur 255 pour cette fenêtre et on la place aux positions X et Y où X est centrer et Y vaut 300
@command_window.back_opacity = 160
@command_window.x = 640 / 2 - @command_window.width / 2
@command_window.y = 300

Comme on créé la fenêtre interactive, on va initialiser la fenêtre descriptive

Code Ruby

# Window_Chapitre.new(largeur, hauteur)
@window_chapitre = Window_Chapitre.new(300, 64)

Nous allons faire la mise à jour permanence des images ...etc. ce qui doit être fait à chaque fois lorsque on fait une "Scène"

Code Ruby

# Transition jusqu'a l'écran actuelle
Graphics.transition
# Boucle infinie
loop do
  # Mise à jour des images et des données d'entrée (clavier)
  Graphics.update
  Input.update
  # On appelle la méthode "update"
  update
 # Si la scene actuelle est différente de la classe. En clair, si on sort cette classe ...
if $scene != self
 # On sort de la boucle et on éxécute le reste.
     break
   end
end

Lisez les commentaires :). Utilisez à chaques fois cette méthode pour mettre à jour les images dans votre scène.

Code Ruby

Graphics.freeze

@command_window.dispose
@sprite.bitmap.dispose
@sprite.dispose
@window_chapitre.dispose

Après avoir quitter la boucle (quand on quitte la scène), on gèle l'écran et on supprime les fenêtres et les sprites.

Note : "Graphics.freeze : Gèle l'écran actuel pour la préparation des transitions. Les réécriture d'écran sont interdites jusqu'à ce que la méthode de transition soit appelée." - Aide RMXP


b) Méthode "update"

On mets à jour les fenêtres pour rafraichir le clignotement du curseur et l'animation graphique de pause (Aide RMXP). Maintenant, on va appeller la méthode "game_position" selon le chapitre choisit, selon la position du curseur quand le joueur appuie sur la touche C ou Entrée.

Code Ruby

 def update
   #Mise à jour des fenêtres
     @command_window.update
     @window_chapitre.update
  # Lorsque le joueur appuie sur la touche C ou Entrée
    if Input.trigger?(Input::C)
      # Selon la position du curseur (0,1 ou 2), on appelle la méthode "game_position"
      case @command_window.index
      when 0  # Chapitre 1
         game_position # Positionne le héros sur le point de départ
      when 1  # Chapitre 2
        game_position(5, 9, 10) # Positionne le héros sur la carte n°5 aux positions X = 5 et Y = 10
      when 2  # Chapitre 3
        game_position(9, 7, 6) # Positionne le héros sur la carte n°9 aux positions X = 7 et Y = 6
      end
    end
  end

"@command_window.index" est position du curseur (de 0 à nombre de commandes - 1). Les commentaires disent la suite :)

c) Méthode "game_position"

On va téléporter le héros vers la map et les positions x et y. Pour cela, on possède les variables, souvenez vous, "id", "x" et "y". A la fin, on change de scène :

Code Ruby

# "game_position" permet de mettre le héros sur la carte selon le chapitre. "id" est le numéro de la carte.
  # "x" et "y" les positions où le héros sera placé. Par défaut,"id", "x" et "y" prennent les valeurs du point de
  # départ définie par vous même
  def game_position(id = $data_system.start_map_id, x = $data_system.start_x, y = $data_system.start_y)
   # On place le héros sur la carte n°id aux positions x et y  
    $game_party.setup_starting_members
        # Placement sur la map numéro de l'id
    $game_map.setup(id)
        # Positions X et Y
    $game_player.moveto(x, y)
        # Mise à jour et joue la musique automatiquement de la carte
    $game_player.refresh
    $game_map.autoplay
    $game_map.update
        # On change de scène et on va sur la map
    $scene = Scene_Map.new
  end