Structure de base classe Scene et Window

Vous avez pu constater dans les scripts fournis par défaut avec RPGmakerXP, que la plupart se nomment Scene_.. et Window_.., cependant comment fonctionne-t-il réellement et surtout comment arriver a faire ses propres scripts d'affichages personnalisés.
Tout d'abord, il faut savoir qu'une classe Scene définit une interface avec l'utilisateur, alors que les classe Window permettent d'afficher quelque chose. Il ne faut pas perdre cela de vue, si l'on veut respecter un minimum le standard mis en place par les scripts par défaut : Scene gère l'interaction avec l'utilisateur en gérant les windows, alors que les windows ne servent qu'a faire de l'affichage. Cependant, n'oubliez pas que les fenêtres sont gérés dans les scènes.

Pour simplifier le tout, j'ai pris le temps de faire un squelette de script Scene et de script Window :

- Pour le script Scene

(Ruby)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#==============================================================================
# ■ Scene_Squel
#------------------------------------------------------------------------------
#  Squelette de script scene
#==============================================================================

class Scene_Squel
  
#--------------------------------------------------------------------------
  # ● initialize
  #      Permet d'initialiser des variables de classes à la construction de l'objet
  #--------------------------------------------------------------------------
  
def initialize
    
# [ A COMPLETER ]

  
end

  
#--------------------------------------------------------------------------
  # ● main
  #--------------------------------------------------------------------------
  
def main
    
# Création des objets Window [ A COMPLETER ]



    # Transition graphique
    
Graphics.transition
    # Boucle
    
loop do
      
# MAJ graphique
      
Graphics.update
      # MAJ clavier
      
Input.update
      # Appel de la méthode update
      
update
      # Si la scene est diférente de celle-ci
      
if $scene != self
        
# Sortir de la scene
        
break
      end
    end
    
# Figer les graphisme
    
Graphics.freeze
    # Détruire les fenêtres créés [ A COMPLETER ]


   
end

  
#--------------------------------------------------------------------------
  # ● update
  #      Permet de gérer les interventions utilisateurs
  #--------------------------------------------------------------------------
  
def update

    
# Appeler les méthodes update des fenêtres créés [ A COMPLETER ]



    # Si touche annulation appuyé
    
if Input.trigger?(Input::B)
      
# Jouer le son d'annulation
      
$game_system.se_play($data_system.cancel_se)

      
# Action a faire en cas d'annulation [ A COMPLETER ]


      
return
    end

    
# Si touche validation appuyé
    
if Input.trigger?(Input::C)
      
# Jouer le son de validation
      
$game_system.se_play($data_system.decision_se)

      
# Action a faire en cas de validation [ A COMPLETER ]



      
return
    end
  end
end


Avec les commentaires que j'ai mis, il ne devrait pas y avoir de difficulté de compréhension, et si en plus je vous dis, que ce script de scène est parfaitement fonctionnel, vous ne me croyez pas?? Et bien faites le test, ajouter un nouveau script au dessus de main, appelez le comme vous voulez 'test' par exemple, copiez y le squelette Scene, ajoutez un évènement sur votre carte avec la commande script :

(Ruby)
1
$scene Scene_Squel.new


Comment ça, ça ne fonctionne pas??? Vous obtenez bien un écran noir avec aucune interaction possible, vous entendez juste les sons d'annulation et de validation selon la touche appuyée, mais vous ne pouvez plus en sortir. Et bien c'est donc parfaitement opérationnel, il ne reste plus qu'a le personnaliser pour en faire ce que vous voulez.
Par exemple, dans l'action d'annulation, rajoutez :
[

(Ruby)
1
$scene Scene_Map.new


Et dans l'action de validation, rajoutez

(Ruby)
1
print "Bouton validé appuyé."


et refaites le test, en appuyant sur les boutons de validation et d'annulation. Et voila, vous venez de commencer à personnaliser votre Scene.

Vous comprenez bien que même si rien n'est affiché, l'on peut quant même interagir avec une scène, se balader dans un tableau en gérant l'index en variable de classe de la scène puis en fonction de l'appuie de haut ou bas, incrémenter ou décrémenter cette index, et ainsi de suite. Mais il est évident, qu'il est plus agréable de rajouter quelque fenêtre pour avoir un peu de visuel de ce que l'on fait.

Nous allons donc passer à la création d'une fenêtre via un script Window vierge :

(Ruby)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#==============================================================================
# ■ Window_Squel
#------------------------------------------------------------------------------
#  Squelette de script Window héritant de Window_Base
#==============================================================================

class Window_Squel Window_Base
  
#--------------------------------------------------------------------------
  # ● initialize
  #      Permet d'initialiser des variables de classes à la construction de l'objet
  #--------------------------------------------------------------------------
  
def initialize
    
# Appel de la méthode initialize de la classe mère (x, y, largeur, hauteur) [ Valeur a modifier ]
    
super(00200200)
    
# Définition du Bitmap permettant d'afficher des données
    
self.contents Bitmap.new(width 32height 32)
    
# Définition de la police d'écriture sur ce Bitmap
    
self.contents.font.name $fontface
    
self.contents.font.size $fontsize

    
# Autre action à réaliser dans initialize [ A COMPLETER ]



    # Appel de la méthode refresh
    
refresh
  end

  
#--------------------------------------------------------------------------
  # ● refresh
  #--------------------------------------------------------------------------
  
def refresh
    
# Effacer le Bitmap
    
self.contents.clear

    # Dessin à effectuer sur le Bitmap [ A COMPLETER ]

  
end
end


Ce script héritant de la classe Window_Base, ne permet aucune gestion de curseur, mais permet quant même d'afficher tout ce que l'on veut. Cependant je rappel qu'une fenêtre doit être géré dans une classe Scene. Pour cela il faut instancié un objet de la classe fenêtre pour pouvoir la manipuler. "Instanciation" ça vous parle pas beaucoup je suppose, en gros c'est une action pour créer une variable ayant pour modèle, une classe. Tout comme le squelette de Scene, cette fenêtre est complétement opérationnelle.
On va donc la tester, ajoutez un script au dessus du script de Scene_Squel, puis copiez-y la classe de Window_Squel. Ensuite dans le script Scene, à l'endroit où il est question de "Création des objets Window" ajouter cette ligne :

(Ruby)
1
2
# Création des objets Window  [ A COMPLETER ]
@squel_window Window_Squel.new


pour la destruction

(Ruby)
1
2
# Détruire les fenêtres créés [ A COMPLETER ]
@squel_window.dispose


Pour la mise à jour :

(Ruby)
1
2
# Appeler les méthodes update des fenêtres créés [ A COMPLETER ]
@squel_window.update


J'éditerais, pour ajouter la gestion des fenêtre selectionable (Window_Selectable), ainsi que des exemples de gestion de multiple fenêtre, mais bon honnêtement pour des exemples, il suffit de regarder les autres scripts RMXP.