Mhd_Splatch.v1

-Introduction

Voici ma version de ce script assez classique, il permet de faire des splatches avant un écran titre. Et aussi d'animer ce dernier, lui-même étant considéré comme un splatch.
Il requiert des notions de scripts pour le customiser, rien de bien méchant, cependant novice s'abstenir. Le plus dur est de ne pas s'emmêler dans les tableaux, de tableaux, de tableaux... vous voyez le trip?
Pour le momment il ne contient que ce dont j'avais besoin pour Last Hope, mais je vais devoir certainement le compléter. (Il n'y pas de translations avec les images pour le moment... assez bidon)
Je l'ai divisé en plusieurs scripts, c'est plus pratique pour moi ^^. Et pour ceux qui veulent le modifier et le compléter...

-Description

Cette scène écrase l'écran titre normal. L'écran titre est le dernier splatch du tableau. la fenêtre de commande s'ouvrira après le début du splatch et un temps déterminé par le maker ou quand le joueur zappera.
Les splatches sont à compléter dans un grand tableau, qui peut tourner en boucle si le maker le configure.
Les splatches sont zappables ou non si le maker le stipule dans le tableau. L'écran titre n'est pas zappable. ça permet de ne pas attendre un tour complet de la boucle à chaque démarrage, mais de pouvoir obliger le joueur de voir un minimum de splatch.

-Installation

Ce script n'échappe pas à la régle du "copiez en dessous de material".
Niveau compatibilité, alors là c'est un peu le mystère.

-Utilisation

En soi, il n'y a pas de consignes particulières d'utilisation.
"Entrer" et "Inser" permettent de zapper les splatchs,
"Inser" permet de faire apparaître la fenêtre de contrôle sur l'écran titre de manière anticipée.
(pas "Entrer" pour éviter les confusions avec les commandes de la fenêtre de contrôle)

-Configuration:

C'est là que ça va être plus compliqué. S'il y a des erreurs ça va être là.
Théoriquement, j'ai fait un effort de commentaires de script. ^^
Remplir le tableau de splatch de surcroît avec les exemples devrait ne pas trop poser de problème (je répête novice s'abstenir). Repérez bien le type d'images que vous voulez placer, un prototype du remplissage du tableau se trouve en-tête de la classe correspondante dans la partie Elements.

Pour ajouter des nouveaux types d'Images:

Toutes les images sont filles de la classe Image, afin qu'elles obeïssent aux consignes d'opacités.
Les differents types d'images sont reconnus par la méthode "create_contents" de la classe Splatch, il vous faudra lui rajouter un mot-clé supplémentaire, dans un "when", correspondant à la case "Type" des images dans le tableau de splatch sinon par défaut elles seront reconnues comme des images simples.

-Les scripts:

Je vous conseille de conserver l'ordre.

Mhd_Math
Comme dit dedans, c'est juste une commodité, des fonctions réccurantes dans differents scripts personnels

Spoiler:

Code:

#==============================================================================#
#                                                                            #
#                                                                            #
#                               Math +                                  #
#                                                                            #
#                                                                            #
#==============================================================================#
#                                                                            #
#By Vincentmhd                                                             #
#http://vincentmhdmaker.canalblog.com/                                     #
#18/2/2010                                                                   #
#                                                                            #
#                                                                            #
#                                                                            #
#                                                                            #
#-------------------------------------NOTE-------------------------------------#
#                                                                            #
# Ce script est une commodité, il me permet de ne pas retenir quelques #
#formules, ou me fait économiser quelques lignes dans un script un peu lourd.#
#Toutes les méthodes sont dans le module Mhd_Math disponible dans l'espace#
#commun. Pour appeler une méthode il suffit de mettre Mhd_Math::la_méthode pour#
#l'appeler.                                                                   #
#                                                                            #
#------------------------------------LISTE-------------------------------------#
#                                                                            #
#    radians(angle)          Converti un angle en des degrés          #
#                               vers les radians.                         #
#                                                                            #
#    plus_ou_moins(nbr, %)    Renvoit un nbr aleatoire entre             #
#                               le nombre plus ou moins un %             #
#                               de ce dernier.                            #
#                                                                            #
#    distance([x,y],[x',y']) Renvoie la distance entre 2 points       #
#                                                                            #
#                                                                            #
#                                                                            #
#==============================================================================#

module Mhd_Math

#------------------------------------------------------------------------------#
#                                                                            #
# Conversion de degrés en radians                                           #
#                                                                            #
#------------------------------------------------------------------------------#
def radians(angle)
return angle = ((Math::PI.to_f * angle.to_f) /180)
end

#------------------------------------------------------------------------------#
#                                                                            #
# Plus ou moins le nombre entré                                           #
#                                                                            #
#------------------------------------------------------------------------------#
def plus_ou_moins(nombre, pourcentage)
pourcentage = (100 - pourcentage) + rand( pourcentage*2 )
pourcentage = pourcentage.to_f/100
nombre = nombre.to_f * pourcentage
return nombre
end

#------------------------------------------------------------------------------#
#                                                                            #
# Distance entre un point A et un point B                                  #
#                                                                            #
#------------------------------------------------------------------------------#
def distance(a, b)
return Math.sqrt( (a[0]-b[0])*(a[0]-b[0]) + (a[1]-b[1])*(a[1]-b[1]) )
end

end

#==============================================================================#
#                      Include dans l'espace commun                         #
#==============================================================================#
include Mhd_Math

#==============================================================================#
#                            Fin de Mhd_Math                               #
#==============================================================================#

Sprite +
Aussi une commodité, pour le placement des sprites

Spoiler:

Code:

#==============================================================================#
#                                                                            #
#                                                                            #
#                               SPRITE +                               #
#                                                                            #
#                                                                            #
#==============================================================================#
#                                                                            #
#By Vincentmhd                                                             #
#http://vincentmhdmaker.canalblog.com/                                     #
#18/2/2010                                                                   #
#                                                                            #
#                                                                            #
#                                                                            #
#                                                                            #
#-------------------------------------NOTE-------------------------------------#
#                                                                            #
# Ce script me permet de gérer plus facilement les sprites avec de petites #
#méthodes supplémentaires. Afin de simplifier l'utilisation, j'utilise les #
#monts clefs suivants:                                                       #
#                                                                            #
# "Haut Gauche"       "Haut Centre"             "Centre"             #
# "Haut Droite"       "Bas Centre"                                     #
# "Bas Gauche"       "Gauche Centre"                                  #
# "Bas Droite"       "Droite Centre"                                  #
#                                                                            #
#                                                                            #
#                                                                            #
#------------------------------------LISTE-------------------------------------#
#                                                                            #
#    coord?(coord)    détermination des coordonnées de la sprite:       #
#                         @x, @y, @zoom_x, @zoom_y                         #
#                                                                            #
#==============================================================================#

class Sprite

#------------------------------------------------------------------------------#
#                                                                            #
# Détermination des coordonnées de la sprite                               #
#                                                                            #
# arguments possibles: "", [,,,], ["",,]                                  #
#                                                                            #
#------------------------------------------------------------------------------#

def coord?(coord)
zoom_x = 100
zoom_y = 100
case (coord)
when nil
   x = 0
   y = 0

when "Haut Gauche"
   x = 0
   y = 0

when "Haut Droite"
   x = 544
   y = 0

when "Bas Gauche"
   x = 0
   y = 416

when "Bas Droite"
   x = 544
   y = 416

when "Haut Centre"
   x = 272
   y = 0

when "Bas Centre"
   x = 272
   y = 208

when "Gauche Centre"
   x = 0
   y = 208

when "Droite Centre"
   x = 544
   y = 208

when "Centre"
   x = 272
   y = 208

else

   zoom_x = coord[1]
   zoom_y = coord[2]

   case coord[0]

   when "Haut Gauche"
      x = 0
      y = 0

   when "Haut Droite"
      x = 544
      y = 0

   when "Bas Gauche"
      x = 0
      y = 416

   when "Bas Droite"
      x = 544
      y = 416

   when "Haut Centre"
      x = 272
      y = 0

   when "Bas Centre"
      x = 272
      y = 208

   when "Gauche Centre"
      x = 0
      y = 208

   when "Droite Centre"
      x = 544
      y = 208

   when "Centre"
      x = 272
      y = 208

   else
      x = coord[0]
      y = coord[1]
      zoom_x = coord[2]
      zoom_y = coord[3]
   end

end

if zoom_x == nil
   zoom_x = 100
   end

if zoom_y == nil
   zoom_y = 100
end

self.zoom_x = zoom_x.to_f/100
self.zoom_y = zoom_y.to_f/100

self.x = x
self.y = y
end

#------------------------------------------------------------------------------#
#                                                                            #
# Détermination de l'origine de la sprite                                  #
#                                                                            #
# arguments possibles: "", [,]                                           #
#                                                                            #
#------------------------------------------------------------------------------#

def origine?(origine)
case (origine)
when nil
   ox = 0
   oy = 0

when "Haut Gauche"
   ox = 0
   oy = 0

when "Haut Droite"
   ox = self.width()
   oy = 0

when "Bas Gauche"
   ox = 0
   oy = self.height()

when "Bas Droite"
   ox = self.width()
   oy = self.height()

when "Haut Centre"
   ox = self.width() /2
   oy = 0

when "Bas Centre"
   ox = self.width() /2
   oy = self.height()

when "Gauche Centre"
   ox = 0
   oy = self.height() /2

when "Droite Centre"
   ox = self.width()
   oy = self.height() /2

when "Centre"
   ox = self.width() /2
   oy = self.height() /2

else
   ox = origine[0]
   oy = origine[1]
end

self.ox = ox
self.oy = oy
end

end
#==============================================================================#
#                            Fin de Sprite +                               #
#==============================================================================#

Splatch Class Elements
Les types d'images.

Spoiler:

Code:

#==============================================================================#
#                                                                            #
#                                                                            #
#                         Contient les differents                         #
#                      Elements possibles d'un splatch                   #
#                                                                            #
#==============================================================================#

#==============================================================================#
#                                                                            #
#                                                                            #
#                               Image de Base                               #
#                   (Capable de changer d'opacité)                      #
# Image = [Position, Moment d'apparition, Adresse image, image, Origine] #                                              #
#                                                                            #
#==============================================================================#

class Image

def initialize(contents)
@sprite       = Sprite.new
@sprite.opacity = 0
@sprite.bitmap = Bitmap.new(contents[2])
@sprite.coord?(contents[0])
@trigger       = contents[1]
@sprite.origine?(contents[4])

@target_opacity = 0
@op_count = 0
@appeared = false
end

def update(count =-1)
wait(count)
op_update
end

def wait(count)
if count == @trigger
   @appeared = true
   fade_in
end
end

#Création de méthode de changement d'Opacité
def op_change (op , duration = Mhd_Splatch::FADE_INTERNAL)
@op_count = duration
@target_opacity = op
if @op_count == 0
   @sprite.opacity = op
end
end

#UpDate de l'opacité
def op_update
if @op_count>0
   d = @op_count
   @sprite.opacity = (@sprite.opacity * (d - 1) + @target_opacity) / d
   @op_count -=1
end
end

def fade_in
op_change(255)
end

def fade_out
op_change(0)
end

def dispose
@sprite.dispose
end
end

#==============================================================================#
#                                                                            #
#                                                                            #
#                            Image avec un son                            #
#                                                                            #
# Image = [Position, Moment d'apparition, Adresse image, image_sound, #
#             Sound[], Temps d'attente avant de le jouer]                #
# Sound = [name, volume, ton]                                           #
#                                                                            #
#==============================================================================#

class Image_sound < Image

def initialize(contents)
super(contents)

if contents[5] != nil
   @se = RPG::SE.new(contents[5][0][0],contents[5][0][1],contents[5][0][2])
   @sound_time = contents[5][1] + 1
else
   @se = nil
end
end

def sound_update
if @se != nil
   if @appeared == true
      if @sound_time >=0
      @sound_time -=1
      if @sound_time == 0
         @se.play
      end
      end
   end
end
end

def update(count =-1)
super(count)
sound_update
end
end

#==============================================================================#
#                                                                            #
#                                                                            #
#                         Image en rotation                               #
#             (continue ou par accout, avec un son ou non)                   #
#                                                                            #
# Image = [Position, Moment d'apparition, Adresse image, image_sound, #
#             Rot[] ]                                                    #
# Rot = [Speed, Step, Sound[] ]                                     #
# Sound = [name, volume, ton]                                           #
#                                                                            #
#==============================================================================#
class Image_Rotation < Image

def initialize(contents)
super(contents)
@speed       = contents[5][0]
@step       = contents[5][1]
@rotate_count = 0
se?(contents[5][2])
end

def se?(se)
if se != nil
   @se = RPG::SE.new(se[0], se[1], se[2])
else
   @se = nil
end
end

def update(count =-1)
super(count)
rotate
end

def rotate
if @step == @rotate_count
   @sprite.angle += @speed
   @rotate_count = 0

   if @se != nil
      @se.play
   end

else
   @rotate_count += 1
end
end

end

Scene_Splatch (Scene_Title +)
La classe Splatch, et la Scene_Title

Spoiler:

Code:

#==============================================================================#
#                                                                            #
#                                                                            #
#                               Scene_Splatch                               #
#                                                                            #
#                                                                            #
#==============================================================================#
#                                                                            #
#By Vincentmhd                                                             #
#http://vincentmhdmaker.canalblog.com/                                     #
#28/2/2010                                                                   #
#                                                                            #
#                                                                            #
#                                                                            #
#                                                                            #
#-------------------------------------NOTE-------------------------------------#
# Ce script est un classique, il sert à placer des splatches avant l'écran #
#titre qui est le dernier splatch. Il est possible d'animer les splatches en #
#des classes spéciales.                                                       #
#                                                                            #
# Le module ci-dessous sert à configurer les splatches. Le tableau est la #
#liste des splatches à réaliser.                                           #
#                                                                            #
#==============================================================================#

module Mhd_Splatch

FADE_INTERNAL = 60             #temps de fade entre les splatches et à l'apparitions des images.
COUNT_WINDOW = 60             #temps que la fenêtre de contrôle met à apparaitre à l'écran titre si non zappé
LOOP       = true          #si les splatches tournent en boucles

#------------------------------------------------------------------------------#
#                                                                            #
# Organisation et contenu des Splatches                                     #
# SPLATCHES = [Splatch1[], Splatch2[],...]                               #
# Splatch = [Temps du splatch, Obligé, Contenu[], BGM[]]             #
# Contenu = [Image1[], Image2[]...]                                     #
# Image = [Position, Moment d'apparition, Adresse image, Type d'image, #
#                Origine,... (reste dépend du type) ]                      #
# BGM    = [name, volume, ton]                                        #
#                                                                            #
#                                                                            #
#------------------------------------------------------------------------------#
SPLATCHES = [
               #Presents
               [ 400, true , [["Centre" , 188, "Graphics/Splatches/Presents.png", "image_sound", "Centre" ,    [["Ice4",    60,             65], 0] ],
                              ["Bas Droite" , 330, "Graphics/Splatches/Fleur_8.png", "image_sound", "Bas Droite",    [["Ice1", rand(30), 5 + rand(10)*5], 0] ],
                              [[378,0]    , 220, "Graphics/Splatches/Fleur_7.png", "image_sound",       nil,    [["Ice4", rand(30), 5 + rand(10)*5], 0] ],
                              [[60,220] , 196, "Graphics/Splatches/Fleur_6.png", "image_sound",       nil,    [["Ice8", rand(30), 5 + rand(10)*5], 0] ],
                              [[119,230] , 249, "Graphics/Splatches/Fleur_5.png", "image_sound",       nil,    [["Ice1", rand(30), 5 + rand(10)*5], 0] ],
                              ["Haut Droite", 200, "Graphics/Splatches/Fleur_4.png", "image_sound", "Haut Droite",    [["Ice4", rand(30), 5 + rand(10)*5], 0] ],
                              [[76,12]    , 300, "Graphics/Splatches/Fleur_3.png", "image_sound",       nil,    [["Ice1", rand(30), 5 + rand(10)*5], 0] ],
                              [[0, 50]    , 280, "Graphics/Splatches/Fleur_1.png", "image_sound",       nil,    [["Ice8", rand(30), 5 + rand(10)*5], 0] ],
                              ["Bas Gauche" , 340, "Graphics/Splatches/Fleur_2.png", "image_sound", "Bas Gauche",    [["Ice1", rand(30), 5 + rand(10)*5], 0] ],
                              ],

               ],
               #Ecran Titre
               [ 400, true, [
                              ],
                              #BGM
                              ["Scene7",80,100]
               ]
               ]

end

#==============================================================================#
#                                                                            #
#                                                                            #
#                               Modèle de Splatch                         #
#                                                                            #
#                                                                            #
#==============================================================================#
class Splatch
attr_reader :running
attr_reader :count

#------------------------------------------------------------------------------#
#                                                                            #
# Initialise le Splatch à partir de son identifiant                         #
# et du tableau.                                                          #
#------------------------------------------------------------------------------#
def initialize(index)

@initial_count = Mhd_Splatch::SPLATCHES[index][0]       #Durée du splatch
@count       = @initial_count                         #Durée du splatch
@oblige       = Mhd_Splatch::SPLATCHES[index][1]       #Obligatoire?
@running    = true                                     #Splatch en fonction
@fading_count = Mhd_Splatch::FADE_INTERNAL             #Décompte pour toutes les images des fades

if Mhd_Splatch::SPLATCHES[index][3] != nil             #Ya-t-il une BGM?
   @bgm = RPG::BGM.new(Mhd_Splatch::SPLATCHES[index][3][0],Mhd_Splatch::SPLATCHES[index][3][1],Mhd_Splatch::SPLATCHES[index][3][2])
else
   @bgm = nil
   RPG::BGM.stop
end

#Doit-il durée indéfiniment (écran titre sans boucle)??
if (Mhd_Splatch::LOOP == false )&&(index == Mhd_Splatch::SPLATCHES.size() -1)
   @unloop = true
else
   @unloop = false
end

create_contents(index)
end

#------------------------------------------------------------------------------#
#                                                                            #
# Création des differentes images composants le splatch                   #
# Interpréteur                                                             #
#------------------------------------------------------------------------------#
def create_contents(index)
if @bgm != nil
   @bgm.play
end
@contents = []
for i in 0...Mhd_Splatch::SPLATCHES[index][2].size()
   type = Mhd_Splatch::SPLATCHES[index][2][i][3]
   case type
   when "image_sound"
      @contents += [Image_sound.new( Mhd_Splatch::SPLATCHES[index][2][i])]
   when "image_rotation"
      @contents += [Image_Rotation.new(Mhd_Splatch::SPLATCHES[index][2][i])]
   else
      @contents += [Image.new(       Mhd_Splatch::SPLATCHES[index][2][i])]
   end
end
end

#------------------------------------------------------------------------------#
#                                                                            #
# Equivalent du main des Scenes: fait tourner le Splatch                   #
#                                                                            #
#------------------------------------------------------------------------------#
def run(zap = false)
if zap == true
   @count = 0
end
if @count != 0
   if @unloop != true
      @count -=1
   end
   return update
else
   if @fading_count != 0
      preterminate
      return false
   else
      terminate
      return false
   end
end
end

#------------------------------------------------------------------------------#
#                                                                            #
# Met à jour les Images                                                    #
#                                                                            #
#------------------------------------------------------------------------------#
def update
for i in 0...@contents.size()
   @contents[i].update(@count)
end
return input_update
end

#------------------------------------------------------------------------------#
#                                                                            #
# Surveille les Inputs                                                    #
#                                                                            #
#------------------------------------------------------------------------------#
def input_update
if (@oblige != true)&&(@splatch_index != (Mhd_Splatch::SPLATCHES.size() -1))&& ((Input.trigger?(Input::B))||(Input.trigger?(Input::C)))
   @count = 0
   return true
else
   return false
end
end

#------------------------------------------------------------------------------#
#                                                                            #
# Fade les Images avant de quitter                                        #
#                                                                            #
#------------------------------------------------------------------------------#
def preterminate
#au premier appel
if @fading_count == Mhd_Splatch::FADE_INTERNAL
   for i in 0...@contents.size()
      @contents[i].fade_out
   end
end
#continue de les mettre à jour
for i in 0...@contents.size()
   @contents[i].update()
end
@fading_count -=1
end

#------------------------------------------------------------------------------#
#                                                                            #
# Quitte                                                                   #
#                                                                            #
#------------------------------------------------------------------------------#
def terminate
for i in 0...@contents.size()
   @contents[i].dispose
end
@running = false
end
end

#==============================================================================#
#                                                                            #
#                                                                            #
#                               Scene_Splatch                               #
#                         Elle remplace le titre.                         #
#                                                                            #
#==============================================================================#

class Scene_Title < Scene_Base

#------------------------------------------------------------------------------#
#                                                                            #
# Initialise la scene                                                    #
#                                                                            #
#------------------------------------------------------------------------------#
def initialize
super
@splatch_index = 0
@next_index = 1
@zap       = false
@window_on = false
@window_count = Mhd_Splatch::COUNT_WINDOW
@l_n_c_finish = false
@zapped       = false
end

#------------------------------------------------------------------------------#
#                                                                            #
# Charge les données et initialise le premier splatch                      #
#                                                                            #
#------------------------------------------------------------------------------#
def start
super
load_n_create
@splatch = Splatch.new(@splatch_index)
end
#------------------------------------------------------------------------------#
#                                                                            #
# Ecrase la fonction du Titre normal pour qu'il n'ouvre pas la fenêtre    #
# de commande.                                                             #
#------------------------------------------------------------------------------#
def post_start
super
end
#------------------------------------------------------------------------------#
#                                                                            #
# Prépare la fin de la scène                                              #
#                                                                            #
#------------------------------------------------------------------------------#
def pre_terminate
super
RPG::BGM.fade(Mhd_Splatch::FADE_INTERNAL)
close_command_window
end

#------------------------------------------------------------------------------#
#                                                                            #
# Fini la scene                                                             #
#                                                                            #
#------------------------------------------------------------------------------#
def terminate
super
dispose_command_window
RPG::BGM.stop
@splatch.terminate
snapshot_for_background
end

#------------------------------------------------------------------------------#
#                                                                            #
# Mise à jour du Splatch et de la fenêtre si elle est ouverte             #
#                                                                            #
#------------------------------------------------------------------------------#
def update
super
update_window
update_splatch
if @window_on == true
   @command_window.update
   if Input.trigger?(Input::C)
      case @command_window.index
      when 0 #New game
      command_new_game
      when 1 # Continue
      command_continue
      when 2 # Shutdown
      command_shutdown
      end
   end
end
end
#------------------------------------------------------------------------------#
#                                                                            #
# Surveille si on ouvre la fenêtre                                        #
#                                                                            #
#------------------------------------------------------------------------------#
def update_window
if @splatch_index < (Mhd_Splatch::SPLATCHES.size() -1)
   #rechargement du compte à rebour si ce n'est pas le dernier splatch
   if @window_on == false && @window_count == 0
      @window_count = Mhd_Splatch::COUNT_WINDOW
   end
else
   #décrémentation si c'est le dernier splatch, si annuler appuyé apparait de suite
   @window_count -=1
   if @window_on == false
      if Input.trigger?(Input::B)
      @window_count = 0
      end
   end
   #N'apparait pas tant que le données ne sont pas chargées
   if (@l_n_c_finish == true) && (@window_on == false)
      if @window_count <= 0
      @window_on = true
      check_continue
      create_command_window
      open_command_window
      end
   end
end
end

#------------------------------------------------------------------------------#
#                                                                            #
# Fermeture de la fenêtre                                                 #
#                                                                            #
#------------------------------------------------------------------------------#
def mhd_window_close
close_command_window
dispose_command_window
@window_count = Mhd_Splatch::COUNT_WINDOW
@window_on = false
end

#------------------------------------------------------------------------------#
#                                                                            #
# MàJ du splatch                                                          #
# Est-il zappable? zappé? Est-il fini?                                     #
#------------------------------------------------------------------------------#
def update_splatch
if @splatch.running == true
   @zap = @splatch.run(@zap)
   zap
else
   next?
   @splatch = Splatch.new(@next_index)
   @splatch_index = @next_index
   @zapped = false
end
end

#------------------------------------------------------------------------------#
#                                                                            #
# Si zappé quel est le prochain car on ne zap pas 1 splatch                #
# mais tout les splatches zappables jusqu'au prochain non zappable       #
#------------------------------------------------------------------------------#
def zap
if (@zap == true) && (@splatch_index != (Mhd_Splatch::SPLATCHES.size() -1))
   stop = true
   index = @splatch_index
   while stop == true
      index += 1
      if index == (Mhd_Splatch::SPLATCHES.size() -1)
      stop = false
      else
      stop =!Mhd_Splatch::SPLATCHES[index][1]
      end
   end
   @next_index = index
   @zapped = true
end
end

def next?
if (@zapped == false)
   if @splatch_index < (Mhd_Splatch::SPLATCHES.size() -1)
      @next_index = @splatch_index + 1
   else
      if (Mhd_Splatch::LOOP == true)
      @next_index = 0
      if @window_on == true
         mhd_window_close
      end
      end
   end
end
end

#------------------------------------------------------------------------------#
#                                                                            #
# Contraction de tout les chargement de données                            #
#                                                                            #
#------------------------------------------------------------------------------#
def load_n_create
load_database
create_game_objects
@l_n_c_finish = true
end

end

-Crédits : Vincentmhd
_________________

>> Démo

Mhd_Splatch.v1

Partager cet article