Bonjour !

Désolé hier je n'ai finalement pas pu poster cette partie, j'ai du partir précipitamment

Voilà la suite du cours sur le RGSS (vous vous rappelez la différence avec le Ruby hein ? ^^ ) ! Voir la partie 1, dans le même topic

Je vous rappel que l'objectif est désormais de pouvoir construire des scripts (assez simples) concernant principalement l'affichage mais aussi, et peut-être des scripts divers.
Nous allons donc faire des choses plus "concrète" que la dernière fois, mais tout aussi importantes !

Sinon n'oubliez pas que le manuel d'aide d'RPG Maker Xp reste très sympa, pour notamment tout ce qui concerne les balises (codes pour désigner une action).

Bon et bien, sans plus attendre, le sommaire !

1) Structure d'un script et notion de classe "Window"
2) Fonctionnement et composition d'un script "Window"
3) Liste de balises
4) TP : fenêtre d'un menu
5) Intégration des fenêtres dans une scène
6) Programmation générale sous RM XP

[]

I) Structure d'un script et notion de classe "Window"

Dans la précédente partie, je vous ai déjà mis la structure d'un script, souvenez vous :

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

Nous allons reproduire le même schéma, afin de faire une fenêtre...
Déja, il faut savoir que pour s'afficher, une fenêtre doit être déclarée dans une variable, lorsque l'on se trouve dans une "Scene_" (même quand on fait insérer un script, car cette commande fonctionne avec "Scene_Map"), mais ça, nous y reviendrons plus tard...

Maintenant, tentons de construire un script "Window_" donc, une fenêtre.
Tout d'abord recopier le code que je viens de vous redonner, et collez le dans un nouveau script vide.
Vous pouvez appelez le script (je dis bien le script, c'est à dire le champs qui est dans la liste à gauche) comme vous voulez, mais bon, pour éviter de se perdre, il vaut mieux nommer vos scripts de manière méthodique, précises, et surtout claires... n'hésitez pas pour ça à créer des scripts vides ayant pour noms "###################" où "### ** WINDOWS ** ###" par exemple, pour classer artificiellement vos scripts...
Ici, nous pourrons appeler notre script "Window_Test".
Et bien sans plus tarder, modifiez le véritable nom de votre fenêtre, en modifiant le nom de la classe, et en mettant "Window_Test" (sans les guillemets bien-sûr ^^).
Cependant, votre script ne marchera pas si vous vous contentez de faire ça, il faut en effet dire à quelle super-classe appartient votre classe.
Le notion de super-classe est assez simple à comprendre : une super-classe est une classe qui contient toute sorte d'informations, et de choses prédéfinies qui sont utiles pour toutes les classes dépendantes...
L'intérêt des super-classe est d'éviter la répétition de certaines choses, et de fixer une bonne fois pour toute certaines bases (définition de variables).
Une des rares super-classe à laquelle vous ayez accès (et oui car vous n'avez pas accès à tous les scripts ! :p ) est la classe "Window_Base" (il y a aussi "Window_Selectable" ou encore "Game_Battler").
En effet, on y définit par exemple les noms des couleurs couramment utilisés, comme ça, pas besoin de les définir à chaque fois (surtout la couleur blanche :p).
Allez visiter ce script (qui d'ailleurs vous le remarquerez dépend lui aussi de la super-classe "Window" à laquelle nous n'avons pas accès) il peut être assez instructif

Bon, revenons à nous moutons, maintenant que la notion de super-classe est acquise (enfin je l'espère ^^) il faut écrire le "code" en conséquence qui n'est autre que :

Code: Tout sélectionner

< Window_Base

Vous devriez obtenir la ligne suivante :

Code: Tout sélectionner

class Window_Test < Window_Base

Passons désormais à la première méthode, la méthode "initialize".
Insérer entre "def initialize" et "@variable = 0" le code suivant :

Code: Tout sélectionner

super(0, 0, 250, 100)

Ce code signifie que nous créons une fenêtre rectangulaire dont les caractéristiques sont données par les 4 nombres donnés entre les parenthèses.
- Le premier nombre désigne en pixel la position horizontale (en abscisse) du premier point de la fenêtre, qui n'est autre que le pixel le plus en haut à gauche du rectangle. Plus ce nombre (qu'on appellera "x") est élevé, plus la fenêtre commence à droite (donc si on met zéro, ça colle le bord gauche de la fenêtre). Je rappelle que la fenêtre fait 640 pixels de largeur.
- Le deuxième nombre désigne la position verticale (en ordonnée) du premier point de la fenêtre. Plus ce nombre (qu'on appellera "y") est élevé, plus la fenêtre va vers le bas (donc si on met zéro, ça colle le bord supérieur de la fenêtre). Je rappelle que la fenêtre fait 480 pixels de hauteur.
- Le troisième nombre désigne la largeur en pixel de la fenêtre (je l'ai fixé ici à 250 pour avoir un peu de place). On le notera "w", pour "width".
- Le quatrième nombre désigne la hauteur de la fenêtre en pixel de la fenêtre. On le notera "h" pour "height".

Maintenant, nous avons "@variable = 0" ceci nous rappelle qu'il faut initialiser nos variables, et bien faisons le !
Copiez collez ceci à la place de "@variable = 0" :

Code: Tout sélectionner

self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize

Explications : La première ligne dit très exactement "le contenu de lui même (la fenêtre) est le bitmap suivant". Un bitmap, au passage, c'est un espace graphique où du texte va pouvoir apparaitre.
Vous savez désormais comment appeler (ou créer si vous voulez) un nouveau Bitmap. Ce dernier possède deux caractéristiques : une largeur et une hauteur.
Ici nous voyons que ces caractéristiques varient avec la largeur et la hauteur de la fenêtre.
"Mais, il y'a un problème !" me direz vous "nous n'avons pas défini ce qu'est "width" et "height" !"
Et vous n'aurez pas tout à fait tort ^^
En fait si, ces deux termes ont été définis dans la super-classe "Window_Base" (aux lignes 21 et 22 pour ceux qui n'ont pas touché au script) vous remarquez donc désormais l'utilité d'une super-classe, nous pouvons utiliser ces termes sans s'embêter ^^ Et si vous êtes toujours dans le script "Window_Base" vous remarquerez que les deux lignes du dessus (18 et 19 donc) crées elles aussi "des raccourcis" mais concernant cette fois x et y.
Donc, voilà pour le Bitmap...
Ensuite, le deux lignes suivantes (dans notre script hein ! ne nous perdons pas ! ^^) définissent respectivement le nom de la police d'écriture et la taille de l'écriture.
Comme vous le voyez, on définis ces paramètres par rapport à deux variables (globales au passage ) : "$fontface" et "$fontsize".
Ces variables ne sortent pas ne nul part, si vous cherchez bien vous les trouverez dans le script "Main"
Cependant, pour votre script "Window_Test" vous n'êtes pas obligé d'utiliser la police par défaut, mais mettre celle que vous voulez !
Ainsi pour cela il suffit de remplacer le "mot" $fontface par le nom exact de la police souhaité (entre guillemet).
Attention n'oubliez pas qu'il faut joindre la police en question (si elle est peu commune) lorsque que vous publiez votre projet sur le net, car si des personnes ne l'ont pas, lorsqu'elles voudront jouer => "Erreur" !! ^^
Enfin, à la fin de la méthode "initialize", vous devez mettre vers quelle méthode vous voulez allez une fois que l'initialisation est faite.
Généralement (je dis pas bien "généralement", pas "tout le temps" ^^) on fait aller à la méthode "refresh".

[]

II) Fonctionnement et composition d'un script "Window"

Pour ce chapitre, nous allons nous intéresser à la méthode "refresh", en effet, c'est la portion de codes la plus "importante".
Tout d'abord, une petite définition :
refresh signifie "rafraichir" en anglais, en effet, cette méthode s'exécutera toutes les frames lorsque que la fenêtre s'affichera.
refresh contient en effet les instructions codant pour l'affichage du contenu de la fenêtre.

Commençons à remplir les lignes :p
Comme cette méthode est un processus permanent (en gros qui tourne tout le temps), la première instruction consiste à effacer ce que vous avez afficher la frame précédente, car peut-être qu'entre ces deux frame, le joueur a fait une action qui doit modifier l'affichage, et par conséquent, il vaut mieux effacer les choses précédentes, et ne pas afficher par dessus, ça fait désordre ^^
Par exemple, on pourrait prendre le cas d'une fenêtre qui affiche en direct sur la map les points de vie du héros. La plupart du temps, elle ne bouge pas, mais si par exemple le héros reçois un coup, alors la valeur des HP ne sera plus la même, et donc la fenêtre doit mettre à jour son affichage, le rafraichir en quelque sorte... d'où le nom ! (la boucle est bouclée ^^).
Ainsi, juste en dessous de "def refresh" mettez le code (l'instruction) :

Code: Tout sélectionner

self.contents.clear

qui signifie littéralement "effacer.le contenu.de self" c'est à dire de la fenêtre...
Une fois ceci fait, on peut mettre tout le texte que l'on veut !

Maintenant intéressons nous à l'affichage du texte proprement dit.
Pour afficher du texte dans une fenêtre, cela se fait par le code suivant :

Code: Tout sélectionner

self.contents.draw_text(x, y, w, h, "Texte")

Cela signifie que le mot "Texte" s'écriera dans la fenêtre. Sa position en abscisse est de x (en pixel, attention à ne pas dépasser la largeur de la fenêtre ^^), sa position en ordonnée est de y (en pixel), la largeur du mot est de w (en pixel) et sa hauteur est de h...
Alors, vous allez me dire : "qu'est-ce que j'en sais moi de la largeur du mot, je l'ai pas mesuré !" et vous n'aurez pas tord ^^
C'est pour cela qu'on a inventer les deux commandes suivantes :

Code: Tout sélectionner

contents.text_size("Texte").width

Code: Tout sélectionner

contents.text_size("Texte").height

Je pense que vous aurez compris, la première instructions mesure la largeur exacte du mot "Texte", en tenant compte de la taille de la police, de la police et aussi de l'état du mot (gras ou italique).
La deuxième instruction fait de même pour la hauteur, mais elle est bien moins utilisée car peu utile mis à part si on a gros gros mot, on met souvent h = 32 pixels (pour la hauteur donc).
Ce n'empêche que c'est bien pratique ! :p
Alors concrètement, pour l'utiliser, on fait comment ?
Et bien juste avant le

Code: Tout sélectionner

self.contents.draw_text(x, y, w, h, "Texte")

on définit une variable qui va être égale à la largeur du mot (ou sa hauteur), et puis après on met cette variable à la place de h, en gros on fait ça :

Code: Tout sélectionner

w = contents.text_size("Texte").width
self.contents.draw_text(x, y, w, h, "Texte")

Et comme ça, "le jeu" connait la largeur du mot "Texte" avant de l'afficher...
Vous aurez remarquez que j'utilise une variable locale (voir la partie du cours si vous vous ne vous rappelez plus ^^), c'est plus propre, et ça permet d'utiliser plein de fois dans des script différent le même nom :p
Ainsi, dans votre petit script de test, vous pouvez copier le code ci-dessous, et remplacer les valeurs de x et y par ce que vous voulez, et h par 32 par exemple...
N'oubliez pas les guillemets qui entoure votre texte ! C'est super important !
Vous savez écrire du texte ! Youpi ! ^^

Mais approfondissons... on peut faire plus fort :
Il est possible d'afficher le contenu d'une variable, qu'elle soit une chaine de caractère (string) ou un nombre...
Il suffit pour cela de remplacez "Texte" (votre texte donc) sans les guillemets, par votre variable genre : "@ma_variable" ou "$votre_variable_adoré" à condition que votre variable contienne du texte...
Si votre variable contient un nombre (comme la variable qui contient les HP du héros principal), genre :

Code: Tout sélectionner

@ma_variable = 6

et bien pour ceci mettez

Code: Tout sélectionner

@ma_variable.to_s

Il faut donc mettre ".to_s" en plus (j'y reviens un peu plus tard).

En résumé :
=> Si votre variable à afficher contient du texte (chaine de caractères ou string) mettez directement la variable :

Code: Tout sélectionner

self.contents.draw_text(x, y, w, h, @ma_variable)

=> Si votre variable à afficher contient un nombre (valeur numérique) alors rajoutez ".to_s" à la fin de votre variable :

Code: Tout sélectionner

self.contents.draw_text(x, y, w, h, @ma_variable.to_s)

Je peux pas être plus clair ^^

Et pour faire tout aussi fort, sachez qu'il est possible d'aligner son texte !
Et oui, on peut rajouter après "Texte" un petit ",s" où l'on définit "s" pour définir l'alignement (on a donc ceci:

Code: Tout sélectionner

self.contents.draw_text(x, y, w, h, @ma_variable, s)

Si s n'existe pas dans votre code ou si il est égale à 0 (par défaut donc) le texte est aligné à gauche, ainsi on a :
- Si s = rien ou s = 0 : aligné à gauche
- Si s = 1 : centré
- Si s = 2 : aligné à droite

Voilà vous savez tout ! ou presque ^^

J'aimerais revenir un instant sur ce que j'ai dit tout à l'heure sur le ".to_s", nous allons approfondir notre connaissance des variables.
En effet, une variable peut contenir deux types d'informations (texte ou valeur), ça, vous le savez, en revanche ce que vous ne savez peut-être pas, c'est qu'en fait, une variable à toujours les deux types d'informations qui sont contenue...
Gné ? ^^
Et bien en fait, on dit qu'une variable à une partie "symbole" et une partie "chaine", plus exactement, on peut transformer une chaine de caractère en symbole, et l'inverse.
Par exemple :
prenez "@ma-variable = 8"

Code: Tout sélectionner

8

est la partie symbole de @ma_variable

Code: Tout sélectionner

"8"

est la partie chaine de @ma_variable
Ainsi, quand on fait ".to_s" on récupère le symbole en chaine de caractères et si on fait ".to_sym" on récupère le symbole...
Regardez ceci :

Code: Tout sélectionner

@ma_variable = 8
@ma_variable.to_s = "8"
@ma_variable.to_sym = 8
@ma_variable.to_sym.to_s = @ma_variable = 8

Comprenez ? Tant mieux ! Car c'était juste une petit parenthèse :DD

Abordons désormais l'affichage d'image dans une fenêtre.
En effet il est tout à fait possible d'afficher une imgae à l'intérieur d'une fenêtre, c'est ce qui se passe lorsque vous voyez l'icône d'un item par exemple dans le menu objets...
Et bien, pour afficher une image, il suffit de mettre l'instruction :

Code: Tout sélectionner

img = RPG::Cache.icon("Nom_de_l'image")

pour tout d'abord définir de quelle image on parle (vous noterez qu'il y a marqué "icon", cela veut dire que le programme va chercher dans vos icônes le nom que vous avez marqué, mais si vous voulez qu'il prenne votre image dans Pictures, remplacez "icon" par "picture") puis ensuite il faut mettre :

Code: Tout sélectionner

self.contents.blt(x, y, img, Rect.new(0, 0, w, h), o)

Étudions et décortiquons un peu tout cela : tout d'abord, il faut notez que l'on a changé de méthode d'affiche, jusqu'à présent on avait

Code: Tout sélectionner

self.contents.draw_text

maintenant on a

Code: Tout sélectionner

self.contents.blt

Pour le reste de la formule, je ne vous ré-explique pas à quoi correspondent le x et le y ni le w et le h, mais notez tout de même que c'est deux derniers sont définis dans une boite (Rect) et non directement, je n'irai pas plus loin pour ne pas vous embrouiller ni entrer dans des choses trop théorique, et somme toute, peu intéressantes ^^.
Ce qu'il ne faut pas oublier dans l'expression

Code: Tout sélectionner

self.contents.blt(x, y, img, Rect.new(0, 0, w, h), o)

c'est le "img", c'est à dire qu'il ne faut pas oublier de mettre les coordonnées de notre images, que nous avons "résumé" dans la variable locale "img" (mais vous pouvez l'appeler comme vous voulez).
Et puis vous aurez remarquer le "o" en fin d'instruction, il désigne l'opacité de l'image, ce qui peut être plutôt utile des fois, cependant cette donné n'est pas obligatoire, et donc l'instruction marche même si vous avez ça :

Code: Tout sélectionner

self.contents.blt(x, y, img, Rect.new(0, 0, w, h))

N'oubliez que par défaut l'image est opaque, donc l'opacité est égale à 255 (et donc 0 signifie transparent).

Nous en avons terminé (pour cette partie) avec notre méthode "refresh" n'oubliez pas les "end" pour mettre fin à votre méthode, et aussi à la classe.

Voilà, vous avez vu déjà pas mal de choses, vous pouvez faire désormais des trucs assez intéressants, d'ailleurs, vous allez pouvoir illustrer votre nouveau savoir dans un "TP", juste après le chapitre suivant.

[]

III) Liste de balises

Pour pouvoir réaliser concrètement et facilement des fenêtres, je vous ait réunis les balises dont nous avons parlé plus haut, voici donc une liste dans laquelle allez piocher si besoin est.
N'oubliez pas que toutes ces balises (syntaxes) sont aussi sur le manuel d'aide dont je vous ait parlé en 1° partie, même si il est moins clair, aidez-vous de ça, surtout si vous avez besoin de renseignements spécifiques, comme "comment désigner les Hp du héros" où "le nombre de pas parcourus"

- Général :

Code: Tout sélectionner

$game_switches[ID]

Désigne un switch d'id "ID"

Code: Tout sélectionner

$game_variables[ID]

Désigne une variable d'id "ID"

Code: Tout sélectionner

to_s

Méthode à appliquer à une variable contenant un chiffre pour afficher ce chiffre (récupère sous forme de caractère le nombre mémorisé).

Code: Tout sélectionner

to_sym

Méthode inverse(réciproque) de "to_s" : à appliquer à une variable contenant un caractère pour récupérer un nombre au lieu d'une chaine de caractère (inutilisable en fenêtre, sert uniquement aux calculs).

- Design :

Code: Tout sélectionner

self.windowskin

Désigne le windowskin (l'habillage) de la fenêtre.

Code: Tout sélectionner

RPG::Cache.windowskin("Nom_du_windowskin")

Désigne le windowskin de nom : "Nom_du_windowskin". Rendre égale ceci à "self.windowskin" pour que le windowskin de la fenêtre soit "Nom_du_windowskin".

Code: Tout sélectionner

self.contents

Désigne le contenue de la fenêtre.

Code: Tout sélectionner

self.contents.font.name

Désigne le nom de la police d'écriture utilisée pour les textes de la fenêtre.

Code: Tout sélectionner

self.contents.font.size

Désigne la taille de la police d'écriture utilisée pour les textes de la fenêtre.

Code: Tout sélectionner

self.contents.font.color

Désigne la couleur de la police d'écriture utilisée pour les textes de la fenêtre.

Code: Tout sélectionner

Color.new(r, g, b, l)

Représente une couleur codée selon la méthode RGB (RedGreenBlue). Le "r" représente le taux de rouge, le "g" le taux de vert, le "b" le taux de bleue et "l" le taux de luminosité.
r,g,b, et l varient entre 0 et 255 uniquement. Rendre égale un "Color.new(r, g, b, l)" à un "self.contents.font.color" permet de définir la couleur de la fenêtre.

Code: Tout sélectionner

self.contents.font.bold

Si cette expression est rendue égale à "true" alors le texte qui va suivre sera en gras.

Code: Tout sélectionner

self.contents.font.italic

Si cette expression est rendue égale à "true" alors le texte qui va suivre sera en italique.

- Fenêtre :

Code: Tout sélectionner

self.contents.clear

Efface le contenue de la fenêtre.

Code: Tout sélectionner

self.contents.draw_text(x, y, w, h, "Texte", s)

Affiche dans la fenêtre le mot "Texte" au point de coordonnée (x,y) d'une largeur "w" et d'une hauteur "h", avec un alignement "s".

Code: Tout sélectionner

self.contents.blt(x, y, img, Rect.new(0, 0, w, h),o)

Affiche dans la fenêtre l'image définie dans la variable "img" d'une largeur "w" et d'une hauteur "h" au point de coordonnée (x,y) avec une opacité "o"(variant de 0 à 255 avec 255 = opaque).

Code: Tout sélectionner

RPG::Cache.icon("Nom_de_l'image")

Désigne l'icône de nom "Nom_de_l'image".

Code: Tout sélectionner

RPG::Cache.picture("Nom_de_l'image")

Désigne l'image de nom "Nom_de_l'image".

[]

IV) TP : fenêtre d'un menu

Je crois qu'il est temps de faire votre premier TP !
Celui-ci fais appel à toutes les connaissances que vous avez apprises jusqu'à présent.
Notez que la troisième partie du TP vous apprend une nouvelle chose !
1)
Voici les consignes :
Faites une fenêtre d'une taille de 200 pixels de large et de 100 pixels de hauteur.
Sa position horizontale est de 100 pixels, et elle se trouve tout en bas de l'écran.
Dans cette fenêtre doit être écrit sur la première ligne la phrase "Vive le RGSS", en gras, avec la police d'écriture "Time New Roman"
Sur la deuxième ligne doit être écrit la valeur de la variable n°33.
Attention, seule la phrase est en gras pas la valeur de la variable !
La première ligne (qui se trouve tout en haut de la fenêtre) et la deuxième sont séparé de 45 pixels.
Cette fenêtre doit apparaitre sur la map, par conséquent vous devrez modifier le script Scene_Map.
Le résultat à obtenir doit être le suivant :

Allez au travail !
Voici la correction (à ne regarder qu'après avoir essayer bien-sûr ^^) :
[spolier]

Code: Tout sélectionner

#==============================================================================
# ■ Window_Test
#------------------------------------------------------------------------------
# 　By Sin
#   Le 08/11/2008
#==============================================================================

class Window_Test < Window_Base # Définition du nom et de l'appartenance de la classe
  #--------------------------------------------------------------------------
  # ● Initialisation
  #--------------------------------------------------------------------------
  def initialize
    # On définie une fenêtre de position (100,380), de largeur 200 et de hauteur 100
    super(100, 380, 200, 100)
    # On créé un bitmap qui pourra contenir du texte
    self.contents = Bitmap.new(width - 32, height - 32)
    # On définit le nom de la police d'écriture
    self.contents.font.name = "Times New Roman"
    # On définit la taille de cette police
    self.contents.font.size = $fontsize
    # On fait continuer "le script" vers la méthode "refresh"
    refresh
  end # Fin de la classe "initialize"
  #--------------------------------------------------------------------------
  # ● Mise à jour
  #--------------------------------------------------------------------------
  def refresh
    # On efface le contenu
    self.contents.clear
    # On regarde la largeur de la phrase "Vive le RGSS !"
    cx = contents.text_size("Vive le RGSS !").width
    # On indique que les prochaines choses écrites seront en gras
    self.contents.font.bold = true
    # On écrit la phrase d'une largeur définie juste au dessus
    self.contents.draw_text(0, 0, cx, 32, "Vive le RGSS !", 2)
    # On indique que les prochaines choses écrites ne seront pas en gras
    self.contents.font.bold = false
    # 45 pixels plus bas, on écrit le contenu de la variable d'ID 33
    self.contents.draw_text(0, 45, 32, 32, $game_variables[33].to_s, 2)
  end # Fin de la méthode "refresh"
end # Fin de la classe "Window_Test"

[/spoiler]
Et voici comment doit être le début du script Scene_Map après modification :
[spolier]

Code: Tout sélectionner

#==============================================================================
# ■ Scene_Map
#------------------------------------------------------------------------------
# 　マップ画面の処理を行うクラスです。
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # ● メイン処理
  #--------------------------------------------------------------------------
  def main
    # スプライトセットを作成
    @spriteset = Spriteset_Map.new
    # メッセージウィンドウを作成
    @message_window = Window_Message.new
    @test_window = Window_Test.new # CHANGEMENT ICI !!!! /////////////////////////////////
    # トランジション実行
    Graphics.transition
    # メインループ
    loop do
      # ゲーム画面を更新
      Graphics.update
      # 入力情報を更新
      Input.update
      # フレーム更新
      update
      # 画面が切り替わったらループを中断
      if $scene != self
        break
      end
    end
    # トランジション準備
    Graphics.freeze
    # スプライトセットを解放
    @spriteset.dispose
    # メッセージウィンドウを解放
    @message_window.dispose
    @test_window.dispose # CHANGEMENT ICI !!!! /////////////////////////////////
    # タイトル画面に切り替え中の場合
    if $scene.is_a?(Scene_Title)
      # 画面をフェードアウト
      Graphics.transition
      Graphics.freeze
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    # ループ
    loop do
      # マップ、インタプリタ、プレイヤーの順に更新
      # (この更新順序は、イベントを実行する条件が満たされているときに
      #  プレイヤーに一瞬移動する機会を与えないなどの理由で重要)
      $game_map.update
      $game_system.map_interpreter.update
      $game_player.update
      # システム (タイマー)、画面を更新
      $game_system.update
      $game_screen.update
      # プレイヤーの場所移動中でなければループを中断
      unless $game_temp.player_transferring
        break
      end
      # 場所移動を実行
      transfer_player
      # トランジション処理中の場合、ループを中断
      if $game_temp.transition_processing
        break
      end
    end
    # スプライトセットを更新
    @spriteset.update
    # メッセージウィンドウを更新
    @message_window.update
    @test_window.refresh # CHANGEMENT ICI !!!! /////////////////////////////////
    # ゲームオーバーの場合
    if $game_temp.gameover
      # ゲームオーバー画面に切り替え
      $scene = Scene_Gameover.new
      return
    end
    # タイトル画面に戻す場合
    if $game_temp.to_title
      # タイトル画面に切り替え
      $scene = Scene_Title.new
      return
    end
    # トランジション処理中の場合
    if $game_temp.transition_processing
      # トランジション処理中フラグをクリア
      $game_temp.transition_processing = false
      # トランジション実行
      if $game_temp.transition_name == ""
        Graphics.transition(20)
      else
        Graphics.transition(40, "Graphics/Transitions/" +
          $game_temp.transition_name)
      end
    end
    # メッセージウィンドウ表示中の場合
    if $game_temp.message_window_showing
      return
    end
    # エンカウント カウントが 0 で、エンカウントリストが空ではない場合
    if $game_player.encounter_count == 0 and $game_map.encounter_list != []
      # イベント実行中かエンカウント禁止中でなければ
      unless $game_system.map_interpreter.running? or
             $game_system.encounter_disabled
        # トループを決定
        n = rand($game_map.encounter_list.size)
        troop_id = $game_map.encounter_list[n]
        # トループが有効なら
        if $data_troops[troop_id] != nil
          # バトル呼び出しフラグをセット
          $game_temp.battle_calling = true
          $game_temp.battle_troop_id = troop_id
          $game_temp.battle_can_escape = true
          $game_temp.battle_can_lose = false
          $game_temp.battle_proc = nil
        end
      end
    end
    # B ボタンが押された場合
    if Input.trigger?(Input::B)
      # イベント実行中かメニュー禁止中でなければ
      unless $game_system.map_interpreter.running? or
             $game_system.menu_disabled
        # メニュー呼び出しフラグと SE 演奏フラグをセット
        $game_temp.menu_calling = true
        $game_temp.menu_beep = true
      end
    end
    # デバッグモードが ON かつ F9 キーが押されている場合
    if $DEBUG and Input.press?(Input::F9)
      # デバッグ呼び出しフラグをセット
      $game_temp.debug_calling = true
    end
    # プレイヤーの移動中ではない場合
    unless $game_player.moving?
      # 各種画面の呼び出しを実行
      if $game_temp.battle_calling
        call_battle
      elsif $game_temp.shop_calling
        call_shop
      elsif $game_temp.name_calling
        call_name
      elsif $game_temp.menu_calling
        call_menu
      elsif $game_temp.save_calling
        call_save
      elsif $game_temp.debug_calling
        call_debug
      end
    end
  end
end

[/spoiler]
Bon, c'était pas si dur que ça non ? ^^

2)
Reprenez l'exercice précédent et changez ceci :
La police d'écriture doit être d'une taille de 15 et en italique (uniquement pour la phrase "Vive le RGSS !"
Changer l'espace qu'il y a entre la phrase une et deux, à la place de 45 mettez 35.
La deuxième phrase contient la phrase suivante : "La position horizontale du héros est :" et juste à droite de cette phrase, mettre la valeur de la position du héros, sachant que l'on désigne la position en x du héros par le "code" :

Code: Tout sélectionner

$game_player.x

Pour les besoins de l'exercice, la fenêtre aura désormais une largeur de 250 pixels.
Le résultat à obtenir doit être le suivant :

Allez, sans plus attendre, la correction :
[spolier]

Code: Tout sélectionner

#==============================================================================
# ■ Window_Test
#------------------------------------------------------------------------------
# 　By Sin
#   Le 08/11/2008
#==============================================================================

class Window_Test < Window_Base # Définition du nom et de l'appartenance de la classe
  #--------------------------------------------------------------------------
  # ● Initialisation
  #--------------------------------------------------------------------------
  def initialize
    # On définie une fenêtre de position (100,380), de largeur 200 et de hauteur 100
    super(100, 380, 250, 100)
    # On créé un bitmap qui pourra contenir du texte
    self.contents = Bitmap.new(width - 32, height - 32)
    # On définit le nom de la police d'écriture
    self.contents.font.name = "Times New Roman"
    # On définit la taille de cette police
    self.contents.font.size = 15
    # On fait continuer "le script" vers la méthode "refresh"
    refresh
  end # Fin de la classe "initialize"
  #--------------------------------------------------------------------------
  # ● Mise à jour
  #--------------------------------------------------------------------------
  def refresh
    # On efface le contenu
    self.contents.clear
    # On regarde la largeur de la phrase "Vive le RGSS !"
    cx = contents.text_size("Vive le RGSS !").width
    # On indique que les prochaines choses écrites seront en gras
    self.contents.font.italic = true
    # On écrit la phrase d'une largeur définie juste au dessus
    self.contents.draw_text(0, 0, cx, 32, "Vive le RGSS !", 2)
    # On indique que les prochaines choses écrites ne seront pas en gras
    self.contents.font.italic = false
    # On regarde la taille de la phrase
    cx2 = contents.text_size("La position horizontale du héros est :").width
    # 35 pixels plus bas, on écrit le contenu de la phrase
    self.contents.draw_text(0, 35, cx2, 32, "La position horizontale du héros est :", 2)
    # Juste à côté, on écrit la position du héros, le nombre est à la suite de la phrase, c'est pourquoi sa position en x est la largeur de la phrase
    self.contents.draw_text(cx2, 35, 32, 32, $game_player.x.to_s, 2)
  end # Fin de la méthode "refresh"
end # Fin de la classe "Window_Test"

[/spoiler]
Vous aurez remarquez que si vous bougez le héros, la valeur change :omg
^^

3)
Voici la dernière partie du TP, la plus dure !
Reprenez la même fenêtre que dans les exercices précédents :
Changer la position de la fenêtre et mettez la tout en haut à gauche.
Changer l'opacité de la fenêtre pour que cette dernière soit transparente.
Faites que la phrase soit en gras.
Enlever la phrase "Vive le RGSS !", à la place mettez la phrase : "La position du héros est : "
Et c'est là qu'un bout de cours intervient, en effet, précédemment, nous nous sommes "embêtés" à mettre deux fois "self.contents.draw_text" pour pouvoir mettre la phrase, puis la valeur de la variable.
Mais il y a moyen de faire plus simple !
On peut intégrer la variable dans la phrase, et nous en aurons besoin car je vais vous demander d'afficher la position en x du héros ET sa position en y, simplement séparé par une virgule, et le tout écrit entre parenthèse ! (comme ceci : (x,y) )
En utilisant plusieurs "draw_text", y'a de quoi s'arracher les cheveux ^^
En fait il suffit de faire comme cela :

Code: Tout sélectionner

"#{@ma_variable}"

Remplacez "@ma_variable" par la variable désirée (dans notre exercice la position du héros). Par exemple, si vous voulez faire la phrase suivante : "La valeur de la variable 33 est :" et afficher à la suite cette valeur, alors il faut écrire :

Code: Tout sélectionner

"La valeur de la variable 33 est : #{$game_variables[33]}"

Cette méthode s'appelle l'inclusion symbolique, car l'on inclue une valeur (symbole) dans une chaine de caractère (vous aurez remarquez d'ailleurs qu'il n'y a pas le "to_s" à la fin de "game_variables"
Compris ? Sinon vous verrez avec la correction ^^
Voila ce que j'attends de vous :

Voici la correction :
[spolier]

Code: Tout sélectionner

#==============================================================================
# ■ Window_Test
#------------------------------------------------------------------------------
# 　By Sin
#   Le 08/11/2008
#==============================================================================

class Window_Test < Window_Base # Définition du nom et de l'appartenance de la classe
  #--------------------------------------------------------------------------
  # ● Initialisation
  #--------------------------------------------------------------------------
  def initialize
    # On définie une fenêtre de position (100,380), de largeur 200 et de hauteur 100
    super(0, 0, 250, 100)
    # On créé un bitmap qui pourra contenir du texte
    self.contents = Bitmap.new(width - 32, height - 32)
    # On définit le nom de la police d'écriture
    self.contents.font.name = "Times New Roman"
    # On définit la taille de cette police
    self.contents.font.size = 15
    # On définit l'opacité du bord de la fenêtre à 0 (transparent)
    self.opacity = 0
    # On définit l'opacité du fond de la fenêtre à 0 (transparent)
    self.back_opacity = 0
    # On fait continuer "le script" vers la méthode "refresh"
    refresh
  end # Fin de la classe "initialize"
  #--------------------------------------------------------------------------
  # ● Mise à jour
  #--------------------------------------------------------------------------
  def refresh
    # On efface le contenu
    self.contents.clear
    # On indique que les prochaines choses écrites seront en gras
    self.contents.font.bold = true
    # On regarde la largeur de la phrase
    cx = contents.text_size("La position du héros est : (#{$game_player.x},#{$game_player.y})").width
    # On écrit la phrase d'une largeur définie juste au dessus
    self.contents.draw_text(0, 0, cx, 32, "La position du héros est : (#{$game_player.x},#{$game_player.y})", 2)
    # On indique que les prochaines choses écrites ne seront pas en gras
   self.contents.font.bold = false
  end # Fin de la méthode "refresh"
end # Fin de la classe "Window_Test"

[/spoiler]
Évidemment, encore une fois, les valeurs changes quand le héros bougent
Voilà, s'en est finit pour votre premier TP ! J'espère que vous avez bien su

[]

V) Intégration des fenêtres dans une scène

Nous avions étudié dans la première partie du tuto le script "Scene_Menu" (si si, rappelez-vous ^^) je vous avez donné une trame de base, commentée, pour faire un menu...
Cette fois, je vais faire un peu plus d'explication.
Tout d'abord, revoici le script en question :
[spolier]

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

[/spoiler]
Que peut-on bien faire de ceci me direz vous ?
Et bien nous avons une fenêtre de commandes pouvant accueillir jusqu'à 5 commandes.
Cela signifie que nous pouvons aller dans 5 parties du menu différentes.
Mais ce nombre peut-être très facilement modifié pour cela il suffit d'ajouter ou de retirer des s1, s2, etc... qui se trouvent au début (notez que vous pouvez les appeler comme vous voulez, mais le tout est de modifier aussi ce qui va suivre) et vous devez en conséquence retirer ou ajouter des choses entre les crochets, dans cette ligne :

Code: Tout sélectionner

@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5]) # Création d'une fenêtre de commande

car c'est la ligne qui définit la fenêtre de commandes...
Notez aussi que si vous utilisez le système de fenêtre normal, le système de base quoi (sans customisation, chapitre que nous aborderons dans la partie 3 ) et bien vous pouvez directement marquer les noms de vos commandes en changeant les chaine de caractères auxquelles sont égales les variables de commandes. (prenez le temps de lire plusieurs fois cette phrase ^^)
Par exemple, on peut rendre égales s1 à "Item", s2 à "Équipement" comme c'est dans le script de base... et directement on voit apparaitre les mots "Item" et "Équipement"

C'est au dessus de

Code: Tout sélectionner

Graphics.transition

que vous pouvez définir vos fenêtres, par exemple, pour reprendre le TP, vous pourriez marquer

Code: Tout sélectionner

@test_window = Window_Test.new

et la fenêtre sur laquelle vous avez travaillée tout à l'heure apparaitra dans votre menu...
Allez jeter un coup d'œil dans le script "Scene_Menu" vous remarquerez au début du script qu'il y a des noms comme :

Code: Tout sélectionner

@playtime_window = Window_PlayTime.new
    @steps_window = Window_Steps.new
    @gold_window = Window_Gold.new
    @status_window = Window_MenuStatus.new

qui désignent respectivement la fenêtre où le temps de jeu s'affiche, puis celle du nombre de pas, puis celle de l'argent possédé et enfin celle concernant l'état des personnages...
Vous pouvez vous rendre aussi dans les scripts de chacune de ces fenêtres (dans le coin où il y a tous les scripts "Window_") normalement vous devriez être en mesure de pouvoir bien mieux les comprendre, à l'exception de "Window_MenuStatus" qui est un peu plus compliqué...
Vous observerez qu'il y a deux manière de définir les caractéristiques d'une fenêtre (sa position, sa taille, sa visibilité), la première c'est dans le script lui même : dans la ligne

Code: Tout sélectionner

super(0, 0, 0, 0)

entre autre, mais l'on peut aussi le faire dans le script de scene qui accueille la fenêtre, cette manière de faire est d'ailleurs "prioritaire" sur l'autre.
En effet, regardez pour "Window_PlayTime" par exemple, il y a marqué

Code: Tout sélectionner

    @playtime_window.x = 0
    @playtime_window.y = 224

On définit ici sa position en x et en y
Ce qu'il faut bien comprendre dans les "Scene_" c'est que l'on va rendre égales des fenêtres à des variables pour pouvoir ensuite les manipulés !
Voici toutes les méthodes associés aux fenêtre que l'on peut définir en début de scene :

Code: Tout sélectionner

@window.x # Valeur numérique (0 à 640), désigne la position horizontale
@window.y # Valeur numérique (0 à 480), désigne la position verticale
@window.z # Valeur numérique (-9999 à 9999), désigne la profondeur (plus le nombre est proche de 9999, plus la fenêtre est proche de nous)
@window.width # Valeur numérique, désigne la largeur
@window.height # Valeur numérique, désigne la hauteur
@window.opacity # Valeur numérique (0 à 255) désigne l'opacité du bord de la fenêtre
@window.back_opacity # Valeur numérique (0 à 255) désigne l'opacité du fond de la fenêtre
@window.contents_opacity # Valeur numérique (0 à 255), désinge l'opacité du contenu de la fenêtre
@window.visible # Valeur booléenne (true ou false), désigne l'état de visibilité de la fenêtre
@window.active # Valeur booléenne (true ou false), désigne l'état activation de la fenêtre

Continuons notre exploration du script "Scene_Menu" : à un moment donné (on est toujours dans la méthode "main") vous verrez marquer l'instruction suivante :

Code: Tout sélectionner

Graphics.transition

et bien sachez que c'est à cette endroit que vous définissez la transitions d'entrée de votre menu ! Pour cela faut rajouter une parenthèse collée au mot ".transition" et de mettre à l'intérieur de cette parenthèse deux choses : premièrement la durée en frame et ensuite, séparé par une virgule, le nom du fichier de transition (une image) mis entre guillemets.
Ca donne ceci (par exemple) :

Code: Tout sélectionner

Graphics.transition(20, "Graphics/Transitions/002-Blind02")

Sympa non ?

Passons à la méthode "update"
C'est dans cette méthode qu'il faut indiquer qu'elle(s) fenêtre(s) se met(tent) à jour...
Cela, vous savez déjà faire (mettre un ".update" ou un ".refresh" après la variable qui désigne votre fenêtre).
Mais vous pouvez aussi profiter de cette méthode pour faire des choses plus sympathiques puisqu'elle s'exécute en permanence.
Par exemple, pour faire une fenêtre qui arrive de la gauche et qui avance doucement jusqu'à ce qu'elle s'arrête à sa position finale (ça fait jolie non ?) et bien il suffit de faire la chose suivante :
Imaginez que votre fenêtre se nomme "@window" et que ça position de départ soit x = -400 (c'est à dire tellement a gauche qu'elle n'est pas dans l'écran). et bien pour qu'elle arrive à sa destination finale qui est x = 0 (la fenêtre est collé au bord gauche de la fenêtre).
Il suffit dans la méthode "update", à n'importe quel endroit le code suivant :

Code: Tout sélectionner

if @window.x < 0
  @window.x += 1
end

Et Oh miracle ça marche ^^

Il y a plein de petites astuces et possibilités de ce genre, avec les "y", ou l'opacité des fenêtres...

[]

VI) Programmation générale sous RM XP

Ce chapitre est juste un avant gout de ce que nous aborderons plus sérieusement dans la troisième partie du tuto

Maintenant que vous en savez un peu plus en RGSS, sachez que pour faire des choses vraiment sympa (et devenir un vrai scripteur) vous devez maitriser plus ou moins l'algorithmique...
L'algo j'en ai déjà parlé dans la première partie, masi je l'ai juste définie, et je vous ait lâchement renvoyé vers Wikipedia ^^
Et bien nous allons en parler un peu plus maintenant.

Tout d'abord sachez que je ne vais absolument pas vous faire un cours magistral sur l'algo, mais simplement quelques points important, il faut vraiment lire ce qui suit, ce très utile !

Bon, vous avez pu remarquer que chaque script suit une certaine logique, et un certain "cheminement" qui est commun à peu près tous les scripts.
En fait chaque scripts est composé de trois parties :
- L'initialisation (définition, ou déclaration)
- La mise à jour (boucle, itération)
- Des fonctions (méthodes annexes, groupes d'instructions)

Sachez qu'en algo pure, faire un algorithme c'est donner un nom puis déclarer (définir les variables) puis écrire des instructions (fonctions).
Et bien nous faisons la même chose en scripts, sauf que dans un script nous utilisons plusieurs fonctions, il y en a une qui passe en boucle, qui est la fonction "mise à jour" (update, refresh), une autre qui dit comment mettre à jour la commande, une autre qui dit comment afficher les statistiques du héros, etc... vous voyez ? Tous les scripts sont principalement fait de fonctions ! Quand dans un menu vous mettez

Code: Tout sélectionner

@window.refresh

et bien vous faites appel à la fonction refresh du script désigné par la variable "@window".

"Mais je croyais que cela s'appellait des méthodes ???!"

En effet, le mot fonction est un mot général utilisé en algo, mais l'outil qui, en RGSS, permet de faire des fonctions s'appelle une méthode.

Autre chose à savoir, pour faire vos scripts, vous allez avoir besoin de faire des conditions, des boucles, de rendre égales des variables, de les afficher, et bien l'algo, c'est tout ceci ! Ni plus ni moins...

Par exemple, vous pourriez avoir besoin de la chose suivante : je veux faire un script qui affiche les HP du héros sur la map, mais que quand ceux-ci sont inférieurs à 10% des HPMAX et bien ils s'affichent en rouge.
Pour faire ceci vous allez faire un algo ! (si si ^^)
Tout d'abord vous construisez un script de fenêtre qui affichent les HPs du héros, ensuite vous le mettez dans le script "Scene_Map" et ensuite c'est là que vient votre algo : juste avant la ligne où l'on définit le texte ("draw_text" vous vous rappelez ? :p ) on définit la couleur (ça peut être à un autre endroit du script, mais imaginons) et bien vous devrez mettre :

Code: Tout sélectionner

Si les HP du héros <= a 10%HPMAX du héros, alors :
  La couleur est rouge
Sinon
  La couleur est normal
FinSi


Ce petit bout de texte est un algorithme permettant de faire varier la couleur de textes qui suit, suivant les conditions...
C'est ça l'algo avant tout, c'est du textes en français (enfin dans votre langue quoi ^^), puis après, il suffit de le retranscrire avec le langage que vous voulez (pour nous le RGSS).

Vous serez amenés à faire des algo bien plus complexes que ça... mais dans la troisième partie du tuto je vais tenté de vous aider le plus possible pour que quelque soit la chose (menu, système de combat ou autre) que vous vouliez faire, vous n'ayez qu'a penser aux spécificités de votre programme... en gros aux algos propres à votre script, moi je vous donnerais les indications pour la customisation en générale.

Le but est que vous ayez le moins d'algo à faire, car c'est le plus dur (sauf si vous voulez en faire votre métier plus tard (genre programmeur)).

Conclusion :
Voilà, s'en est finit pour la partie 3 !!
Je sais parfaitement que ce cours ne suffit pas pour pouvoir maitriser le concept de fenêtres et de scènes, cependant en vous appuyant sur ce que j'ai dit, en fouillant les scripts (ceux de base et ceux du net) et en lisant le fichier d'aide vous devriez très bien vous en sortir (pensez que moi j'ai tout trouvé tout seul, rien qu'en observant les script et en les bidouillant !).
J'espère en tout cas que vous avez appréciez ce tuto, car il est rien que pour vous !


PS : encore une fois, j'ai dit les choses "à ma façon" et normalement, elle ne sont pas totalement fausses ^^

dans le 3e post

attention ! "#{variable}" n'est pas un symbole !
en ruby, des symboles, sont en gros des objets qui n'ont pas besoin d'etre déclarés et assignés. ils se notent :symb ou :"chaine" ou encore "chaine".to_sym

Ps, t'as oubilé un $ à game_variables[i:p6xbugm7] dans la derniere linge de code

Juste comme ça... est-ce normal que la fenêtre est bien sur la map, mais qu'au bout d'un certain temps, elle disparait ? VOici ma syntaxe :

Code: Tout sélectionner

#==============================================================================
# ■ Window_Test
#------------------------------------------------------------------------------
#  Auteur
#  Version
#  Date
#------------------------------------------------------------------------------
#  Explications
#==============================================================================
class Window_Test < Window_Base
 
  #--------------------------------------------------------------------------
  # ● Initialisation
  #--------------------------------------------------------------------------
  def initialize
    super (0, 0, 250, 100)
      self.contents = Bitmap.new(width - 32, height - 32)
      self.contents.font.name = $fontface
      self.contents.font.size = $fontsize
    @variable = 0
    refresh
  end
 
  #--------------------------------------------------------------------------
  # ● Rafrachissement
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @w=contents.text_size("Vive le RGSS").width
    @h=contents.text_size("Vive le RGSS").height
    self.contents.draw_text(0, 0, @w, @h, "Vive le RGSS", 1)
  end
end

je crois que si tu ne la rafraîchis pas pendant un certain laps de temps, elle est libérée automatiquement...

Alors là, que les autres scripteurs n'hésites pas à me rattraper si je me trompe, car c'est un point dont je ne suis pas du tout sur...

Dans le RGSS, il y a ce qui s'appelle le "ramasse-miette".
En gros, c'est ce qui permet de liberré automatiquement de la mémoire si elle n'est plus utilisée.
Exemple : tu engages un combat
=> les variables de la map ne servent plus, et son donc effacée au bout d'un certain temps.

Pour ta fenêtre, c'est pareil...
si tu fais

Code: Tout sélectionner

Window_Test.new

Il va bien créé ta fenêtre... quelque part dans la mémoire. Mais il n'enregistrera pas que cette partie de la mémoire sert à cette fenêtre, et croira dont que c'est de la mémoire inutilisée...
Et dès que le ramasse-miettes passe, ploup! Diiisparition...
Pour éviter ça, utilise par exemple ce code :

Code: Tout sélectionner

$windows_test = Window_Test.new

Ainsi, il se souvient bien que cette partie de la mémoire est utilisé dans $windws_test.

Bon la première partie j'avais à peu près piger mais là...