RGSS3 pour les nul (Chapitre 1: Fenêtre et Scène de Base)

/1\Approche d'une fenêtre de base :

Alors nous allons étudier ensemble une 1ère fenêtre basique qui va nous permettre d'afficher une fenêtre qui fait la taille de l'écran de jeu ^^
Bon vous allez me dire : " a quoi sa va nous servir une fenêtre en plein milieu de notre écran "
Et bien, pour apprendre a courir il faut savoir marcher non ? pour le rgss c'est pareil ^^.
Il faut commencer par des scènes de base avant de pouvoir faire un système complexe

Donc, donc... on va commencer a voir sa ensemble et nous vous inquiétez pas je vais vous expliquez au fur et a mesure ^^.

Alors pour créer une fenêtre basique dans une scène il vous ceci :

Code:

#-------------------------------------------------------------------------------
class Window_Test < Window_Base
#------------------------------------------------------------------------------- 
  def initialize
    super(0, 0, Graphics.width, Graphics.height)
    refresh
  end
#------------------------------------------------------------------------------- 
  def refresh
    self.contents.clear
  end
end
#-------------------------------------------------------------------------------
class Scene_Test < Scene_Base
#------------------------------------------------------------------------------- 
  def start
    super
    create_window_test
  end
#------------------------------------------------------------------------------- 
  def update
    super
    return_scene if Input.trigger?(:B)
    if Input.trigger?(:B)
    Sound.play_cancel
  end
  end
#------------------------------------------------------------------------------- 
  def create_window_test
    @window_test = Window_Test.new
  end
end
#-------------------------------------------------------------------------------

Donc commençons a analyser ce code morceau par morceau ^^:

Code:

class Window_Test < Window_Base

Alors ceci

Code:

 class Window_Test

vous permet de dire dans quelle classe vous allez travaillez.

et ceci :

Code:

< Window_Base

Va vous permettre de définir l'héritage de votre classe.
Oo? késako l'héritage ? : l'héritage vous permet de récupérer les méthodes et les propriétés définies dans la classe parent (Window_Base) dans votre classe fille Window_Test)

Maintenant passons au coeur du code avec ceci en 1er temps :

Code:

 def initialize
    super(0, 0, Graphics.width, Graphics.height)
    refresh
  end


alors ce morceau de code va vous permettre d'initialiser les propriété graphique de votre fenêtre.
Donc avec :

Code:

def initialize

vous définissez la méthode initialize
ensuite avec:

Code:

super(0, 0, Graphics.width, Graphics.height)

"super" vous permet d’appeler la méthode de même nom défini dans la classe parent, autrement dit le code défini dans la méthode initialize de Window_Base est exécuté.

et (0, 0, Graphics.width, Graphics.height)
- le 1er 0 correspond à la position "x" de votre fenêtre.
- le 2ème 0 correspond à la position "y" de votre fenêtre.
- le Graphics.width correspond à la largeur de votre fenêtre.
- le Graphics.height correspond à la hauteur de votre fenêtre.

veuillez notez que le Graphics.width et Graphics.height ont ne met cela que pour définir une largeur et une hauteur par défaut, et par défaut ses paramètres font la taille de l'écran de jeu RMVX c'est a dire 544*412.

et le refresh permet de rafraichir votre fenêtre, nous allons voir cette méthode dans un instant.
une fois tout cela fait pensez bien a mettre un end pour fermer votre méthode.

Maintenant voyons ceci :

Code:

  def refresh
    self.contents.clear
  end

le def refresh vous permet de définir la méthode qui va rafraichir votre fenêtre si elle change au cours de la scene, mais cela nous le verrons plus tard.
le self.contents.clear vous permet d'effacer entierement le Bitmap (nous verrons ce que c'est plus tard)
et comme tout a l'heure fermer votre méthode avec un end.
ce qui vous donne ceci:

Code:

#-------------------------------------------------------------------------------
class Window_Test < Window_Base
#------------------------------------------------------------------------------- 
  def initialize
    super(0, 0, Graphics.width, Graphics.height)
    refresh
  end
#------------------------------------------------------------------------------- 
  def refresh
    self.contents.clear
  end
end

Oo? j'allais oublier (non je plaisante :p) il faut fermer aussi la class dans laquelle on travaille donc mettez un dernier end juste après le end
de la méthode refresh.
Et voià rien qu'avec ça vous avez fait votre 1ère fenêtre bravo ^^.
Mais il y a la suite ne nous emballons pas hein ?

/2\Approche d'une scène de base :

La fenêtre c'est dans la poche maintenant nous allons voir la scène qui va permettre d'afficher cette fenêtre créer précédemment.
Pour cela vous munir de votre clavier et de votre cerveau x)

commençons avec ceci :

Code:

class Scene_Test < Scene_Base

Bon... -_- pour ça je vais pas vous re-expliquez quand même ?
si vous avez pas compris cela retourner un peu plus haut sur l'explication des class et de l'héritage.

ensuite nous avons ceci en dessous de class Scene_Test < Scene_Base:

Code:

 def start
    super
    create_window_test
  end

alors le def start et OBLIGATOIRE ! a chaque début de scène. Ensuite pour le super je ne vais pas non plus vous re-expliquez.

mais voyons voir nous avons un truc nouveau là :

Code:

create_window_test

alors la je ne saurais pas vous expliquez ce que sais !
Mais siiiii ! je rigole le create_window_test(a vous de le nommer a votre convenance) c'est tout simplement une méthode que nous allons définir juste après ^^.
une fois fait terminer votre méthode start par un end.

Maintenant ceci :

Code:

 def update
    super
    return_scene if Input.trigger?(:B)
    if Input.trigger?(:B)
    Sound.play_cancel
  end
  end

le début vous connaissais maintenant jusqu'au super

ensuite voyons voir ceci:

Code:

return_scene if Input.trigger?(:B)
if Input.trigger?(:B)
Sound.play_cancel
end

je vais vous traduire ça littéralement vous allez desuite comprendre ^^ cela veut dire :

Retourne_scene Si la touche B(echap) et appuyer
Si la touche B(echap) et appuyer
Jouer un son : cancel

si vous n'avez pas compris dites moi le dans vos post ci dessous je vous l'expliquerais plus en détail
finissez par un end comme dab' quoi --'.

Et pour finir ce 1er code basique faite ceci :

Code:

def create_window_test
    @window_test = Window_Test.new
  end
end

La on défini la méthode create_window_test qui va appelez votre fenêtre, OUFFF !! Enfin !! xD
donc pour ce faire vous faite un variable de class, les variables de class ont un ptit "@" devant et permettent d'être accessible que dans la class ou l'on travaille.
donc vou faite ceci : @window_test = Window_Test.new

N'oubliez pas de fermer votre méthode et votre class par un end

et votre Scene et Fenêtre basique sont fini ^^
code entier final :

Code:

#-------------------------------------------------------------------------------
class Window_Test < Window_Base
#------------------------------------------------------------------------------- 
  def initialize
    super(0, 0, Graphics.width, Graphics.height)
    refresh
  end
#------------------------------------------------------------------------------- 
  def refresh
    self.contents.clear
  end
end
#-------------------------------------------------------------------------------
class Scene_Test < Scene_Base
#------------------------------------------------------------------------------- 
  def start
    super
    create_window_test
  end
#------------------------------------------------------------------------------- 
  def update
    super
    return_scene if Input.trigger?(:B)
    if Input.trigger?(:B)
    Sound.play_cancel
  end
  end
#------------------------------------------------------------------------------- 
  def create_window_test
    @window_test = Window_Test.new
  end
end
#-------------------------------------------------------------------------------

Et pour appeler cette scène de base faite un event avec pour apparence ce que vous voulez et mettez un apel de script avec ceci a l'intérieur
SceneManager.call(Scene_Test)

Voilà pour ce 1er cour sur le RGSS3, j'espère qui vous plaira et vous permettra d'aborder le RGSS avec moins d’appréhension ^^

Prochain cour du RGSS3 pour les nul => affichage d'information sur la fenêtre de base.

A bientôt les nuls (je plaisante hein ? xD)




+5 pts de participation

OH, super, une chaine de tutos sur le RGSS 3 ! Non sans rire merci beaucoup pour ce tuto, il y'en a peu qui concernent le RGSS 3 sur internet ! (en plus il est en français, alors !)

J'attend la suite

Belle initiative, merci du partage.

Merci pour le tuto ! Comme il a été dit, ça manque en français ! (Pas facile de suivre ceux de Khas et Gubid en vidéo dès fois )

Par contre, quand tu dis que nous allons voir plus tard les bitmaps et refresh, c'est dans un autre tuto ou tu as oublié de l'intégrer dans celui la ?

Pour les bitmap se sera dans un prochain cour ^^

mais le refresh je l'ai expliquer :

et le refresh permet de rafraichir votre fenêtre, nous allons voir cette méthode dans un instant.
une fois tout cela fait pensez bien a mettre un end pour fermer votre méthode.

Maintenant voyons ceci :
Code:Sélectionner le contenu

Code:

 def refresh
    self.contents.clear
  end

le def refresh vous permet de définir la méthode qui va rafraichir votre fenêtre si elle change au cours de la scene, mais cela nous le verrons plus tard.
le self.contents.clear vous permet d'effacer entierement le Bitmap (nous verrons ce que c'est plus tard)
et comme tout a l'heure fermer votre méthode avec un end.
ce qui vous donne ceci:

Après merci pour vos commentaires sa me donne envie de faire d'autre tutos et ptet que aujourd'hui vous aurez une ptit surprise

Oui, j'ai lu ce que tu as écrit ! J'ai juste du mal à comprendre dans les scripts comment fonctionne le Refresh, pour ça que je voulais plus de détails, peut-être une autre fois, dans un autre tuto

En tout cas, sache que tout tutorial sur le RGSS3 est loin d'être inutile, et même attendu avidement

Je viens de poster un nouveau cour qui parle de l'affichage d'un icône et d'un texte sur la fenêtre qu'on a créer ^^

après pour le refresh tu va comprendre tout seul grâce au 2ème cour ^^
si tu ne comprend pas plus avec le 2ème cour, dit moi le je t'expliquerais plus en détail

J'ai l'impression d'être le seul à avoir ce souci, j'ai ptet mal manipulé, au départ j'ai copié manuellement tes codes pour m'entrainer, et j'avais un message d'erreur, mais meme en copiant le tien, il y est encore. Le message d'erreur est : Script Window_Test line 14 NameError occurred uninitiallized constant Object::Scene_Base. J'ai essayé de le comprendre mais je vois pas comment on peut le régler... (à noter que j'ai bien placé mon évenement en automatique avec l'appel de script nécessaire).

Essaye dans un projet vierge, en ne prenant que ça :

#-------------------------------------------------------------------------------
class Window_Test < Window_Base
#-------------------------------------------------------------------------------
def initialize
super(0, 0, Graphics.width, Graphics.height)
refresh
end
#-------------------------------------------------------------------------------
def refresh
self.contents.clear
end
end
#-------------------------------------------------------------------------------
class Scene_Test < Scene_Base
#-------------------------------------------------------------------------------
def start
super
create_window_test
end
#-------------------------------------------------------------------------------
def update
super
return_scene if Input.trigger?(:B)
if Input.trigger?(:B)
Sound.play_cancel
end
end
#-------------------------------------------------------------------------------
def create_window_test
@window_test = Window_Test.new
end
end
#-------------------------------------------------------------------------------

Dans l'apel de script de l'évènement tu as bien mis
SceneManager.call(Scene_Test)

Justement j'ai déjà essayé de changer le script en n'en prenant qu'une partie, mais il y'a un message d'erreur ! Et oui, j'ai bien mis SceneManager.call(Scene_Test)...

alors la c'est bizarre parce que ce code fonctionne très bien chez moi Oo
sa te met quoi comme message d'erreur ?

Haaaa. Ca marche. Mais... j'avais pas compris qu'il fallait que je découpe mon script en deux pour en mettre une partie dans "Scene_Test", et l'autre dans "Window_Test", je sais pas si ça vient de là... En tout cas j'ai ma fenêtre d'affichée !
Désolé ^^

Ah ben... voilà ^^ je suis content que tu ai réussi
je suis en train de préparer le 3eme cour de rgss3 que je devrais pas tarder a sortir

Vivement !

Excellente initiative !!! Je vais pouvoir me mettre au RGSS dès ce week-end et si j'ai des questions, puis-je te mp, je pense que cela sera plus approprié que de poster moult messages sur ce sujet ?

Merci beaucoup light

je préfèrerais que tu me pose tes questions sur ce post car j'ai pas envie que ma boite mp soit blindé ^^
merci du compliment XtremeViper

Super cet initiative très attendue
Voilà une personne de valeur parmi d'autre évidement

Par contre j'ai pas trouvé ça très prof comme travail
Ya des fautes et des messages inutile à mon sens mais ça ne regarde que moi hein ^^

Te vexe pas hein
Merci beaucoup a toi c'est superbe !

Note: Corrige un peut tous ça et fais plus proprement, plus prof quoi
Et puit tu va peut être nous sortir un livre qui sais !

Super cet initiative très attendue

merci ^^

Par contre j'ai pas trouvé ça très prof comme travail
Ya des fautes et des messages inutile à mon sens mais ça ne regarde que moi hein ^^
Te vexe pas hein
Merci beaucoup a toi c'est superbe !

Il est vrai que j'ai fait beaucoup de faute d'orthographe dans le cour mais vue qu'il est long je n'ai pas prêter attention aux fautes x) dès que j'aurais tu temps je le corrigerais un peu ^^ en attendant tu peut quand même t'en servir car dans le code par contre il n'y a pas de faute ^^

Et puit tu va peut être nous sortir un livre qui sais !

Oula ! même pour un sujet comme ça je ne pense pas a faire de livre x) déjà que dans 1 page de cour c'est criblé de faute, alors dans un livre je te dit pas x)

Tu sais je ne suis frenchement pas mieux dans le genre

Merci Lightnox, je recommande ton tutoriel à tous ceux qui, comme moi, souhaitent amorcer la transition ruby>>rgss3 (bon je maitrise pas ruby à fond, mais assez je pense pour attaquer cette transition).

Il m'a aussi donné l'idée de commencer à observer les classes mères utilisées, comme Window_Base, pour voir plus précisément ce qui est importé au juste dans ton exemple, et regarder "comment c'est fait à l'intérieur", le "noyau" on pourrait dire; et c'est aussi une chose que je recommande aux apprentis codeurs, pour approfondir la logique de ces classes mères, découvrir plus de méthodes utilisables à partir de celles ci, et puis aussi pour la gymnastique intellectuelle du "décryptage" de ces classes.

Salut Montag, je te conseil également le tutoriel de Ekron à cette adresse, il est très bien écris et précis donc facile à comprendre :

http://rpgmakervx.1fr1.net/t15477-ruby-rgss-ou-la-puissance-cachee-de-rpg-maker

Ce n'est que le début donc faudra patienter pour la suite qui ne devrait plus tarder

PS : Joli nécropost (1 an)

Salut, j'ai jeté un oeil (très rapide) sur ce topic, il est bien écrit, détaillé et structuré, mais il s'arrête aux variables (pour l'instant, quand des nouveaux paragraphes seront ajoutés, j'y referai un tour). Mais dès les premières lignes, j'ai retrouvé l'état d'esprit dans lequel je me suis mis à apprendre le ruby/rgss : si les limites de rpgmaker sans son code sont rapidement évaluées, à partir du moment où un langage de programmation entier y est intégré, les seules limites de ce qu'on peut en faire sont la 2D et la résolution maximale...je pense que ce support peut offrir un potentiel largement sous estimé...certains ont fait des zelda-like, mais par exemple, un jeu de plates-formes, un shoot'em up, un diablo-like, ou même un rts ou un jeu de gestion, pourquoi pas après tout, ça doit certainement être faisable, tant que ça reste en 2D, et avec cette limite de résolution...

Pour l'instant, j'ai appris de ruby ce qui était nécessaire, et je suis toujours en train de "décortiquer" les classes et méthodes spécifiques au rgss3   , mais j'ai hâte d'être bien au point pour voir jusqu'où j'arriverai à "pousser le truc"...^^

Oui, c'est un vieux topic, mais toujours d'actualité. ^^