[VX] Effet de lumière

#==============================================================================#
# #
# #
# Light Effects VX 1.2 #
# #
# #
#==============================================================================#
#Original par Kylock #
#revu par Vincentmhd #
#http://vincentmhdmaker.canalblog.com/ #
#10/8/2010 #
# #
# #
#-------------------------------------NOTE-------------------------------------#
# #
# Ce script est une extention de celui de Kylock. #
#Il permet de placer des effets lumineux à partir d'une image et de commentaire#
# #
#Il nécéssite une image "le.png" #
# #
# #
# #
#--------------------------------EFFET LUMINEUX--------------------------------#
# #
#Utilisation: #
# #
#Tout d'abord il existe plein de synthaxes possible donc je ne vais pas toutes les expliquer
# #
#Le minimum, c'est le TYPE de lumière à savoir: #
#LIGHT :Lumière blanche toute simple #
#DARKNESS :Ombre #
#FIRE :Lumière vibrante #
#TORCH :Lumière vibrante 2 #
# #
#J'ai conservé les types de Kylock #
#Juste le type dans un commentaire fonctione mais ce n'est pas l'intérêt du script.
# #
# #
#Il existe 4 paramètres sur lesquels la lumière peut varier: #
#Les proportions, la position, la teinte et l'état (allumée ou éteinte). #
#Pour écrire les paramètres, voilà la synthaxe complète: #
# #
#TYPE:[SIZE,COORDONNEES,TONE,STATE] #
#exemple: LIGHT:[64,5,ROUGE,false] #
#dans l'exemple la lumière sera de 64 sur 64, centrée sur l'event 5, de couleur#
#rouge et éteinte à l'arrivée sur la map. #
# #
#ATTENTION pas d'espace, n'oubliez pas les : et [] #
# #
#Voyons les paramètres: #
# #
# - les proportions: #
#L'image de base reste la même mais ses proportions peuvent être modifiées en #
#carré ou en rectangle. En carré, un nombre suffit le script comprendra qu'il #
#s'agit d'un carrée. En rectangle, un tableau de nombre permet de définir #
#la largeur et la hauteur de l'effet: [a,b] #
#ATTENTION pas d'espace... #
# #
# - Les coordonnées #
#Les coordonnées peuvent être de 3 natures: #
# + un tableau de 2 nombres [a,b] #
# => Elles indiqueront une position fixe sur la map. #
# + un nombre #
# => Il correspondra à l'id d'un event auquel il sera fixé. #
# + une chaine avec P au début P... #
# => Il permet d'attribuer un effet sur le player. #
# Attention l'effet ne sera dispo que sur la map de l'event créateur. #
# #
# - Le ton de l'image #
#Il peut être un mot-clé, correspondant à un ton dans le hash ligne 1321 #
#ou un tableau à 4 composantes: [r,b,g,a]. #
# #
# - L'état #
#Ca peut paraitre étrange mais pour s'allumer ou s'éteindre un effet doit #
#exister. Donc il se peut que vous ayez à déclarer des effets éteints pour #
#pouvoir les allumer après. #
# #
# #
#Un mot sur l'ordre des paramètres: #
# #
#le ton et l'état peuvent être mis n'importe où. #
#Parcontre, les proportions doivent toujours être avant les coordonnées et #
#si vous déclarez des coordonnées il faudra déclarer des proportions avant. #
#Il existe une seule exception, si la coordonnée est une chaine pour le player.#
# #
#Autre: #
#Les effets sont répertoriés dans un hash dont les keys correspondent aux #
#coordonnées des effets. Cela implique qu'un event ne peut avoir q'un effet qui#
#le suit, qu'une position fixe idem. Le player parcontre peut en avoir autant #
#que voulu. #
# #
#Comment allumer ou éteindre une lumière: #
#Il faut utiliser ces appels: #
#$game_light.map[COORDONNEES].on #
#$game_light.map[COORDONNEES].off #
#Ces transformations sont oubliées si vous changez de map. #
#Utilisez les pages et les interrupteurs locaux pour les rendre permanentes. #
# #
#$game_light.map_on #
#$game_light.map_off #
#Allume ou éteint toutes les lumières dépendantes de la map. #
# #
#Vous pouvez redimensionner les lumières. #
#$game_light.map[COORDONNEES].resize(SIZE [,frame]) #
# #
# #
#------------------------------MAP SOMBRE ET GROTTE----------------------------#
# #
# Il est possible d'habiller l'écran d'un voile noir qui se révèle par #
#compensation avec les effets lumineux. Ce voile peut être plus ou moins opaque#
#Les maps à voiler se trouvent ds un tableau DARK_MAP, ligne 214 il regroupe les
#identifiants des maps avec l'opacité correspondante. #
# #
#Détail, les opacités des effets sont alignées sur cette opacity afin d'adapter#
#la compensation. #
# #
# #
# #
#----------------------------------Influence des tons--------------------------#
# #
#A vrai dire, je ne sais pas vraiment ce qui est le mieux. Un interrupteur #
#permet d'aligner ou non le tone du viewport des effets sur celui de la map. #
# #
# TONE_INFLUENCE #
# #
#Ligne 217 #
# #
#------------------------Petit mot pour ceux qui en veulent plus---------------#
# #
# Dans le script tel quel il n'y a qu'une image de base, afin de limiter les #
#dépence aux fichiers. Il est possible d'ajouter d'autres formes de base en #
#ajoutant d'autre type d'effet. #
# #
#Cependant cela demande quelques connaissance en script mais ce n'est pas #
#compliqué. #
# #
#Allez à la ligne 529 #
#Vous voyez : #
# #
#if ["LIGHT","DARKNESS","TORCH","FIRE"].include?(key) #
# #
#Ajoutez le nom de votre type personalisé dans le array comme les autres types.#
#(c'est pour que le script reconnaisse le commentaire) #
# #
#if ["LIGHT","DARKNESS","TORCH","FIRE","MON_TRUC_PERSO"].include?(key) #
# #
# #
#Allez à la ligne 689 #
#Vous voyez: #
# #
# def draw #
# case @light_type #
# when "LIGHT" #
# @light.bitmap = Cache.picture("le.png") #
# @light.origine?("Centre") #
# @light.blend_type = 1 #
# @type_op = 125 #
# when "TORCH" #
# @light.bitmap = Cache.picture("le.png") #
# @light.origine?("Centre") #
# @light.blend_type = 1 #
# @type_op = 125 #
# @tremble = [10,10] #
# when "FIRE" #
# @light.bitmap = Cache.picture("le.png") #
# @light.origine?("Centre") #
# @light.blend_type = 1 #
# @type_op = 125 #
# @tremble = [3,3] #
# when "DARKNESS" #
# @light.bitmap = Cache.picture("le.png") #
# @light.origine?("Centre") #
# @light.blend_type = 2 #
# @type_op = 125 #
# else #
# end #
# end #
# #
#Pas de panique, c'est relativement simple. #
#Bon il y les 4 types de base avec leurs paramètres inérants. Décrivons-les. #
# #
# #
# when "FIRE" #
# *Identifie le type de l'effet à faire. il faudra mettre un when "MON_TRUC_PERSO"
# avant le else* #
# @light.bitmap = Cache.picture("le.png") #
# *Quelle image attribuer à votre effet* #
# @light.origine?("Centre") #
# *Comment centrer l'image (méthode perso à mot clé voir plus bas Sprite +)*#
# @light.blend_type = 1 #
# *Comment intégrer l'image par addition 1 par soustraction 2 (0 n'est pas utile ici)
# @type_op = 125 #
# *Quelle est l'opacité de base de cet effet* #
# @tremble = [3,3] #
# *Si l'effet tremble à quelle puisance. #
# #
# #
#Pour ajouter votre effet, il suffit d'ajouter un when "MON_TRUC_PERSO" avant #
#le else et de prendre modèle sur les autres types #
# #
#Bon je crois que j'ai fait le tour... #
# #
#==============================================================================#






#==============================================================================#
# #
# Gestionnaire des effets lumineux #
# #
#==============================================================================#
class Gst_light
#Variables globales
DARK_MAP = {2 => 125,
3 => 225,
12=> 175 }
TONE_INFLUENCE = false

attr_accessor :map, :eq, :comp
#------------------------------------------------------------------------------#
# Initialisation #
#------------------------------------------------------------------------------#
def initialize
vp_create
@map = {}
@eq = {}
@comp = {}
end

#==============================================================================#
# Ensemble des méthodes de créations #
#==============================================================================#
def create
create_darkness
end
#------------------------------------------------------------------------------#
# Création du viewport #
#------------------------------------------------------------------------------#
def vp_create
@viewport = Viewport.new(0,0,Graphics.width, Graphics.height)
@viewport.z = 1
end
#------------------------------------------------------------------------------#
# Renvois le viewport #
#------------------------------------------------------------------------------#
def viewport
return @viewport
end
#------------------------------------------------------------------------------#
# Création de la sprite de l'ombre. #
#------------------------------------------------------------------------------#
def create_darkness
if dark_map?()
if (@dark.nil?)||(@dark.disposed?)
@dark = Sprite.new(@viewport)
@dark.z = 1000
@dark.bitmap = Bitmap.new(2*Graphics.width, 2*Graphics.height)
@dark.bitmap.remplir(Color.new(255,255,255,255))
@dark.origine?("Centre")
@dark.coord?("Centre")
@dark.blend_type = 2
@dark.visible = false
end
@dark.opacity = DARK_MAP[$game_map.map_id]
else
if (!@dark.nil?)&&(!@dark.disposed?)
@dark.opacity = 0
end
end
#met à jour les opacités en fonction
for light in @map.values
light.refresh_op
end
end
#------------------------------------------------------------------------------#
# Création de la sprite de l'ombre. #
#------------------------------------------------------------------------------#
def create_from_event(type,param,id_event)
light = Light.new
light.create_from_event(type,param,id_event)
@map[light.key] = light
end
#==============================================================================#
# Méthodes de l'Ombre. #
#==============================================================================#
def dark_map?(id = $game_map.map_id)
return DARK_MAP.has_key?(id)
end

def dark_opacity
if (!@dark.nil?)&&(!@dark.disposed?)
return @dark.opacity
else
return 0
end
end

#==============================================================================#
# Ensemble des méthodes de monstration. #
#==============================================================================#
def show
show_darkness
show_map
end

def hide
hide_darkness
hide_map
end
#------------------------------------------------------------------------------#
# Monstration de l'ombre. #
#------------------------------------------------------------------------------#
def show_darkness
if dark_map?()||(!@dark.nil?)
if (!@dark.disposed?)
@dark.visible = true
end
end
end

def hide_darkness
if dark_map?()||(!@dark.nil?)
if(!@dark.disposed?)
@dark.visible = false
end
end
end
#------------------------------------------------------------------------------#
# Monstration des effets ce la map. #
#------------------------------------------------------------------------------#

def show_map
for light in @map.values
light.show
end
end

def hide_map
for light in @map.values
light.hide
end
end

#==============================================================================#
# Ensemble des méthodes de mise à jour. #
#==============================================================================#
def update
vp_update
update_darkness
update_map
end

#------------------------------------------------------------------------------#
# Mise à jour du viewport. #
#------------------------------------------------------------------------------#
def vp_update
if TONE_INFLUENCE
@viewport.tone = $game_map.screen.tone
end
@viewport.ox = $game_map.screen.shake
@viewport.update
end
#------------------------------------------------------------------------------#
# Mise à jour de l'ombre. #
#------------------------------------------------------------------------------#
def update_darkness
if dark_map?()
if (@dark.nil?||@dark.disposed?)
create_darkness
end
@dark.update
end
end
#------------------------------------------------------------------------------#
# Mise à jour des lumières #
#------------------------------------------------------------------------------#
def update_map
for light in @map.values
light.update
end
end

#------------------------------------------------------------------------------#
# Tout éteindre la map. #
#------------------------------------------------------------------------------#
def map_off
for light in @map.values
light.off
end
end


#------------------------------------------------------------------------------#
# Tout allumer de la map. #
#------------------------------------------------------------------------------#
def map_on
for light in @map.values
light.on
end
end

#==============================================================================#
# Ensemble des méthodes de destruction. #
#==============================================================================#
def dispose
dispose_darkness
end

#------------------------------------------------------------------------------#
# Destruction du viewport #
#------------------------------------------------------------------------------#
def vp_dispose
@viewport.dispose
end
#------------------------------------------------------------------------------#
# Destruction de l'ombre. #
#------------------------------------------------------------------------------#
def dispose_darkness
if dark_map?()
@dark.dispose
end
end
#------------------------------------------------------------------------------#
# Destruction de l'ombre. #
#------------------------------------------------------------------------------#
def clear_map
for light in @map.values
light.dispose
end
@map.clear
end

end



#==============================================================================#
# #
# Alias de la classe des images de Maps #
# #
#==============================================================================#
class Spriteset_Map

#Alias nécessaires
alias light_initalize initialize
alias light_dispose dispose
alias light_update update

#------------------------------------------------------------------------------#
# Initialisation #
#------------------------------------------------------------------------------#
def initialize
light_initalize
$game_light.create
$game_light.show
end


#------------------------------------------------------------------------------#
# Update #
#------------------------------------------------------------------------------#
def update
light_update
$game_light.update
end

#------------------------------------------------------------------------------#
# Dispose #
#------------------------------------------------------------------------------#
def dispose
light_dispose
$game_light.dispose
$game_light.hide
end

end


#==============================================================================#
# #
# Création du gestionnaire #
# #
#==============================================================================#
class Scene_Title
alias light_create_game_objects create_game_objects
def create_game_objects
light_create_game_objects
$game_light = Gst_light.new
end
end


#==============================================================================#
# #
# Mise à jour du Gestionnaire à la Map #
# #
#==============================================================================#
class Game_Map

alias mhd_light_setup_events setup_events
def setup_events
mhd_light_setup_events
self.Mhd_setup
end

def Mhd_setup
for event in $game_map.events.values
next if event.list == nil
for i in 0...event.list.size
if event.list[i].code == 108
commentaire = ""
commentaire = event.list[i].parameters.to_s
info = Commentaire.analyse(commentaire)
self.Analyse_Com(info[0], info[1], event)
end
end
end
end

if !defined?(Analyse_Com(key, param, event))
def Analyse_Com(key, param, event)
end
end


alias light_Analyse_Com Analyse_Com
alias light_setup_events setup_events

def Analyse_Com(key, param, event)
light_Analyse_Com(key,param, event)
if ["LIGHT","DARKNESS","TORCH","FIRE"].include?(key)
$game_light.create_from_event(key,param, event.id)
end
end

def setup_events
$game_light.clear_map
light_setup_events
end

end

#==============================================================================#
# #
# Classe d'un effet lumineux #
# #
#==============================================================================#
class Light

#------------------------------------------------------------------------------#
# Initialisation #
#------------------------------------------------------------------------------#
def initialize()

@light = Sprite.new($game_light.viewport)

@light_type = nil
@coord_type = nil
@light.visible = false

@op_count = 0
@size_count = 0
@active = true
@id
end


#------------------------------------------------------------------------------#
# Ce qui permet de l'identifier #
#------------------------------------------------------------------------------#
def key
return @coord
end

#==============================================================================#
# Méthodes d'action. #
#==============================================================================#
#------------------------------------------------------------------------------#
# Allume la lumière. #
#------------------------------------------------------------------------------#
def on
@state = true
op_change(@type_op)
end
#------------------------------------------------------------------------------#
# Eteint la lumière. #
#------------------------------------------------------------------------------#
def off
@state = false
op_change(0)
end

#==============================================================================#
# Ensemble des méthodes d'opacité. #
#==============================================================================#
def op_change (op , duration = 60)
@op_count = duration
@target_op = op
if @op_count == 0
@light.opacity = op
end
end
#------------------------------------------------------------------------------#
# Eteint la lumière. #
#------------------------------------------------------------------------------#
def align_op
coef = 1 - (($game_light.dark_opacity.to_f)*0.5)/ 255.0
@type_op = (@type_op.to_f * (coef)).to_i
end


#------------------------------------------------------------------------------#
# Redimensionnement de l'image #
#------------------------------------------------------------------------------#
def resize(a, count = 60)

if (a.is_a?(Array)) && (a.size == 2)
@size_target = [a[0].to_i, a[1].to_i]

elsif (a.is_a?(Array)) && (a.size == 1)
@size_target=[a[0].to_i, a[0].to_i]

elsif a.is_a?(Integer)
@size_target=[a.to_i, a.to_i]
end
@size_count = count
end

#==============================================================================#
# Ensemble des méthodes de création. #
#==============================================================================#
#------------------------------------------------------------------------------#
# Création par event #
#------------------------------------------------------------------------------#
def create_from_event(type, param, id_event)
info = Commentaire.decompose(param)
create_light(type)
info = check_state(info)
info = create_tone(info)

if !info.nil?
if (info.is_a?(Array))&&(info.size > 1)
create_size(info[0])
create_coord(info[1],id_event)
else
create_size(info)
create_coord([],id_event)
end
else
create_size([])
create_coord([],id_event)
end

if @coord.is_a?(Array)
@coord_type = "Fixe"
elsif @coord.is_a?(Integer)
@coord_type = "Event"
elsif @coord.is_a?(String)
@coord_type = "Player"
end
end

#------------------------------------------------------------------------------#
# Création par équipement #
#------------------------------------------------------------------------------#
def create_from_eq(type, param, id_eq)
end

#------------------------------------------------------------------------------#
# Création par compétence #
#------------------------------------------------------------------------------#
def create_from_comp(type, param, id_comp)
end

#==============================================================================#
# Ensemble des sous-méthodes de création. #
#==============================================================================#
#------------------------------------------------------------------------------#
# Création de la lumière. #
#------------------------------------------------------------------------------#
def create_light(type)
@light_type = type
draw
align_op
draw_op
end

def draw
case @light_type
when "LIGHT"
@light.bitmap = Cache.picture("le.png")
@light.origine?("Centre")
@light.blend_type = 1
@type_op = 125
@light.z = $game_light.map.size()
when "TORCH"
@light.bitmap = Cache.picture("le.png")
@light.origine?("Centre")
@light.blend_type = 1
@type_op = 125
@tremble = [10,10]
@light.z = $game_light.map.size()
when "FIRE"
@light.bitmap = Cache.picture("le.png")
@light.origine?("Centre")
@light.blend_type = 1
@type_op = 125
@light.z = $game_light.map.size()
@tremble = [3,3]
when "DARKNESS"
@light.bitmap = Cache.picture("le.png")
@light.origine?("Centre")
@light.blend_type = 2
@type_op = 125
@light.z = $game_light.map.size() -1000
#pour les Ténèbres s'annulent à la lumière il faut qu'ils soient sous
#la lumière.
else
end
end

def draw_op
@target_op = @type_op
@light.opacity = @type_op
end
#------------------------------------------------------------------------------#
# Création de la taille de l'image (zoom) #
#------------------------------------------------------------------------------#
def create_size(info)
a = Commentaire.decompose(Commentaire.decompose(info))
@size = 64

if (a.is_a?(Array)) && (a.size == 2)
@size = [a[0].to_i, a[1].to_i]

elsif (a.is_a?(Array)) && (a.size == 1)
@size=[a[0].to_i, a[0].to_i]

elsif a.is_a?(String)
if a[0,1] == 'P'
@coord = a #si le makeur oubli...
else
@size=[a.to_i, a.to_i]
end
end
@light.zoom_resize(@size[0],@size[1])
@size_target = @size
end



#------------------------------------------------------------------------------#
# Création de le ton de l'image (fonctionne par mots-clés et par arrays) #
#------------------------------------------------------------------------------#
def create_tone(param)

if ( ! param.nil? )

if (param.is_a?(Array))
for i in 0...param.size
a = Commentaire.tone?(Commentaire.decompose(param[i]))
if !(a.nil?)
@light.tone = a
param.delete_at(i)
end
end

elsif (param.is_a?(String))
a = Commentaire.tone?(param)
if !(a.nil?)
@light.tone = a
param = nil
end
end

end
return param



end
#------------------------------------------------------------------------------#
# Création des Coordonnées de l'image #
#------------------------------------------------------------------------------#
def create_coord(info, id)
if @coord.nil?
a = Commentaire.decompose(Commentaire.decompose(info))

if (a.is_a?(Array))&&(a.size == 2)
@coord = [a[0].to_i, a[1].to_i]
elsif (a.is_a?(Array))&&(a.size == 1)
@coord = a[0].to_i
elsif a.is_a?(String)
if a[0,1] == 'P'
@coord = a
else
@coord = a.to_i
end
else
@coord = id
end
end
end
#------------------------------------------------------------------------------#
# Initialisation de l'état de l'éclairage. #
#------------------------------------------------------------------------------#
def check_state(param)

if !param.nil?

if param.is_a?(Array)
for i in 0...param.size
if param[i] == "false"
@state = false
@target_op = 0
@light.opacity = 0
param.delete_at(i)
end
end

elsif param.is_a?(String)
if param == "false"
@state = false
@target_op = 0
@light.opacity = 0
param = nil
end
end
end

if @state.nil?
@state = true
end

return param
end

#==============================================================================#
# Ensemble des méthodes de mise à jour. #
#==============================================================================#
def update
if @active
@light.update
op_update
size_update
place
end
end

#------------------------------------------------------------------------------#
# Mise à jour de l'opacité en changement. #
#------------------------------------------------------------------------------#
def op_update
if @op_count>0
d = @op_count
@light.opacity = (@light.opacity * (d - 1) + @target_op) / d
@op_count -=1
end
end

#------------------------------------------------------------------------------#
# Mise à jour de l'opacité en changement. #
#------------------------------------------------------------------------------#
def size_update
if @size_count >0
d = @size_count
@size[0] = (@size[0] * (d - 1) + @size_target[0]) / d
@size[1] = (@size[1] * (d - 1) + @size_target[1]) / d
@light.zoom_resize(@size[0],@size[1])
@size_count -=1
end
end

#------------------------------------------------------------------------------#
# Mise à jour de la position. #
#------------------------------------------------------------------------------#
def place
if !(@light.opacity == 0)
case @coord_type
when "Fixe"
@light.x = (((@coord[0]* 256) - ($game_map.display_x))/8 + 16).round
@light.y = (((@coord[1]* 256) - ($game_map.display_y))/8 + 16).round
when "Event"
@light.x = ((($game_map.events[@coord].real_x) - ($game_map.display_x))/8 + 16).round
@light.y = ((($game_map.events[@coord].real_y) - ($game_map.display_y))/8 + 16).round
when "Player"
@light.x = ((($game_player.real_x) - ($game_map.display_x))/8 + 16).round
@light.y = ((($game_player.real_y) - ($game_map.display_y))/8 + 16).round
else
end


if !(@tremble.nil?)
@light.x += rand(2*@tremble[0]) - @tremble[0]
@light.y += rand(2*@tremble[1]) - @tremble[1]
end
end
end

#------------------------------------------------------------------------------#
# Rendre la lumière visible #
#------------------------------------------------------------------------------#
def show
@light.visible = true
@active = true
end

#------------------------------------------------------------------------------#
# Rendre la lumière invisible #
#------------------------------------------------------------------------------#
def hide
@light.visible = false
@active = false
end
#==============================================================================#
# Méthodes de refresh #
#==============================================================================#
def refresh_op
draw
align_op
draw_op
if !(@state)
@target_op = 0
@light.opacity = 0
end
end

#==============================================================================#
# Ensemble des méthodes de destrution. #
#==============================================================================#
def dispose
@light.dispose
end
end

#==============================================================================#
# #
# Outils #
# #
#==============================================================================#

#==============================================================================#
# #
# #
# BITMAP + (Dessin) #
# #
# #
#==============================================================================#
# #
#By Vincentmhd #
#http://vincentmhdmaker.canalblog.com/ #
#01/4/2010 #
# #
# #
# #
# #
#-------------------------------------NOTE-------------------------------------#
# #
# Ajout de méthodes pour dessiner des formes plus rapidement #
# #
#------------------------------------LISTE-------------------------------------#
# #
# #
# ________________________________________________________________________ #
# | | | #
# | Prototype | Action | #
# |____________________________________|___________________________________| #
# | | | #
# | remplir(Color, Rect) | Remplis un rentangle. | #
# |____________________________________|___________________________________| #
# #
# #
#==============================================================================#

class Bitmap

#------------------------------------------------------------------------------#
# #
# Permet de remplir le rectangle. #
# (c'est juste pour avoir moins de variables à renseigner.) #
# plus pratique de commencer par la couleur... #
#------------------------------------------------------------------------------#

def remplir(color = Color.new(255,255,255,255), rect = self.rect)
self.fill_rect(rect , color)
end
end
#==============================================================================#
# #
# #
# SPRITE + (Coordonnées #
# #
# #
#==============================================================================#
# #
#By Vincentmhd #
#http://vincentmhdmaker.canalblog.com/ #
#18/8/2010 #
# #
#v2, ajout de x_min, y_min, width et height dans la méthode coord? #
# #
# #
#-------------------------------------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-------------------------------------#
# #
# #
# ________________________________________________________________________ #
# | | | #
# | Prototype | Action | #
# |____________________________________|___________________________________| #
# | | | #
# | Void > zoom_resize(Int, Int) | Détermination la taille du zoom | #
# | | pour avoir la taille demandée. | #
# |____________________________________|___________________________________| #
# | | | #
# | Bool > is_on?(Int, Int) | Détermination si la coord est | #
# | | dans la sprite. | #
# |____________________________________|___________________________________| #
# | | | #
# | Rect[Bool] is_on_corner?(Int, Int)| Détermination si la coord est dans| #
# | | les coins. | #
# |____________________________________|___________________________________| #
# | | | #
# | Rect[Bool] is_on_corner_8(Int, | Détermination si les coord est | #
# | Int, Int) | dans les coins. | #
# |____________________________________|___________________________________| #
# | | | #
# | Void > coord?(String, Rect) | Sous ces multiples Prototypes qui | #
# | | peuvent effrayer cette méthode est| #
# | | faites pour simplifier le | #
# | Void > coord?(Array[Int, Int, | placement des sprites par | #
# | Int, Int], | l'utilisation de mots-clés. | #
# | Rect) | | #
# | | @x, @y, @zoom_x, @zoom_y | #
# | Void > coord?(Array[String, | | #
# | Int, Int], | | #
# | Rect) | | #
# | | | #
# |____________________________________|___________________________________| #
# | | | #
# | Void > origine?(Int, Int) | Sous ces multiples Prototypes qui | #
# | | peuvent effrayer cette méthode est| #
# | | faites pour simplifier le | #
# | Void > origine?(String) | placement des sprites par | #
# | | l'utilisation de mots-clés. | #
# | | | #
# | | @ox, @oz | #
# |____________________________________|___________________________________| #
# #
# #
#==============================================================================#

class Sprite


def zoom_resize(width,height = width)
self.zoom_x = width.to_f/ ((self.width).to_f)
self.zoom_y = height.to_f/ ((self.height).to_f)
end
#------------------------------------------------------------------------------#
# #
# Renvoit si la coordonnée est sur la croix centrale. #
# #
#------------------------------------------------------------------------------#
def is_on_center_cross?(x = $souris.x, y = $souris.y)
return (self.rect).is_on_center_cross?(x,y)
end


#------------------------------------------------------------------------------#
# #
# #
# Renvoit le rectangle de la sprite #
# #
# #
#------------------------------------------------------------------------------#
def rect
if self.viewport != nil
x = self.x + self.viewport.rect.x
y = self.y + self.viewport.rect.y
w = self.zoom_x*self.width
h = self.zoom_y*self.height
else
x = self.x
y = self.y
w = self.zoom_x*self.width
h = self.zoom_y*self.width
end
return Rect.new(x,y,w,h)
end


#------------------------------------------------------------------------------#
# #
# #
# Détermination si la coordonnée est dans la sprite. #
# #
# #
#------------------------------------------------------------------------------#

def is_on?(x = $souris.x, y= $souris.y)

return self.rect.is_on?(x,y)
end

#------------------------------------------------------------------------------#
# #
# #
# Détermination si la coordonnée est dans les coins de la sprite. #
# #
# #
#------------------------------------------------------------------------------#

def is_on_corner?(x = $souris.x, y= $souris.y, side = 8*self.zoom_x)
return self.rect.is_on_corner?(x,y,side)
end


#------------------------------------------------------------------------------#
# #
# #
# Détermination si la coordonnée est dans les coins de la sprite. #
# #
# #
#------------------------------------------------------------------------------#

def is_on_corner_8?(x = $souris.x, y= $souris.y, side = 8*self.zoom_x)
return self.rect.is_on_corner_8?(x,y,side)
end

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

def coord?(coord, rect = Rect.new(0,0,Graphics.width,Graphics.height))
zoom_x = 100
zoom_y = 100

x_min = rect.x
y_min = rect.y
width = rect.width
height= rect.height

case (coord)
when nil
x = x_min
y = y_min

when "Haut Gauche"
x = x_min
y = y_min

when "Haut Droite"
x = x_min + width
y = y_min

when "Bas Gauche"
x = x_min
y = y_min + height

when "Bas Droite"
x = x_min + width
y = y_min + heigth

when "Haut Centre"
x = x_min + width/2
y = y_min

when "Bas Centre"
x = x_min + width/2
y = y_min + height

when "Gauche Centre"
x = x_min
y = y_min + height/2

when "Droite Centre"
x = x_min + width
y = y_min + height/2

when "Centre"
x = x_min + width/2
y = y_min + height/2

else

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

case coord[0]

when "Haut Gauche"
x = x_min
y = y_min

when "Haut Droite"
x = x_min + width
y = y_min

when "Bas Gauche"
x = x_min
y = y_min + height

when "Bas Droite"
x = x_min + width
y = y_min + heigth

when "Haut Centre"
x = x_min + width/2
y = y_min

when "Bas Centre"
x = x_min + width/2
y = y_min + height

when "Gauche Centre"
x = x_min
y = y_min + height/2

when "Droite Centre"
x = x_min + width
y = y_min + height/2

when "Centre"
x = x_min + width/2
y = y_min + height/2


else
x = x_min + coord[0]
y = y_min + 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 + #
#==============================================================================#

#==============================================================================#
# #
# #
# Mhd_File #
# #
# #
#==============================================================================#
# #
#Vincentmhd #
#http://vincentmhdmaker.canalblog.com/ #
#10/07/2010 #
# #
# #
#-------------------------------------NOTE-------------------------------------#
# #
# Ceci est une classe de décomposition de chaine selon une synthase précise. #
#Me sert dans mes commentaires: Ils ont tous cette forme: #
# #
# CLEE:[PARAMETRES] #
# #
# La clée identifie le script a qui est adressé les paramètres. #
#Selon les scripts les paramètres peuvent être imbriqués à diverses profondeurs#
#Cette synthaxe me permet de compresser et d'homogénéïser le paramétrage de mes#
#scripts. #
#==============================================================================#



module Commentaire

C = ":"
S = ","
IN = "["
OUT = "]"


TONE = {"BLANC" => Tone.new(255,255,255,0),
"NEUTRE" => Tone.new(0,0,0,255),
"NOIR" => Tone.new(-255,-255,-255,0),
"+1/2" => Tone.new(125,125,125,0),
"-1/2" => Tone.new(-125,-125,-125,0),
"" => Tone.new(0,0,0,0),
"ROUGE" => Tone.new(255,-255,-255,0),
"VERT" => Tone.new(-255,255,-255,0),
"CYAN" => Tone.new(-255,255,255,0),
"BLEU" => Tone.new(-255,-255,255,0),
"JAUNE" => Tone.new(255,255,-255,0),
"MAGENTA" => Tone.new(255,-255,255,0)
}

def analyse(commentaire)
info = []
index = 0
ouvert = 0
info[index] = ""
for i in 0...commentaire.size

info[index] += commentaire[i,1]

if info[index][info[index].size - IN.size, IN.size] == IN
ouvert += 1
end

#Si l'on ferme un crochet
if info[index][info[index].size - (OUT.size), OUT.size] == OUT
ouvert -= 1
#Si l'on retourne à la strate 0
if ouvert == 0
info[index]= info[index][IN.size, info[index].size - (IN.size + OUT.size)]
end
end


if (ouvert == 0)
if info[index][info[index].size - C.size, C.size] == C
info[index] = info[index][0,info[index].size - C.size]
index += 1
info[index] = ""
end
end
end
return info
end

#------------------------------------------------------------------------------#
# #
# Décompose une chaine en plusieurs chaine de Rang 1 #
# #
#------------------------------------------------------------------------------#

def decompose(commentaire)
info = []
index = 0
ouvert = 0
info[index] = ""
if commentaire.is_a?(String)
for i in 0...commentaire.size

info[index] += commentaire[i,1]

if info[index][info[index].size - IN.size, IN.size] == IN
ouvert += 1
end

#Si l'on ferme un crochet
if info[index][info[index].size - (OUT.size), OUT.size] == OUT
ouvert -= 1
#Si l'on retourne à la strate 0
if ouvert == 0
info[index]= info[index][IN.size, info[index].size - (IN.size + OUT.size)]
end
end


if (ouvert == 0)
if info[index][info[index].size - S.size, S.size] == S
info[index] = info[index][0,info[index].size - S.size]
index += 1
info[index] = ""
end
end
end
#resultat
if info.size > 1
return info
else
return info[0]
end

else
if (commentaire.is_a?(Array))&&(commentaire.size == 1)
return commentaire[0]
else
return commentaire
end
end
end

#------------------------------------------------------------------------------#
# #
# Transforme un commentaire en ton. #
# #
#------------------------------------------------------------------------------#
def tone?(commentaire)
commentaire = decompose(commentaire)


if (commentaire.is_a?(Array))&&(commentaire.size == 4)
t = Tone.new((commentaire[0]).to_i,(commentaire[1]).to_i,(commentaire[2]).to_i,(commentaire[3]).to_i)
return t
elsif TONE.has_key?(commentaire)
return TONE[commentaire]
else
return nil
end
end
end

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

#==============================================================================#
# Fin de Mhd_Commentaire #
#==============================================================================#