|
| | Effets de lumière : allumer / éteindre |  |
| | Auteur | Message |
|---|
BARVACHE
Paysan (niveau 3)
Messages postés : 21
Date d'inscription : 28/06/2015
Jauge LPC :
 |  Sujet: Effets de lumière : allumer / éteindre Jeu 9 Juil 2015 - 20:18 | |
| Bonsoir. J'utilise le script posté dans le message suivant. Je souhaite créer un évènement "chandelier" qu'on allumerait avec une allumette. On aurait un truc du genre... - Citation :
- [première page]
*message : utiliser l'allumette, choix : OUI NON*
*interrupteur local A activé
[deuxième page]
*commentaire FIRE:[ORANGE,100] Mais bien sûr l'effet de lumière n'est pas visible. J'ai déjà testé les techniques suivantes: - Citation :
- *appel de script : $game_map.refresh après l'activation de l'interrupteur local A
*téléporter le héros au même point après l'activation de l'interrupteur local A Mais ça ne marchait pas. J'ai également testé les méthodes allumer-éteindre déjà présentes dans le script mais sans succès => peut-être les ai-je mal utilisées. Si quelqu'un peut m'expliquer tout ça, c'est pas de refus parce que ça me dépannerait énormément. Je glisse le script dans le message suivant et j'vous remercie d'avance! |
| | | | BARVACHE
Paysan (niveau 3)
Messages postés : 21
Date d'inscription : 28/06/2015
Jauge LPC :
| | Sujet: Re: Effets de lumière : allumer / éteindre Jeu 9 Juil 2015 - 20:20 | |
| - Première partie du script:
- Code:
-
#==============================================================================#
# #
# #
# Light Effects VX 1.2 #
# #
# #
#==============================================================================#
#Original par Kylock #
#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 = {
6 => 70,
7=>50,
9=>40,
10 => 70,
1=>50,
2=>50,
11=>95,
12=>50,
13=>50,
15=>160,
}
TONE_INFLUENCE = true
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
|
| | | | BARVACHE
Paysan (niveau 3)
Messages postés : 21
Date d'inscription : 28/06/2015
Jauge LPC :
| | Sujet: Re: Effets de lumière : allumer / éteindre Jeu 9 Juil 2015 - 20:20 | |
| - Deuxième partie du script:
- Code:
-
#==============================================================================#
# 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("le2.png")
@light.origine?("Centre")
@light.blend_type = 1
@type_op = 125
@light.z = $game_light.map.size()
when "TORCH"
@light.bitmap = Cache.picture("le2.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("le2.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("le2.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),
"ORANGE" => Tone.new(255,-102,-255,0),
"MARRON" => Tone.new(-68,-68,-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 #
#==============================================================================#
|
| | | | Valefor
Ancien staffeux
Messages postés : 1945
Date d'inscription : 02/04/2012
Jauge LPC :
| | Sujet: Re: Effets de lumière : allumer / éteindre Jeu 9 Juil 2015 - 21:07 | |
| Mais comment tu le génères ton effet de lumière? Ça me semble très simple si tu le fait avec une image que tu affiche ou non selon si le chandelier est allumé ou pas. |
| | | | BARVACHE
Paysan (niveau 3)
Messages postés : 21
Date d'inscription : 28/06/2015
Jauge LPC :
| | Sujet: Re: Effets de lumière : allumer / éteindre Jeu 9 Juil 2015 - 21:43 | |
| Le script détecte les évènements comportant un commentaire de la forme LUMIERE:[COULEUR,TAILLE].
Il génère ensuite automatiquement un effet de lumière (avec l'aide d'une image enregistrée au préalable dans la partie "pictures").
Ce n'est donc pas un affichage d'image en évènements.
Je pourrai le faire en évènement, comme tu le dis, sauf que:
1. J'utilise déjà des images pour d'autres évènements et je ne veux pas de surcharge.
2. Dans le cas d'une map avec plusieurs effets de lumière allumés ou non, cela devient vite un calvaire niveau conditions + quantités d'images.
EDIT : si on sort puis retourne dans la map, l'effet de lumière est là.
Il faut donc trouver ce qui, en plus de $game_map.refresh permet d'afficher l'effet de lumière en question. |
| | | | Hinola
Ninja (niveau 4)
Messages postés : 213
Date d'inscription : 06/02/2013
Jauge LPC :
| | Sujet: Re: Effets de lumière : allumer / éteindre Ven 10 Juil 2015 - 21:47 | |
| fait gaffe, j'ai déjà regardé des scripts, des fois ils cherchent un emplacement précis pour les lignes de commentaire. Du genre si le deuxième composant est un commentaire contenant tel texte, faire ça et ça ...
Essais de mettre l'event du chandelier allumé en premier page et l'event du chandelier éteint en deuxième page. |
| | | | BARVACHE
Paysan (niveau 3)
Messages postés : 21
Date d'inscription : 28/06/2015
Jauge LPC :
| | Sujet: Re: Effets de lumière : allumer / éteindre Sam 18 Juil 2015 - 8:25 | |
| Yo.
J'ai essayé ça mais pour une histoire de priorité dans l'exécution des pages d'évènements, ça ne marche pas.
C'est toujours la page 1 qui est exécutée avant.
Ceci dit, l'emplacement est peut-être une piste ; je regarderai le script en détail.
|
| | | | Contenu sponsorisé
| | Sujet: Re: Effets de lumière : allumer / éteindre | |
| |
| | | | |
Sujets similaires | |
|
| | Permission de ce forum: | Vous ne pouvez pas répondre aux sujets dans ce forum
| |
| |
| |
Accueil du Site
Accueil
Rechercher
S'enregistrer
