Время/Дата v. 6.1 Финальная Версия

#============================================================================== # ** Victor Engine - Light Effects #------------------------------------------------------------------------------ # Author : Victor Sant # # Version History: # v 1.00 - 2011.12.21 > First release # v 1.01 - 2011.12.23 > Compatibility with Diagonal Movement # v 1.02 - 2011.12.24 > Better checks for images bigger than screen # v 1.03 - 2011.12.27 > Fixed bug when teleporting to same map # v 1.04 - 2011.12.30 > Faster Regular Expressions # v 1.05 - 2012.01.04 > Fixed lantern direction bug # > Fixed load fail when lights ON # v 1.06 - 2012.01.07 > Fixed light opacity change not updating # v 1.07 - 2012.01.13 > Fixed update delay when exiting the menu # v 1.08 - 2012.01.15 > Fixed the positive sign on some Regular Expressions # > Fixed the Regular Expressions problem with "" and 灯 # v 1.09 - 2012.05.21 > Compatibility with Map Turn Battle # v 1.10 - 2012.07.24 > Compatibility with Moving Platform # > Changed actor indexing for lantern (now start at 1) # v 1.11 - 2012.08.02 > Compatibility with Basic Module 1.27 # v 1.12 - 2013.01.07 > Fixed issue with actor lantern and map transfer #------------------------------------------------------------------------------ # This scripts allow to add varied light effects to the maps. But it works # different from other scripts with this function. # Normally, light effect scripts add images above the events, and then the # screen is tone is changed, with the images staying bellow the darker layer. # This script add an new darkened layer, and apply the light effect images # on this layer. #------------------------------------------------------------------------------ # Compatibility # Requires the script 'Victor Engine - Basic Module' v 1.27 or higher # # * Alias methods # class Game_Map # def setup(map_id) # # class Game_CharacterBase # def init_public_members # def update # # class Game_Event < Game_Character # def clear_starting_flag # # class Spriteset_Map # def initialize # def update # def dispose # # class Scene_Map # def pre_transfer # # class Game_Interpreter # def comment_call # #------------------------------------------------------------------------------ # Instructions: # To instal the script, open you script editor and paste this script on # a new section bellow the Materials section. This script must also # be bellow the script 'Victor Engine - Basic' # The lights must be placed on the folder "Graphics/Lights". Create a folder # named "Lights" on the Graphics folder. # #------------------------------------------------------------------------------ # Comment calls note tags: # Tags to be used in events comment box, works like a script call. # # <create shade> # setting # </create shade> # Create a shade effect on the map, add the following values to the setting. # opacity: x : opacity (0-255) # red: x : red tone (0-255, can be negative) # green: x : green tone (0-255, can be negative) # blue: x : blue tone (0-255, can be negative) # blend: x : fog blend type (0: normal, 1: add, 2: subtract) # # <actor light> <event light> <vehicle light> # setting setting setting # </actor light> </event light> </vehicle ligth> # Create a light effect on actor, event or vehicle, add the following # values to the info. The ID, index and name must be added, other values # are optional. # id: x : ligh effect ID # name: "x" : ligh effect graphic filename ("filename") # index: x : actor index, event id or (0: boat, 1: ship, 2: airship) # opacity: x : light opacity (0-255) # pos x: x : coordinate X adjust # pos y: x : coordinate Y adjust # var: x : light opacity variation # speed: x : light variation speed # zoom: x : ligh effect zoom (100 = default size) # # <map light> # setting # </map light> # Create a light effect on a specific map postion, add the following # values to the info. The ID, map_x, map_y and name must be added, other # values are optional. # id: x : ligh effect ID # name: "x" : ligh effect graphic filename ("filename") # map x: x : map X coordinate # map y: x : map Y coordinate # opacity: x : light opacity (0-255) # pos x: x : coordinate X adjust # pos y: x : coordinate Y adjust # var: x : light opacity variation # speed: x : light variation speed # zoom: x : ligh effect zoom (100 = default size) # # <actor lantern i: o> # <event lantern i: o> # <vehicle lantern i: o> # Call a lantern on the target character, lanterns are effets that # lights the front of the character # i : actor index, event id or (0: boat, 1: ship, 2: airship) # o : light opacity (0-255) # # <light opacity id: o, d> # This tag allows to change the light opacity gradually # i : light effect ID # o : new opacity (0-255) # d : wait until complete change (60 frames = 1 second) # # <shade opacity: o, d> # This tag allows to change the shade opacity gradually # o : new opacity (0-255) # d : wait until complete change (60 frames = 1 second) # # <shade tone: r, g, b, d> # This tag allows to change the shade opacity gradually # r : red tone (0-255, can be negative) # g : green tone (0-255, can be negative) # b : blue tone (0-255, can be negative) # d : wait until complete change (60 frames = 1 second) # # <remove light: id> # This tag allows remove a light effect # id: ligh effect ID # #------------------------------------------------------------------------------ # Maps note tags: # Tags to be used on the Maps note box in the database # # <create shade> # setting # </create shade> # Create a shade effect on the map, add the following values to the setting. # opacity: x : opacity (0-255) # red: x : red tone (0-255, can be negative) # green: x : green tone (0-255, can be negative) # blue: x : blue tone (0-255, can be negative) # blend: x : fog blend type (0: normal, 1: add, 2: subtract) # # <actor light> <event light> <vehicle light> # setting setting setting # </actor light> </event light> </vehicle ligth> # Create a light effect on actor, event or vehicle, add the following # values to the info. The ID, index and name must be added, other values # are optional. # id: x : ligh effect ID # name: "x" : ligh effect graphic filename ("filename") # index: x : actor index, event id or (0: boat, 1: ship, 2: airship) # opacity: x : light opacity (0-255) # pos x: x : coordinate X adjust # pos y: x : coordinate Y adjust # var: x : light opacity variation # speed: x : light variation speed # zoom: x : ligh effect zoom (100 = default size) # # <map light> # setting # </map light> # Create a light effect on a specific map postion, add the following # values to the info. The ID, map_x, map_y and name must be added, other # values are optional. # id: x : ligh effect ID # name: "x" : ligh effect graphic filename ("filename") # map x: x : map X coordinate # map y: x : map Y coordinate # opacity: x : light opacity (0-255) # pos x: x : coordinate X adjust # pos y: x : coordinate Y adjust # var: x : light opacity variation # speed: x : light variation speed # zoom: x : ligh effect zoom (100 = default size) # # <actor lantern i: o> # <event lantern i: o> # <vehicle lantern i: o> # Call a lantern on the target character, lanterns are effets that # lights the front of the character # i : actor index, event id or (0: boat, 1: ship, 2: airship) # o : light opacity (0-255) # #------------------------------------------------------------------------------ # Comment boxes note tags: # Tags to be used on events Comment boxes. They're different from the # comment call, they're called always the even refresh. # # <custom light> # settings # </custom light> # Create a custom light effect on actor, event or vehicle, add the following # values to the settings. The name must be added, other values # are optional. # name: "x" : ligh effect graphic filename ("filename") # opacity: x : light opacity (0-255) # pos x: x : coordinate X adjust # pos y: x : coordinate Y adjust # var: x : light opacity variation # speed: x : light variation speed # zoom: x : ligh effect zoom (100 = default size) # # <simple light: o> # <simple lamp: o> # <simple torch: o> # <simple window 1: o> # <simple window 2: o> # Simple light shortcuts # o : new opacity (0-255) # # <flash light: o> # <flash lamp: o> # <flash torch: o> # <flash window 1: o> # <flash window 2: o> # Flashing light shortcuts # o : new opacity (0-255) # # <lantern: o> # Lanterns shortcut # o : new opacity (0-255) # #------------------------------------------------------------------------------ # Additional instructions: # # The lights are placed on the shade, so you *must* create a shade in order # to display the lights. No shade, no lights. # # The IDs of the light effects are used as identifiers. Don't use the # same value for different light spots, if you do so, one light will # replace the other. Also the IDs are used as referece to when # removing lights and changing light opacity. # # The actor lanter use the actor position in the party, NOT the actor ID. # So the if you want a lantern for the first character, use # <actor lantern 1: o> (o = opacity) # # About the error on line 1062: this is a USER error made by BAD setup. # this happen when you assign a light effect to a event id that don't exist # at the map. So please: DON'T REPORT IT ANYMORE. # #============================================================================== #============================================================================== # ** Victor Engine #------------------------------------------------------------------------------ # Setting module for the Victor Engine #============================================================================== module Victor_Engine #-------------------------------------------------------------------------- # * required # This method checks for the existance of the basic module and other # VE scripts required for this script to work, don't edit this #-------------------------------------------------------------------------- def self.required(name, req, version, type = nil) if !$imported[:ve_basic_module] msg = "The script '%s' requires the script\n" msg += "'VE - Basic Module' v%s or higher above it to work properly\n" msg += "Go to http://victorscripts.wordpress.com/ to download this script." msgbox(sprintf(msg, self.script_name(name), version)) exit else self.required_script(name, req, version, type) end end #-------------------------------------------------------------------------- # * script_name # Get the script name base on the imported value, don't edit this #-------------------------------------------------------------------------- def self.script_name(name, ext = "VE") name = name.to_s.gsub("_", " ").upcase.split name.collect! {|char| char == ext ? "#{char} -" : char.capitalize } name.join(" ") end end $imported ||= {} $imported[:ve_light_effects] = 1.11 Victor_Engine.required(:ve_light_effects, :ve_basic_module, 1.27, :above) Victor_Engine.required(:ve_light_effects, :ve_map_battle, 1.00, :bellow) #============================================================================== # ** Cache #------------------------------------------------------------------------------ # This module loads each of graphics, creates a Bitmap object, and retains it. # To speed up load times and conserve memory, this module holds the created # Bitmap object in the internal hash, allowing the program to return # preexisting objects when the same bitmap is requested again. #============================================================================== module Cache #-------------------------------------------------------------------------- # * New method: lights #-------------------------------------------------------------------------- def self.lights(filename) self.load_bitmap('Graphics/Lights/', filename) end end #============================================================================== # ** Game_Screen #------------------------------------------------------------------------------ # This class handles screen maintenance data, such as change in color tone, # flashes, etc. It's used within the Game_Map and Game_Troop classes. #============================================================================== class Game_Screen #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :lights attr_reader :shade attr_accessor :remove_light #-------------------------------------------------------------------------- # * Alias method: clear #-------------------------------------------------------------------------- alias :clear_ve_light_effects :clear def clear clear_ve_light_effects clear_lights end #-------------------------------------------------------------------------- # * New method: clear_lights #-------------------------------------------------------------------------- def clear_lights @lights = {} @remove_light = [] @shade = Game_ShadeEffect.new end #-------------------------------------------------------------------------- # * New method: lights #-------------------------------------------------------------------------- def lights @lights ||= {} end #-------------------------------------------------------------------------- # * New method: remove_light #-------------------------------------------------------------------------- def remove_light @remove_light ||= [] end #-------------------------------------------------------------------------- # * New method: shade #-------------------------------------------------------------------------- def shade @shade ||= Game_ShadeEffect.new end end #============================================================================== # ** Game_Map #------------------------------------------------------------------------------ # This class handles maps. It includes scrolling and passage determination # functions. The instance of this class is referenced by $game_map. #============================================================================== class Game_Map #-------------------------------------------------------------------------- # * Alias method: setup #-------------------------------------------------------------------------- alias :setup_ve_light_effects :setup def setup(map_id) setup_ve_light_effects(map_id) setup_lights_effect end #-------------------------------------------------------------------------- # * New method: setup_lights_effect #-------------------------------------------------------------------------- def setup_lights_effect setup_map_shade(note) setup_map_lights(:actor, note) setup_map_lights(:event, note) setup_map_lights(:vehicle, note) setup_map_lights(:map, note) setup_map_lantern(:actor, note) setup_map_lantern(:event, note) setup_map_lantern(:vehicle, note) end #-------------------------------------------------------------------------- # * New method: setup_map_shade #-------------------------------------------------------------------------- def setup_map_shade(text) if text =~ get_all_values("CREATE SHADE") info = $1.dup shade = @screen.shade shade.show shade.opacity = info =~ /OPACITY: (\d+)/i ? $1.to_i : 192 shade.blend = info =~ /BLEND: (\d+)/i ? $1.to_i : 2 red = info =~ /RED: (\d+)/i ? $1.to_i : 0 green = info =~ /GREEN: (\d+)/i ? $1.to_i : 0 blue = info =~ /BLUE: (\d+)/i ? $1.to_i : 0 shade.set_color(red, green, blue) end end #-------------------------------------------------------------------------- # * New method: setup_map_lights #-------------------------------------------------------------------------- def setup_map_lights(type, text) value = get_regexp_value(type) text.scan(get_all_values("#{value} LIGHT")) do light = setup_light($1.dup, type) @screen.lights[light.id] = light if light.id end end #-------------------------------------------------------------------------- # * New method: setup_map_lantern #-------------------------------------------------------------------------- def setup_map_lantern(type, text) value = get_regexp_value(type) regexp = /<#{value} LANTERN (\d+): (\d+)>/i text.scan(regexp) do |index, opacity| target = get_font(type, index.to_i) next unless target target.lantern = opacity.to_i target.update_lantern end end #-------------------------------------------------------------------------- # * New method: get_regexp_value #-------------------------------------------------------------------------- def get_regexp_value(type) case type when :actor then "ACTOR" when :event then "EVENT" when :vehicle then "VEHICLE" when :map then "MAP" end end #-------------------------------------------------------------------------- # * New method: setup_light #-------------------------------------------------------------------------- def setup_light(info, type) light = Game_LightEffect.new light.name = info =~ /NAME: #{get_filename}/i ? $1.dup : "" light.id = info =~ /ID: (\w+)/i ? $1.to_s : 0 light.id = info =~ /ID: (\d+)/i ? $1.to_i : light.id light.x = info =~ /POS X: ([+-]?\d+)/i ? $1.to_i : 0 light.y = info =~ /POS Y: ([+-]?\d+)/i ? $1.to_i : 0 light.speed = info =~ /SPEED: (\d+)/i ? $1.to_i : 0 light.zoom = info =~ /ZOOM: (\d+)/i ? $1.to_f : 100.0 light.opacity = info =~ /OPACITY: (\d+)/i ? $1.to_i : 192 light.variance = info =~ /VAR: (\d+)/i ? $1.to_i : 0 if type == :map map_x = info =~ /MAP X: (\d+)/i ? $1.to_i : 0 map_y = info =~ /MAP Y: (\d+)/i ? $1.to_i : 0 light.info = {x: map_x, y: map_y} else index = info =~ /INDEX: (\d+)/i ? $1.to_i : 0 light.info = {type => index} end light end #-------------------------------------------------------------------------- # * New method: set_light #-------------------------------------------------------------------------- def set_light(id, name, info, op = 0, x = 0, y = 0, v = 0, s = 0, z = 100) light = Game_LightEffect.new light.id = id light.name = name light.info = info light.opacity = op.to_i light.x = x.to_i light.y = y.to_i light.variance = v.to_i light.speed = s.to_i light.zoom = z.to_f light end #-------------------------------------------------------------------------- # * New method: get_font #-------------------------------------------------------------------------- def get_font(type, i) case type when :actor then actors[i - 1] when :event then events[i] when :vehicle then vehicles[i] end end end #============================================================================== # ** Game_CharacterBase #------------------------------------------------------------------------------ # This class deals with characters. Common to all characters, stores basic # data, such as coordinates and graphics. It's used as a superclass of the # Game_Character class. #============================================================================== class Game_CharacterBase #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :lantern #-------------------------------------------------------------------------- # * Alias method: init_public_members #-------------------------------------------------------------------------- alias :init_public_members_ve_light_effects :init_public_members def init_public_members init_public_members_ve_light_effects @lantern = 0 end #-------------------------------------------------------------------------- # * Alias method: update #-------------------------------------------------------------------------- alias :update_ve_light_effects :update def update update_ve_light_effects update_lantern end #-------------------------------------------------------------------------- # * New method: update_lantern #-------------------------------------------------------------------------- def update_lantern(forced = false) diag = $imported[:ve_diagonal_move] && diagonal? if @lantern != 0 && ((!diag && @lantern_direction != @direction) || (diag && @lantern_direction != @diagonal) || forced) @lantern_direction = (diag ? @diagonal : @direction) light = setup_lantern $game_map.screen.lights[light.id] = light elsif @lantern == 0 && @lantern_direction id = event? ? "EL#{@id}" : "AL#{@id}" $game_map.screen.remove_light.push(id) if $game_map.screen.remove_light @lantern_direction = nil end end #-------------------------------------------------------------------------- # * New method: setup_lantern #-------------------------------------------------------------------------- def setup_lantern id = event? ? "EL#{@id}" : "AL#{@id}" type = event? ? :event : :actor case @lantern_direction when 1 name = 'lantern_downleft' value = [id, name, {type => @id}, @lantern, -48, 48] when 3 name = 'lantern_downright' value = [id, name, {type => @id}, @lantern, 48, 48] when 2 name = 'lantern_down' value = [id, name, {type => @id}, @lantern, 0, 64] when 4 name = 'lantern_left' value = [id, name, {type => @id}, @lantern, -64, 0] when 6 name = 'lantern_right' value = [id, name, {type => @id}, @lantern, 64, 0] when 7 name = 'lantern_upleft' value = [id, name, {type => @id}, @lantern, -48, -48] when 8 name = 'lantern_up' value = [id, name, {type => @id}, @lantern, 0, -64,] when 9 name = 'lantern_upright' value = [id, name, {type => @id}, @lantern, 48, -48] end $game_map.set_light(*value) end end #============================================================================== # ** Game_Event #------------------------------------------------------------------------------ # This class deals with events. It handles functions including event page # switching via condition determinants, and running parallel process events. # It's used within the Game_Map class. #============================================================================== class Game_Event < Game_Character #-------------------------------------------------------------------------- # * Alias method: clear_starting_flag #-------------------------------------------------------------------------- alias :clear_starting_flag_ve_light_effects :clear_starting_flag def clear_starting_flag clear_starting_flag_ve_light_effects @lantern = 0 $game_map.screen.remove_light.push("EV#{@id}") refresh_lights if @page end #-------------------------------------------------------------------------- # * New method: refresh_lights #-------------------------------------------------------------------------- def refresh_lights case note when /<SIMPLE LIGHT: (\d+)?>/i set_light("EV#{@id}", "light", $1 ? $1 : 255) when /<SIMPLE LAMP: (\d+)?>/i set_light("EV#{@id}", "lamp", $1 ? $1 : 255) when /<SIMPLE TORCH: (\d+)?>/i set_light("EV#{@id}", "torch", $1) when /<SIMPLE WINDOW (\d+): (\d+)?>/i adj = $1 == "1" ? 0 : 14 set_light("EV#{@id}", "window", $2 ? $2 : 255, 0, 0, 0, adj) when /<FLASH LIGHT: (\d+)?>/i set_light("EV#{@id}", "light", $1 ? $1 : 255, 30, 1) when /<FLASH LAMP: (\d+)?>/i set_light("EV#{@id}", "lamp", $1 ? $1 : 255, 30, 1) when /<FLASH TORCH: (\d+)?>/i set_light("EV#{@id}", "torch", $1 ? $1 : 255, 30, 1) when /<FLASH WINDOW (\d+): (\d+)?>/i adj = $1 == "1" ? 0 : 14 set_light("EV#{@id}", "window", $2 ? $2 : 255, 30, 1, 0, adj) when get_all_values("CUSTOM LIGHT") info = $1.dup n = info =~ /NAME: #{get_filename}/i ? $1.dup : "" x = info =~ /POS X: ([+-]?\d+)/i ? $1.to_i : 0 y = info =~ /POS Y: ([+-]?\d+)/i ? $1.to_i : 0 s = info =~ /SPEED: (\d+)/i ? $1.to_i : 0 z = info =~ /ZOOM: (\d+)/i ? $1.to_f : 100.0 o = info =~ /OPACITY: (\d+)/i ? $1.to_i : 192 v = info =~ /VAR: (\d+)/i ? $1.to_i : 0 set_light("EV#{@id}", n, o, v, s, x, y, z) when /<LANTERN(?:: (\d+))?>/i @lantern = ($1 ? $1.to_i : 255) end end #-------------------------------------------------------------------------- # * New method: set_light #-------------------------------------------------------------------------- def set_light(id, name, op = 255, v = 0, s = 0, x = 0, y = 0, z = 100) value = [id, name, {:event => @id}, op, x, y, v, s, z].compact $game_map.screen.lights[id] = $game_map.set_light(*value) $game_map.screen.remove_light.delete(id) end end #============================================================================== # ** Game_Interpreter #------------------------------------------------------------------------------ # An interpreter for executing event commands. This class is used within the # Game_Map, Game_Troop, and Game_Event classes. #============================================================================== class Game_Interpreter #-------------------------------------------------------------------------- # * Alias method: comment_call #-------------------------------------------------------------------------- alias :comment_call_ve_light_effects :comment_call def comment_call call_create_lights call_change_shade_opacity call_change_shade_tone call_change_light_opacity call_remove_light comment_call_ve_light_effects end #-------------------------------------------------------------------------- # * New method: create_lights #-------------------------------------------------------------------------- def call_create_lights $game_map.setup_map_shade(note) $game_map.setup_map_lights(:actor, note) $game_map.setup_map_lights(:event, note) $game_map.setup_map_lights(:vehicle, note) $game_map.setup_map_lights(:map, note) $game_map.setup_map_lantern(:actor, note) $game_map.setup_map_lantern(:event, note) $game_map.setup_map_lantern(:vehicle, note) end #-------------------------------------------------------------------------- # * New method: call_change_shade_opacity #-------------------------------------------------------------------------- def call_change_shade_opacity return if !$game_map.screen.shade.visible note.scan(/<SHADE OPACITY: ((?:\d+,? *){2})>/i) do if $1 =~ /(\d+) *,? *(\d+)?/i duration = $2 ? $2.to_i : 0 $game_map.screen.shade.change_opacity($1.to_i, duration) end end end #-------------------------------------------------------------------------- # * New method: call_change_shade_tone #-------------------------------------------------------------------------- def call_change_shade_tone return if !$game_map.screen.shade.visible note.scan(/<SHADE TONE: ((?:\d+,? *){4})>/i) do if $1 =~ /(\d+) *, *(\d+) *, *(\d+) *, *(\d+)/i $game_map.screen.shade.change_color($1.to_i, $2.to_i, $3.to_i, $4.to_i) end end end #-------------------------------------------------------------------------- # * New method: call_change_light_opacity #-------------------------------------------------------------------------- def call_change_light_opacity return if !$game_map.screen.shade.visible note.scan(/<LIGHT OPACITY (\d+): ((?:\d+,? *){2})>/i) do light = $game_map.screen.lights[$1.to_i] if light && $2 =~ /(\d+) *,? *(\d+)?/i duration = $2 ? $2.to_i : 0 light.change_opacity($1.to_i, duration) end end end #-------------------------------------------------------------------------- # * New method: call_remove_light #-------------------------------------------------------------------------- def call_remove_light note.scan(/<REMOVE LIGHT: (\d+)>/i) do $game_map.screen.remove_light.push($1.to_i) end end end #============================================================================== # ** Spriteset_Map #------------------------------------------------------------------------------ # This class brings together map screen sprites, tilemaps, etc. It's used # within the Scene_Map class. #============================================================================== class Spriteset_Map #-------------------------------------------------------------------------- # * Alias method: initialize #-------------------------------------------------------------------------- alias :initialize_ve_light_effects :initialize def initialize initialize_ve_light_effects 2.times { update_light(true) } end #-------------------------------------------------------------------------- # * Alias method: update #-------------------------------------------------------------------------- alias :update_ve_light_effects :update def update update_ve_light_effects update_light end #-------------------------------------------------------------------------- # * Alias method: dispose #-------------------------------------------------------------------------- alias :dispose_ve_light_effects :dispose def dispose dispose_ve_light_effects dispose_light unless SceneManager.scene_is?(Scene_Map) end #-------------------------------------------------------------------------- # * New method: update_light #-------------------------------------------------------------------------- def update_light(forced = false) return unless Graphics.frame_count % 2 == 0 || forced update_shade update_effects end #-------------------------------------------------------------------------- # * New method: dispose_light #-------------------------------------------------------------------------- def dispose_light if @light_effect @light_effect.dispose @light_effect = nil @screen_shade = nil end end #-------------------------------------------------------------------------- # * New method: update_shade #-------------------------------------------------------------------------- def update_shade if !@light_effect && $game_map.screen.shade.visible refresh_lights elsif $game_map.screen.shade.visible && @light_effect @light_effect.update elsif @light_effect && !$game_map.screen.shade.visible dispose_light end end #-------------------------------------------------------------------------- # * New method: refresh_lights #-------------------------------------------------------------------------- def refresh_lights @light_effect.dispose if @light_effect @screen_shade = $game_map.screen.shade @light_effect = Sprite_Light.new(@screen_shade, @viewport2) $game_map.event_list.each {|event| event.refresh_lights } @light_effect.update end #-------------------------------------------------------------------------- # * New method: update_effects #-------------------------------------------------------------------------- def update_effects return if !@light_effect || $game_map.screen.lights.empty? $game_map.screen.lights.keys.each {|key| create_light(key) } $game_map.screen.remove_light.clear end #-------------------------------------------------------------------------- # * New method: create_light #-------------------------------------------------------------------------- def create_light(key) effect = @light_effect.lights[key] return if remove_light(key) return if effect && effect.light == $game_map.screen.lights[key] @light_effect.create_light($game_map.screen.lights[key]) end #-------------------------------------------------------------------------- # * New method: remove_light #-------------------------------------------------------------------------- def remove_light(key) return false if !$game_map.screen.remove_light.include?(key) @light_effect.remove_light(key) $game_map.screen.lights.delete(key) return true end end #============================================================================== # ** Scene_Map #------------------------------------------------------------------------------ # This class performs the map screen processing. #============================================================================== class Scene_Map #-------------------------------------------------------------------------- # * Alias method: pre_transfer #-------------------------------------------------------------------------- alias :pre_transfer_ve_light_effects :pre_transfer def pre_transfer pre_transfer_ve_light_effects if $game_player.new_map_id != $game_map.map_id @spriteset.dispose_light $game_map.screen.clear_lights end end #-------------------------------------------------------------------------- # * Alias method: post_transfer #-------------------------------------------------------------------------- alias :post_transfer_ve_light_effects :post_transfer def post_transfer $game_map.actors.each {|actor| actor.update_lantern(true) } post_transfer_ve_light_effects end end #============================================================================== # ** Game_ShadeEffect #------------------------------------------------------------------------------ # This class handles the shade layer data #============================================================================== class Game_ShadeEffect #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :visible attr_reader :color attr_accessor :blend attr_accessor :opacity #-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize init_opacity init_color end #-------------------------------------------------------------------------- # * init_opacity #-------------------------------------------------------------------------- def init_opacity @visible = false @opacity = 0 @opacity_target = 0 @opacity_duration = 0 end #-------------------------------------------------------------------------- # * init_color #-------------------------------------------------------------------------- def init_color @blend = 0 @color = Color.new(0, 0, 0, 0) @color_duration = 0 @color_target = Color.new(0, 0, 0, 0) end #-------------------------------------------------------------------------- # * show #-------------------------------------------------------------------------- def show @visible = true end #-------------------------------------------------------------------------- # * hide #-------------------------------------------------------------------------- def hide @visible = false end #-------------------------------------------------------------------------- # * set_color #-------------------------------------------------------------------------- def set_color(r = 0, g = 0, b = 0) @color = get_colors(r, g, b) @color_target = @color.clone end #-------------------------------------------------------------------------- # * change_opacity #-------------------------------------------------------------------------- def change_opacity(op, d) @opacity_target = op @opacity_duration = [d, 0].max @opacity = @opacity_target if @opacity_duration == 0 end #-------------------------------------------------------------------------- # * change_color #-------------------------------------------------------------------------- def change_color(r, g, b, d) @color_target = get_colors(r, g, b) @color_duration = [d, 0].max @color = @color_target.clone if @color_duration == 0 end #-------------------------------------------------------------------------- # * get_colors #-------------------------------------------------------------------------- def get_colors(r, g, b) color = Color.new(255 - r, 255 - g, 255 - b, 255) if @blend == 2 color = Color.new(r, g, b, 255) if @blend != 2 color end #-------------------------------------------------------------------------- # * update #-------------------------------------------------------------------------- def update update_opacity update_color end #-------------------------------------------------------------------------- # * update_opacity #-------------------------------------------------------------------------- def update_opacity return if @opacity_duration == 0 d = @opacity_duration @opacity = (@opacity * (d - 1) + @opacity_target) / d @opacity_duration -= 1 end #-------------------------------------------------------------------------- # * update_color #-------------------------------------------------------------------------- def update_color return if @color_duration == 0 d = @color_duration @color.red = (@color.red * (d - 1) + @color_target.red) / d @color.green = (@color.green * (d - 1) + @color_target.green) / d @color.blue = (@color.blue * (d - 1) + @color_target.blue) / d @color_duration -= 1 end end #============================================================================== # ** Game_LightEffect #------------------------------------------------------------------------------ # This class handles the light sprite data #============================================================================== class Game_LightEffect #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :id attr_accessor :name attr_accessor :info attr_accessor :opacity attr_accessor :x attr_accessor :y attr_accessor :variance attr_accessor :speed attr_accessor :zoom attr_accessor :opacity_target attr_accessor :opacity_duration #-------------------------------------------------------------------------- # * change_opacity #-------------------------------------------------------------------------- def change_opacity(op, d) @opacity_target = op @opacity_duration = [d, 0].max @opacity = @opacity_target if @opacity_duration == 0 end end #============================================================================== # ** Game_LightBitmap #------------------------------------------------------------------------------ # This class handles the bitmpas of each light spot #============================================================================== class Game_LightBitmap #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :light attr_reader :bitmap attr_reader :opacity attr_reader :x attr_reader :y #-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize(light) @light = light init_basic update end #-------------------------------------------------------------------------- # * init_basic #-------------------------------------------------------------------------- def init_basic @bitmap = Cache.lights(@light.name) @target = set_target @opacity = @light.opacity @speed = @light.speed @variance = 0.0 @light.opacity_duration = 0 @light.opacity_target = 0 end #-------------------------------------------------------------------------- # * width #-------------------------------------------------------------------------- def width @bitmap.width * @light.zoom / 100.0 end #-------------------------------------------------------------------------- # * height #-------------------------------------------------------------------------- def height @bitmap.height * @light.zoom / 100.0 end #-------------------------------------------------------------------------- # * update #-------------------------------------------------------------------------- def update update_position update_opacity update_variance end #-------------------------------------------------------------------------- # * update_position #-------------------------------------------------------------------------- def update_position @target.is_a?(Game_Character) ? character_position : map_position end #-------------------------------------------------------------------------- # * character_position #-------------------------------------------------------------------------- def character_position @x = $game_map.adjust_x(@target.real_x) * 32 - width / 2 + @light.x + 16 @y = $game_map.adjust_y(@target.real_y) * 32 - height / 2 + @light.y + 16 end #-------------------------------------------------------------------------- # * map_position #-------------------------------------------------------------------------- def map_position @x = $game_map.adjust_x(@target[:x]) * 32 - width / 2 + @light.x + 16 @y = $game_map.adjust_y(@target[:y]) * 32 - height / 2 + @light.y + 16 end #-------------------------------------------------------------------------- # * change_opacity #-------------------------------------------------------------------------- def change_opacity(op, d) @light.opacity_target = op @light.opacity_duration = [d, 0].max @light.opacity = @light.opacity_target if @light.opacity_duration == 0 end #-------------------------------------------------------------------------- # * update_opacity #-------------------------------------------------------------------------- def update_opacity return if @light.opacity_duration == 0 d = @light.opacity_duration @light.opacity = (@light.opacity * (d - 1) + @light.opacity_target) / d @light.opacity_duration -= 1 end #-------------------------------------------------------------------------- # * update_variance #-------------------------------------------------------------------------- def update_variance @variance += @speed @speed *= -1 if @variance.abs > @light.variance.abs @opacity = [[@light.opacity + @variance, 0].max, 255].min end #-------------------------------------------------------------------------- # * dispose #-------------------------------------------------------------------------- def dispose @bitmap.dispose end #-------------------------------------------------------------------------- # * set_target #-------------------------------------------------------------------------- def set_target if @light.info.keys.include?(:actor) target = $game_map.actors[@light.info[:actor] - 1] elsif @light.info.keys.include?(:event) target = $game_map.events[@light.info[:event]] elsif @light.info.keys.include?(:vehicle) target = $game_map.vehicles[@light.info[:vehicle]] else target = @light.info end target end end #============================================================================== # ** Sprite_Light #------------------------------------------------------------------------------ # This sprite is used to display the light effects #============================================================================== class Sprite_Light < Sprite_Base #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :lights #-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize(shade, viewport) super(viewport) @shade = shade self.bitmap = Bitmap.new(Graphics.width, Graphics.height) self.blend_type = @shade.blend self.opacity = @shade.opacity self.z = 100 @lights = {} end #-------------------------------------------------------------------------- # * map_x #-------------------------------------------------------------------------- def map_x $game_map.adjust_x($game_map.display_x) end #-------------------------------------------------------------------------- # * map_y #-------------------------------------------------------------------------- def map_y $game_map.adjust_y($game_map.display_y) end #-------------------------------------------------------------------------- # * update #-------------------------------------------------------------------------- def update super self.ox = map_x self.oy = map_y update_opacity update_lights end #-------------------------------------------------------------------------- # * update lights #-------------------------------------------------------------------------- def update_lights rect = Rect.new(map_x, map_y, Graphics.width, Graphics.height) self.bitmap.fill_rect(rect, color) draw_light_effects end #-------------------------------------------------------------------------- # * color #-------------------------------------------------------------------------- def color @shade.color end #-------------------------------------------------------------------------- # * draw_light_effects #-------------------------------------------------------------------------- def draw_light_effects @lights.values.each do |light| light.update next if !on_screen?(light) draw_light(light) end end #-------------------------------------------------------------------------- # * on_sceen? #-------------------------------------------------------------------------- def on_screen?(light) ax1 = light.x ay1 = light.y ax2 = light.x + light.width ay2 = light.y + light.height bx1 = map_x by1 = map_y bx2 = map_x + Graphics.width by2 = map_y + Graphics.height check1 = ax1.between?(bx1, bx2) || ax2.between?(bx1, bx2) || ax1 < bx1 && ax2 > bx2 check2 = ay1.between?(by1, by2) || ay2.between?(by1, by2) || ay1 < by1 && ay2 > by2 check1 && check2 end #-------------------------------------------------------------------------- # * draw_light #-------------------------------------------------------------------------- def draw_light(light) img = light.bitmap rect = Rect.new(light.x, light.y, light.width, light.height) self.bitmap.stretch_blt(rect, img, img.rect, light.opacity) end #-------------------------------------------------------------------------- # * update_opacity #-------------------------------------------------------------------------- def update_opacity @shade.update self.opacity = @shade.opacity self.blend_type = @shade.blend end #-------------------------------------------------------------------------- # * create_light #-------------------------------------------------------------------------- def create_light(light) remove_light(light.id) @lights[light.id] = Game_LightBitmap.new(light) end #-------------------------------------------------------------------------- # * remove_light #-------------------------------------------------------------------------- def remove_light(id) @lights.delete(id) if @lights[id] end #-------------------------------------------------------------------------- # * dispose #-------------------------------------------------------------------------- def dispose super @lights.values.each {|light| light.dispose unless light.bitmap.disposed? } end end