#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=: # XP Map Loader & Multi Layer # Version: 2.05 # Author : LiTTleDRAgo #:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=: ($imported ||= {})[:drg_xp_map_loader] = 2.05 #:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=: # # Introduction : # # Version 2 from XP Map Loader (Merged with multi layer script) # # Issue : # # XP Map Loader : # - You cannot use Drago - Custom Resolution II's zoom feature. # - You cannot join XP maps with VXA maps, but you can join VXA # maps with XP maps. # - Only for VXAce # # Multi Layer : # - More Layer = More Lag # #============================================================================== module LiTTleDRAgo # Condition for layer to be joined MultiLayerCond = proc do |i| condition = { 1 => $game_switches[1], # This means this layer will be joined when # switch 1 is ON and will disappear when OFF 2 => $game_variables[1] == 200, } condition[i] # Do not remove this line end end core = "This script needs Drago - Core Engine ver 1.44 or above" implemented = "%1$s has already implemented, Please remove the %1$s script" ($imported[:drg_core_engine] || 0) >= 1.44 || raise(core) ($imported[:drg_multi_layer])&& raise(sprintf(implemented,"Multi Layer")) #============================================================================== # ** 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 #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_sec_accessor :panorama_name, :fog_name, 'String.new' attr_sec_accessor :panorama_hue, :fog_hue, :fog_zoom, 1 attr_sec_accessor :fog_opacity, :fog_blend_type, 0 attr_sec_accessor :fog_sx, :fog_sy, :fog_ox, :fog_oy, 0 attr_sec_accessor :fog_tone, :fog_tone_target, 'Tone.new(0,0,0)' attr_sec_accessor :multi_layer_condition_true, 'Array.new' attr_sec_accessor :multi_layer_condition_false, 'Array.new' attr_sec_reader :xpmap, 'Array.new' attr_sec_reader :vxamap, 'Array.new' #-------------------------------------------------------------------------- # * Class Variable #-------------------------------------------------------------------------- tileset = "Data/Tilesets.rxdata" @@tileset_xp = File.exist?(tileset) ? load_data(tileset) : nil @@rpgmakerxp = LiTTleDRAgo::XP #-------------------------------------------------------------------------- # * Define Method #-------------------------------------------------------------------------- unless @@rpgmakerxp define_method(:zoom_x) { 1 } define_method(:zoom_y) { 1 } end #-------------------------------------------------------------------------- # * Undefine Method #-------------------------------------------------------------------------- if !@@rpgmakerxp && method_defined?(:zoom) undef :zoom, :zoom_in, :zoom_out, :zoom_x=, :zoom_y=, :start_zoom end #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias_sec_method :xpmap_loader_setup, :setup alias_sec_method :xpmap_loader_update, :update alias_sec_method :layered_tiles_flag_vxlayer, :layered_tiles_flag? #-------------------------------------------------------------------------- # * Aliased Method : setup #-------------------------------------------------------------------------- def setup(*args) xpmap_loader_setup(*args) setup_map_xp setup_map_layer end #-------------------------------------------------------------------------- # * New Method : setup_map_xp #-------------------------------------------------------------------------- def setup_map_xp reset_map_xp map = sprintf("Map%03d",@map_id) b = "The dimension on %1$s.rvdata2 %2$s and %1$s.rxdata %3$s is not same" return unless @@tileset_xp && File.exist?("Data/"+map+".rxdata") return if @@rpgmakerxp return if self.xpmap.detect {|xp| xp && xp[:map_id] == @map_id } _xp = load_map_data(@map_id,:rxdata) _sz = [@map,_xp].flatten.map {|m| [m.width,m.height]}.uniq fail( sprintf( b, map, *_sz.map {|s| s.inspect})) if _sz.size > 1 self.xpmap[0] = {} self.xpmap[0][:map_id] = @map_id self.xpmap[0][:map] = _xp self.xpmap[0][:tileset_id] = _xp.tileset_id _xp = @@tileset_xp[_xp.tileset_id] self.xpmap[0][:tileset_name] = _xp.tileset_name self.xpmap[0][:autotile_names] = _xp.autotile_names self.xpmap[0][:passages] = _xp.passages self.xpmap[0][:priorities] = _xp.priorities self.xpmap[0][:terrain_tags] = _xp.terrain_tags @panorama_name = _xp.panorama_name @panorama_hue = _xp.panorama_hue @fog_name = _xp.fog_name @fog_hue = _xp.fog_hue @fog_opacity = _xp.fog_opacity @fog_blend_type = _xp.fog_blend_type @fog_zoom = _xp.fog_zoom @fog_sx = _xp.fog_sx @fog_sy = _xp.fog_sy end #-------------------------------------------------------------------------- # * Aliased Method : update #-------------------------------------------------------------------------- def update(*args) xpmap_loader_update(*args) update_fog unless @@rpgmakerxp update_layer_condition end #-------------------------------------------------------------------------- # * New Method : reset_map_xp #-------------------------------------------------------------------------- def reset_map_xp self.xpmap.clear self.vxamap.clear self.multi_layer_condition_true.clear self.multi_layer_condition_false.clear @mapinfo = nil self.clear_panorama unless @@rpgmakerxp self.clear_fog unless @@rpgmakerxp end #-------------------------------------------------------------------------- # * New Method : setup_map_layer #-------------------------------------------------------------------------- def setup_map_layer layered = false self.child_ids.each_with_index do |submap_id,index| next if self.vxamap.detect {|vxa| vxa && vxa[:map_id] == submap_id } next if self.xpmap.detect {|xp| xp && xp[:map_id] == submap_id } next unless (map_info = mapInfo[submap_id]).not.nil? next unless (map_info.parent_id == map_id) join = map_info.name[/\[\s*join\s*\]/] if map_info.name[/\[\s*join:\s*([-]?\d+)\s*\]/] id = $1.to_i cond = LiTTleDRAgo::MultiLayerCond.call(id) if !cond && multi_layer_condition_true.not.include?(id) @multi_layer_condition_true << id end if cond && multi_layer_condition_false.not.include?(id) @multi_layer_condition_false << id end join ||= cond end next unless join map = sprintf("Map%03d",submap_id) org = sprintf("Map%03d",map_id) notsame = "The dimension of Parent map and Child map must be same" if @@tileset_xp && File.exist?("Data/"+map+".rxdata") _xp = load_map_data(submap_id,:rxdata) _sz = [@map,_xp].flatten.map {|m| [m.width,m.height]}.uniq _sz.size > 1 && fail(notsame) self.xpmap[index+1] = {} self.xpmap[index+1][:map_id] = submap_id self.xpmap[index+1][:map] = _xp self.xpmap[index+1][:tileset_id] = _xp.tileset_id _xp = @@tileset_xp[_xp.tileset_id] self.xpmap[index+1][:tileset_name] = _xp.tileset_name self.xpmap[index+1][:autotile_names] = _xp.autotile_names self.xpmap[index+1][:passages] = _xp.passages self.xpmap[index+1][:priorities] = _xp.priorities self.xpmap[index+1][:terrain_tags] = _xp.terrain_tags elsif File.exist?("Data/"+map+".rvdata2") _vxa = load_map_data(submap_id,:rvdata2) _sz = [@map,_vxa].flatten.map {|m| [m.width,m.height]}.uniq _sz.size > 1 && fail(notsame) self.vxamap[index] = {} self.vxamap[index][:map_id] = submap_id self.vxamap[index][:map] = _vxa self.vxamap[index][:tileset_id] = _vxa.tileset_id tileset = $data_tilesets[_vxa.tileset_id] self.vxamap[index][:tileset] = tileset end layered = _xp || _vxa end spriteset.create_multi_layer if spriteset end #-------------------------------------------------------------------------- # * New Method : update_layer_condition #-------------------------------------------------------------------------- def update_layer_condition meth = LiTTleDRAgo::MultiLayerCond condition = multi_layer_condition_true.any? {|id| meth.call(id) } || multi_layer_condition_false.any? {|id| meth.not.call(id)} condition && [setup_map_xp, setup_map_layer] end #-------------------------------------------------------------------------- # * New Method : reset_fog_variable #-------------------------------------------------------------------------- def reset_fog_variable @fog_ox = @fog_oy = @fog_tone = @fog_tone_target = nil @fog_tone_duration = @fog_opacity_duration = @fog_opacity_target = 0 end #-------------------------------------------------------------------------- # * New Method : start_fog_tone_change #-------------------------------------------------------------------------- unless method_defined?(:start_fog_tone_change) def start_fog_tone_change(tone, duration) @fog_tone_target = tone.clone @fog_tone_duration = duration if @fog_tone_duration == 0 @fog_tone = @fog_tone_target.clone end end end #-------------------------------------------------------------------------- # * New Method : start_fog_opacity_chang #-------------------------------------------------------------------------- unless method_defined?(:start_fog_opacity_change) def start_fog_opacity_change(opacity, duration) @fog_opacity_target = opacity * 1.0 @fog_opacity_duration = duration if @fog_opacity_duration == 0 @fog_opacity = @fog_opacity_target end end end #-------------------------------------------------------------------------- # * New Method : change_panorama #-------------------------------------------------------------------------- def change_panorama(panorama_name = '',panorama_hue = 0) @panorama_name = panorama_name @panorama_hue = panorama_hue end #-------------------------------------------------------------------------- # * New Method : clear_panorama #-------------------------------------------------------------------------- def clear_panorama(*args) change_panorama end #-------------------------------------------------------------------------- # * New Method : change_fog #-------------------------------------------------------------------------- def change_fog(name='',hue=0,opac = 60, blend = 0,zoom = 1.0,sx = 0,sy = 0) @fog_name = name @fog_hue = hue @fog_opacity = opac @fog_blend_type = blend @fog_zoom = zoom @fog_sx = sx @fog_sy = sy end #-------------------------------------------------------------------------- # * New Method : clear_fog #-------------------------------------------------------------------------- def clear_fog(*args) change_fog end #-------------------------------------------------------------------------- # * New Method : update_fog #-------------------------------------------------------------------------- unless method_defined?(:update_fog) def update_fog @fog_ox = fog_ox - fog_sx / 8.0 @fog_oy = fog_oy - fog_sy / 8.0 if (@fog_tone_duration ||= 0) >= 1 d = (@fog_tone_duration ||= 0) target = fog_tone_target fog_tone.red = (fog_tone.red * (d - 1) + target.red) / d fog_tone.green = (fog_tone.green * (d - 1) + target.green) / d fog_tone.blue = (fog_tone.blue * (d - 1) + target.blue) / d fog_tone.gray = (fog_tone.gray * (d - 1) + target.gray) / d @fog_tone_duration -= 1 end if (@fog_opacity_duration ||= 0) >= 1 d = (@fog_opacity_duration ||= 0) @fog_opacity = (fog_opacity * (d-1) + (@fog_opacity_target||=0)) / d @fog_opacity_duration -= 1 end end end #-------------------------------------------------------------------------- # * New Method : tile_id_obj #-------------------------------------------------------------------------- def tile_id_obj(obj, x, y, z) if $game_map.respond_to?(:reverse) && $game_map.reverse && LiTTleDRAgo::XP obj.reverse_data[x, y, z] || 0 else obj.data[x, y, z] || 0 end end #-------------------------------------------------------------------------- # * New Method : collect_flag_tiles_vxa #-------------------------------------------------------------------------- def collect_flag_tiles_vxa(x,y,*flag) result = [] vxamap.compact.each do |map| result += [2, 1, 0].collect do |z| tile_id = tile_id_obj(map[:map],x, y, z) [tile_id] + flag.collect {|s| map[s].flags[tile_id]} end end return result end #-------------------------------------------------------------------------- # * New Method : collect_flag_tiles_xp #-------------------------------------------------------------------------- def collect_flag_tiles_xp(x,y,*flag) result = [] xpmap.compact.each do |map| result += [2, 1, 0].collect do |z| tile_id = tile_id_obj(map[:map],x, y, z) [tile_id] + flag.collect {|s| map[s][tile_id]} end end return result end #-------------------------------------------------------------------------- # * New Method : collect_flag_tiles_original #-------------------------------------------------------------------------- def collect_flag_tiles_original(x,y,*flag) all_tiles_rep(x, y).collect do |t_id| @@rpgmakerxp ? [t_id] + flag.collect {|map| map[t_id]} : [t_id, tileset.flags[t_id]] end end #-------------------------------------------------------------------------- # * Aliased Method : layered_tiles_flag? #-------------------------------------------------------------------------- def layered_tiles_flag?(x, y, bit) xp = collect_flag_tiles_xp(x,y,:passages) vxa = collect_flag_tiles_vxa(x,y,:tileset) original = collect_flag_tiles_original(x,y,@passages) if @@rpgmakerxp result = (xp + vxa + original).any? { |id,flag| flag & bit != 0 } else result = layered_tiles_flag_vxlayer(x, y, bit) result ||= (xp + vxa ).any? { |id,flag| flag & bit != 0 } end return result end #-------------------------------------------------------------------------- # * Overwriten Method : check_passage #-------------------------------------------------------------------------- def check_passage(x, y, bit) original = collect_flag_tiles_original(x,y,@passages) xp = collect_flag_tiles_xp(x,y,:passages) vxa = collect_flag_tiles_vxa(x,y,:tileset) ( xp + vxa + original ).each do |t_id,flag,prio| next if flag & 0x10 != 0 # [☆]: No effect on passage #return true if flag & bit == 0 # [○] : Passable return false if flag & bit != 0 # [×] : Impassable return false if flag & bit == bit # [×] : Impassable return true if prio && prio == 0 # [○] : Passable end return true#false # Impassable end #-------------------------------------------------------------------------- # * Overwriten Method : terrain_tag #-------------------------------------------------------------------------- def terrain_tag(x, y) return 0 unless valid?(x, y) original = collect_flag_tiles_original(x,y,@terrain_tags) xp = collect_flag_tiles_xp(x,y,:terrain_tags) vxa = collect_flag_tiles_vxa(x,y,:tileset).map {|t| t >> 12} (xp + vxa).each { |t_id,tag| return tag if tag > 0 } (original).each do |t_id,flag| tag = @@rpgmakerxp ? flag : flag >> 12 return tag if tag > 0 end return 0 end #-------------------------------------------------------------------------- # * Overwriten Method : passable? #-------------------------------------------------------------------------- if @@rpgmakerxp def passable?(x, y, d, s = nil) original = (event_tiles(x, y, s) + layered_tiles(x, y)).map do |t_id| [t_id, @passages[t_id], @priorities[t_id]] end xp = collect_flag_tiles_xp(x,y,:passages,:priorities) vxa = collect_flag_tiles_vxa(x,y,:tileset) bit = (1 << (d / 2 - 1)) & 0x0f (xp + vxa + original ).each do |t_id,flag,prio| next if flag & 0x10 != 0 # [☆]: No effect on passage return false if flag & bit != 0 # [×] : Impassable return false if flag & 0x0f == 0x0f # [×] : Impassable return true if prio && prio == 0 # [○] : Passable end return true # [○] : Passable end #-------------------------------------------------------------------------- # * Overwriten Method : bush? #-------------------------------------------------------------------------- def bush?(x, y) valid?(x, y) && layered_tiles_flag?(x, y, 0x40) end #-------------------------------------------------------------------------- # * Overwriten Method : counter? #-------------------------------------------------------------------------- def counter?(x, y) valid?(x, y) && layered_tiles_flag?(x, y, 0x80) end end #-------------------------------------------------------------------------- # * New Method : event_tiles #-------------------------------------------------------------------------- def event_tiles(x, y, s = nil) e = events_xy(x,y).select {|e| e.tile_id > 0 && e != s && !e.through} e.collect {|event| event.tile_id } end #-------------------------------------------------------------------------- # * Replicated Method : layered_tiles #-------------------------------------------------------------------------- unless method_defined?(:layered_tiles) def layered_tiles(x, y) [2, 1, 0].collect {|z| tile_id_obj(@map, x, y, z) } end end #-------------------------------------------------------------------------- # * Replicated Method : all_tiles_rep #-------------------------------------------------------------------------- unless method_defined?(:all_tiles_rep) def all_tiles_rep(x, y) event_tiles(x, y) + layered_tiles(x,y) end end #-------------------------------------------------------------------------- # * Replicated Method : events_xy #-------------------------------------------------------------------------- unless method_defined?(:events_xy) def events_xy(x, y) @events.values.select {|event| event.x == x && event.y == y } end end end #============================================================================== # ** RPG #------------------------------------------------------------------------------ # #============================================================================== module RPG #============================================================================ # ** Map #---------------------------------------------------------------------------- # #============================================================================ class Map attr_accessor :tileset_id attr_sec_accessor :reverse_data, 'data.reverse(true,false,false)' end #============================================================================ # ** Tileset #---------------------------------------------------------------------------- # #============================================================================ class Tileset #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_sec_accessor :tileset_name, :panorama_name, :fog_name, :battleback_name, 'String.new' attr_sec_accessor :autotile_names, '[String.new]*7' attr_sec_accessor :panorama_hue, :fog_hue, :fog_blend_type, :fog_sx, :fog_sy, 0 attr_sec_accessor :passages, :priorities, :terrain_tags, 'Table.new(384)' attr_sec_accessor :fog_zoom, 200 attr_sec_accessor :fog_opacity, 64 end end #============================================================================== # ** Spriteset_Map #------------------------------------------------------------------------------ # This class brings together map screen sprites, tilemaps, etc. It's used # within the Scene_Map class. #============================================================================== class Spriteset_Map #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_sec_reader :tilemap_layer, 'Array.new' #-------------------------------------------------------------------------- # * Class Variable #-------------------------------------------------------------------------- @@rpgmakerxp = LiTTleDRAgo::XP @@fog_opacity = @@panorama_opacity = 0 #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias_sec_method :update_multi_layer_cr, :update alias_sec_method :dispose_multi_layer_cr, :dispose alias_sec_method :reload_tilemap_multi_layer_cr, :reload_tilemap alias_method :fog_fix_initialize, :initialize #-------------------------------------------------------------------------- # * Aliased method: initialize #-------------------------------------------------------------------------- def initialize(*args) fog_fix_initialize @fog.opacity = @@fog_opacity || 0 if @fog @panorama.opacity = @@panorama_opacity || 0 if @panorama end #-------------------------------------------------------------------------- # * New Method : create_multi_layer #-------------------------------------------------------------------------- def create_multi_layer dispose_multi_layer @xpmap_size = $game_map.xpmap.size @vxamap_size = $game_map.vxamap.size $game_map.vxamap.compact.each do |data| next if @@rpgmakerxp tilemap_layer[(i = tilemap_layer.size)] = Tilemap.new(@viewport1) create_layer_tilemap(tilemap_layer[i],data) end $game_map.xpmap.compact.each do |data| _data = data.clone _data[:tileset] = LiTTleDRAgo.cache.tileset(data[:tileset_name]) _data[:autotiles] = [] if (tilemap = ([@tilemap]+tilemap_layer).detect {|t| obj_is_ztilemap?(t)}) data[:autotile_names].each_with_index do |name, i| _data[:autotiles][i] = LiTTleDRAgo.cache.autotile_cr_tilemap(name) end [tilemap.extra_map_data.push(_data), tilemap.refresh] && next end unless @@rpgmakerxp cr = "This script needs Drago - Custom Resolution ver 2.12 or above" ($imported[:drg_custom_resolution] || 0) >= 2.12 || raise(cr) end klass = @@rpgmakerxp ? @tilemap.class : ZTilemap tilemap_layer[(i = tilemap_layer.size)] = klass.new(@viewport1) create_layer_tilemap(tilemap_layer[i], _data) end @viewport_screen_width = 0 end #-------------------------------------------------------------------------- # * New Method : create_layer_tilemap #-------------------------------------------------------------------------- def create_layer_tilemap(tilemap,data) if (@@rpgmakerxp && tilemap.is_a?(Tilemap)) || obj_is_ztilemap?(tilemap) if obj_is_ztilemap?(tilemap) temp = tilemap.sprite_compact tilemap.sprite_compact = false end (0..6).each do |i| name = data[:autotile_names][i] bitmap = LiTTleDRAgo.cache.autotile(name) @force_tilemap_enabled = true if bitmap.height == 192 tilemap.autotiles[i] = obj_is_ztilemap?(tilemap) ? LiTTleDRAgo.cache.autotile_cr_tilemap(name) : bitmap end tilemap.tileset = data[:tileset] tilemap.priorities = data[:priorities] tilemap.map_data = data[:map].data update_layer_tilemap(tilemap) tilemap.update tilemap.sprite_compact = temp if obj_is_ztilemap?(tilemap) else tilemap.map_data = data[:map].data data[:tileset].tileset_names.each_with_index do |name, i| tilemap.bitmaps[i] = LiTTleDRAgo.cache.tileset(name) end tilemap.flags = data[:tileset].flags update_layer_tilemap(tilemap) tilemap.update end end #-------------------------------------------------------------------------- # * Aliased Method : update #-------------------------------------------------------------------------- def update unless @@rpgmakerxp update_panorama update_fog update_panorama_plane update_fog_plane end update_multi_layer_cr if @xpmap_size != $game_map.xpmap.size || @vxamap_size != $game_map.vxamap.size create_multi_layer end update_multi_layer end #-------------------------------------------------------------------------- # * New Method : dispose_multi_layer #-------------------------------------------------------------------------- def dispose_multi_layer tilemap_layer.dispose tilemap_layer.clear end #-------------------------------------------------------------------------- # * New Method : update_multi_layer #-------------------------------------------------------------------------- def update_multi_layer tilemap_layer.each { |t| update_layer_tilemap(t) } end #-------------------------------------------------------------------------- # * New Method : update_layer_tilemap #-------------------------------------------------------------------------- def update_layer_tilemap(tilemap) if obj_is_ztilemap?(tilemap) if @@rpgmakerxp tilemap.ox = @tilemap.ox tilemap.oy = @tilemap.oy tilemap.zoom_x = $game_map.zoom_x tilemap.zoom_y = $game_map.zoom_y tilemap.opacity = $game_map.tilemap_opacity tilemap.hue = $game_map.tilemap_hue tilemap.tone = $game_map.tilemap_tone else tilemap.ox = $game_map.display_x * tilemap_move_multiplier tilemap.oy = $game_map.display_y * tilemap_move_multiplier end else tilemap.ox = @tilemap.ox rescue $game_map.display_x * tilemap_move_multiplier tilemap.oy = @tilemap.oy rescue $game_map.display_y * tilemap_move_multiplier end tilemap.update end #-------------------------------------------------------------------------- # * New Method : obj_is_ztilemap? #-------------------------------------------------------------------------- def obj_is_ztilemap?(obj) defined?(ZTilemap) && obj.is_a?(ZTilemap) end #-------------------------------------------------------------------------- # * Aliased Method : dispose #-------------------------------------------------------------------------- def dispose dispose_multi_layer dispose_multi_layer_cr [dispose_fog, dispose_panorama] rescue nil unless @@rpgmakerxp end #-------------------------------------------------------------------------- # * Aliased Method : reload_tilemap #-------------------------------------------------------------------------- def reload_tilemap reload_tilemap_multi_layer_cr create_multi_layer end #-------------------------------------------------------------------------- # * New Method : tilemap_move_multiplier #-------------------------------------------------------------------------- def tilemap_move_multiplier n = 1.00 / 4 n = 1.00 / 8 if LiTTleDRAgo::VX n = 1.00 * 32 if LiTTleDRAgo::VXA return n end #-------------------------------------------------------------------------- # * New Method : update_panorama #-------------------------------------------------------------------------- unless method_defined?(:update_panorama) def update_panorama if @panorama.nil? @panorama = Plane.new(@viewport1) @panorama.opacity = (@@panorama_opacity ||= 0) @panorama.z = -1000 end if @panorama_name != $game_map.panorama_name or @panorama_hue != $game_map.panorama_hue @panorama_name = $game_map.panorama_name @panorama_hue = $game_map.panorama_hue if @panorama.bitmap.respond_to?(:dispose) && @panorama.bitmap.not.disposed? @panorama.bitmap.dispose @panorama.bitmap = nil end if @panorama_name != '' @panorama.bitmap = LiTTleDRAgo.cache.panorama(@panorama_name, @panorama_hue) end Graphics.frame_reset end end end #-------------------------------------------------------------------------- # * New Method : update_fog #-------------------------------------------------------------------------- unless method_defined?(:update_fog) def update_fog if @fog.nil? @fog = Plane.new(@viewport1) @fog.opacity = (@@fog_opacity ||= 0) @fog.z = 3000 end if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue @fog_name = $game_map.fog_name @fog_hue = $game_map.fog_hue if @fog.bitmap.respond_to?(:dispose) && @fog.bitmap.not.disposed? @fog.bitmap.dispose @fog.bitmap = nil end if @fog_name != '' @fog.bitmap = LiTTleDRAgo.cache.fog(@fog_name, @fog_hue) end Graphics.frame_reset end end end #-------------------------------------------------------------------------- # * New Method : update_panorama_plane #-------------------------------------------------------------------------- unless method_defined?(:update_panorama_plane) def update_panorama_plane @panorama.ox = $game_map.display_x / 8 @panorama.oy = $game_map.display_y / 8 end end #-------------------------------------------------------------------------- # * New Method : update_fog_plane #-------------------------------------------------------------------------- unless method_defined?(:update_fog_plane) def update_fog_plane @fog.zoom_x = $game_map.fog_zoom / 100.0 @fog.zoom_y = $game_map.fog_zoom / 100.0 @fog.opacity = $game_map.fog_opacity @fog.blend_type = $game_map.fog_blend_type @fog.ox = $game_map.display_x*tilemap_move_multiplier + $game_map.fog_ox @fog.oy = $game_map.display_y*tilemap_move_multiplier + $game_map.fog_oy @fog.tone = $game_map.fog_tone end end #-------------------------------------------------------------------------- # * New Method : dispose_fog #-------------------------------------------------------------------------- unless method_defined?(:dispose_fog) def dispose_fog unless @fog.nil? || @fog.disposed? @@fog_opacity = @fog.opacity @fog.dispose end end end #-------------------------------------------------------------------------- # * New Method : dispose_panorama #-------------------------------------------------------------------------- unless method_defined?(:dispose_panorama) def dispose_panorama unless @panorama.nil? || @panorama.disposed? @@panorama_opacity = @panorama.opacity @panorama.dispose end end end end #============================================================================== # ** RPG::Cache #============================================================================== ModCache = LiTTleDRAgo.cache module ModCache #---------------------------------------------------------------------------- # * Self #---------------------------------------------------------------------------- class << self #-------------------------------------------------------------------------- # * Get Autotile Graphic #-------------------------------------------------------------------------- unless method_defined?(:autotile) def autotile(filename) load_bitmap("Graphics/Autotiles/", filename) end end #-------------------------------------------------------------------------- # * Get Panorama Graphic #-------------------------------------------------------------------------- unless method_defined?(:panorama) def panorama(filename, hue = 0) load_bitmap("Graphics/Panoramas/", filename, hue) end end #-------------------------------------------------------------------------- # * Get Fog Graphic #-------------------------------------------------------------------------- unless method_defined?(:fog) def fog(filename, hue = 0) load_bitmap("Graphics/Fogs/", filename, hue) end end end end