#==============================================================================#
# #
# #
# 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 + #
# #
# #
#==============================================================================#
# #
#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 + #
#==============================================================================#

#==============================================================================#
# #
# #
# 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 #
# #
# #
#==============================================================================#
# #
#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