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