Utiliser les données sélectionnées
- Suite du TP "Le joueur personnalise le héros." -

Souvenez vous du TP "Le joueur personnalise le héros." ? Rien de mieux pour savoir utiliser les fenêtres. Mais voilà, nous nous étions arrêté à la sélection de l'apparence du héros. Ce tutorial va expliquer comment mettre l'apparence du héros sélectionné sur la carte et donc que le joueur utilise l'apparence de son choix.

1) Le contexte.

Nous avons fais divers fenêtre principalement de sélections. Nous avons 2 sprites :

@sprite_for_tete : Le Sprite "Tête"
@sprite_for_corp : Le Sprite "Corps"

Chaques Sprites prend une valeur, un Bitmap, quand on sélectionne un corps ou une tête

Les données seront "sauvegardées" quand on le joueur valide dans la fenêtre de sélection principale. Quand le joueur fait cette action, on arrive, dans la méthode "update_command", ici:

Code Ruby

when 2
   # "Valider" : Sera fait dans un autre TP
  end

Le commentaire était mis dans le tutorial précédent. Le code qu'on va effectué sera dedans !

2) La classe "Game_Character_Custom" pour les données.

Souvent dans RPG Maker XP/VX, les classes commençant par "Game" sont des classes ayant des données qui serveront pour des calculs ou l'utilisation dans d'autres scripts. Par exemple, le script "Game_Map" permet de savoir les données de la carte actuelle comme la liste des évènements, le brouillard utilisé ...etc. ou bien "Game_Screen" pour les données de l'écran comme le ton, le flash, la météo ...etc. Nous allons donc créer une classe du même genre mais très simplifié. On la nommera Game_Character_Custom.

Nous allons avoir 2 méthodes :
- initialize
- clear_chara_bitmap : pour supprimer le Bitmap "Character" sauvegardé.

Voici la classe complète :

Code Ruby

class Game_Character_Custom
  # Notre attribut
  attr_accessor :bitmap_chara
 
  def initialize
    # On initialie l'attribut quand on appelle la classe
    @bitmap_chara = nil
  end
 
  def clear_chara_bitmap
    #Supprimer le Bitmap revient à mettre notre attribut à nil
    @bitmap_chara = nil
  end
end

Nous faisons un attribut nommé "bitmap_chara". On pourra changer sa valeur ou la lire dans d'autres classes. Très pratique pour relever des données.

On peut donc créer une variable globale nommé, par exemple, $game_chara_custom qu'on va initialiser dans le script "Scene_Title" comme les autres variables globales "$game_troop", "$game_map" ...etc. :

Code Ruby

$game_chara_custom  = Game_Character_Custom.new

3) Revenons sur notre scène.

Revenons, en effet, dans la classe "Scene_Character_Custom" et ensuite dans le "when" vu plus haut
Nous allons assembler les deux Sprites : "Tête" et "Corps" pour former un personnage. Souvenez vous ... dit "assembler" dit "blt" sur notre Bitmap. C'est du déjà vu, il y aura pas de problème normalement.

Tout d'abord, nous allons tester si le joueur a bien sélectionné une tête et un corps. Si ce n'est pas le cas, il faut éviter d'assembler deux Bitmap qui n'existent pas. Une condition suffira :

Code Ruby

if @sprite_for_tete.bitmap != nil and @sprite_for_corp.bitmap != nil
     # Ici, le code que l'on va voir après
  elsif
      @command_window_principal.active = true
  end

On vérifie donc si les deux Bitmap ne valent pas "nil", sinon on réactive le curseur de la fenêtre principale pour que le joueur puisse continuer à sélectionner d'autres commandes (car on avait désactiver le curseur)

Le principe de "blt" sera simple. On prend la tête du héros, on le découpe (Rect) et on le colle sur le corps du héros. Cela nous donne :

Code Ruby

# Nous deux Bitmap  
bitmap_tete = @sprite_for_tete.bitmap
bitmap_corps = @sprite_for_corp.bitmap
#  On enregistre comme donnée, le Bitmap "Corps"          
$game_chara_custom.bitmap_chara = bitmap_corps.clone
# On prend la tête avec Rect
rect_tete = bitmap_tete.rect.set(0, 0, bitmap_tete.width, bitmap_tete.height)
# On colle la tête sur le Bitmap "Corp"
$game_chara_custom.bitmap_chara.blt(0, 0, bitmap_tete, rect_tete)

L'attribut "bitmap_chara" de la classe "Game_Chara_Custom" va prendre le Bitmap "Corps". La suite va permettre d'avoir notre Bitmap assemblé en collant la tête (qui est un rectangle) dans le Bitmap "Corps". L'attribut "bitmap_chara" est maintenant un personnage en entier ^^

Pourquoi applique t-on "clone" à "bitmap_corps" ?

"clone" permet de faire un clone d'un objet (voir documentation). Imaginons que nous n'ayons pas mis le "clone" :
"bitmap_corps" est un objet de la classe Bitmap. L'attribut "bitmap_chara" va prendre la valeur de "bitmap_corps" est sera donc aussi un objet de la classe Bitmap. Cependant, c'est deux variables différentes qui pointent sur le même objet. Du coup, quand vous supprimez en quittant la classe le Sprite "@sprite_for_corp" ( = "bitmap_corps") avec la méthode "dispose", vous supprimez aussi la donnée enregistrée dans l'attribut "bitmap_chara" ! ce qu'on ne veut pas. (Voir "Initiation à la Programmation Orientée Objet" par Åvygeil)

Pour finir, nous allons changer de scène et revenir sur la carte :

Code Ruby

$scene = Scene_Map.new

4) Changer le Sprite du héros par le nouveau

Oui, on a notre nouveau Bitmap précieusement enregistrer dans la classe "Game_Chara_Custom" mais il faut le changer par l'actuel. Direction donc "Spriteset_Map", où c'est ici qu'on définit les Sprites dès qu'on rentre sur la carte. Cette classe contient une variable nommé "@character_sprites". Si vous regardez bien la méthode "initialize", vous constatez qu'on rentre dans cette variable, qui est un tableau, plusieurs sprites de type "Sprite_Character". Ces sprites sont les évènements du jeu :

Code Ruby

@character_sprites = []
  for i in $game_map.events.keys.sort
    sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
    @character_sprites.push(sprite)
  end
@character_sprites.push(Sprite_Character.new(@viewport1, $game_player))

Quand on a fini la boucle "for", on enregistre, une fois seulement, encore un Sprite ... mais cette fois ci c'est notre héros. Il suffit donc de changer le Bitmap du dernier élément du tableau "@character_sprites". Faisons une méthode pour cela :

Code Ruby

def maj_heros
  @character_sprites[-1].bitmap = $game_chara_custom.bitmap_chara
end

Quand on appellera cette méthode, Le Bitmap du dernier élément du tableau, donc du héros", sera modifié par le nouveau Bitmap enregistré dans l'attribut "bitmap_chara".

La dernière étape est donc d'appeler cette méthode. Allons dans le script "Scene_Map". Dans l'initialisation, vous verrez qu'une variable nommé "@spriteset" est déjà un objet de la classe "Spriteset_Map". Nous allons donc appeler la méthode ci-dessus via cette variable. Pour que le changement soit fait automatiquement, nous allons le faire dans la méthode "update" de "Scene_Map" mais seulement une fois !

Code Ruby

if $game_chara_custom.bitmap_chara != nil
  @spriteset.maj_heros
  $game_chara_custom.clear_chara_bitmap
end

Si l'attribut "bitmap_chara" ne vaut pas "nil" donc qu'il y a un Bitmap :p, alors on appelle la méthode pour changer le Sprite et, grâce à la méthode "clear_chara_bitmap", on remet l'attribut "bitmap_chara" à nil. De ce fait, on a effectuer seulement une seule fois la condition et donc une seule fois le changement.

5) Conclusion

Ce tutorial vous a montrer quelques démarches pour changer les Sprites actuels mais aussi comment utiliser des données. Évidemment, le script n'est pas complètement fini car si le joueur va sur le menu et revient sur la carte, l'apparence du héros reviendra à celle qui est enregistré dans la base de données de RPG Maker. Si vous avez compris comment s'utilise les données en RGSS, vous arriverez à régler ce problème :)