[RGSS/3] XP Map Loader II

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