[RGSS] Drago - Multi Layer XP

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# Drago - Multi Layer XP
# Version: 2.00 XP
# Author : LiTTleDRAgo
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:

($imported ||= {})[:drg_multi_layer_xp] = 1.00

core = "This script needs Drago - Core Engine ver 1.42 or above"
rmxp = "This script only for RMXP"

$imported[:drg_core_engine]       || raise(core)
LiTTleDRAgo::XP                   || raise(rmxp)

#==============================================================================
# ** 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'
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias_method :initialize_multi_layer_cr, :initialize
  alias_method :update_multi_layer_cr,     :update
  alias_method :dispose_multi_layer_cr,    :dispose
  #--------------------------------------------------------------------------
  # * Aliased Method : initialize
  #--------------------------------------------------------------------------
  def initialize
    initialize_multi_layer_cr
    create_multi_layer
    update
  end
  #--------------------------------------------------------------------------
  # * New Method : create_multi_layer
  #--------------------------------------------------------------------------
  def create_multi_layer
    $game_map.layer_data.each_with_index do |data,index|
      temp_map = Game_Map.new
      temp_map.setup($game_map.layer_subs.at(index))
      tilemap_layer[index] = Tilemap.new(@viewport1)
      tilemap_layer[index].tileset = RPG::Cache.tileset(temp_map.tileset_name)
      for i in 0..6
        autotile_name = RPG::Cache.autotile(temp_map.autotile_names[i])
        tilemap_layer[index].autotiles[i] = autotile_name
      end
      tilemap_layer[index].map_data   = temp_map.data
      tilemap_layer[index].priorities = temp_map.priorities
    end
  end
  #--------------------------------------------------------------------------
  # * Aliased Method : update
  #--------------------------------------------------------------------------
  def update
    update_multi_layer_cr
    if @tilemap.not.disposed?
      tilemap_layer.ox = @tilemap.ox
      tilemap_layer.oy = @tilemap.oy
      tilemap_layer.update
    end
  end
  #--------------------------------------------------------------------------
  # * Aliased Method : dispose
  #--------------------------------------------------------------------------
  def dispose
    tilemap_layer.dispose
    dispose_multi_layer_cr
  end
  #-------------------------------------------------------------------------
  # * Drago - Custom Resolution
  #-------------------------------------------------------------------------
  if $imported[:drg_custom_resolution]
    #-------------------------------------------------------------------------
    # * Alias Listing
    #-------------------------------------------------------------------------
    alias_method :create_tilemap_ex_multi_layer,  :create_tilemap_ex
    alias_method :update_new_tilemap_multi_layer, :update_new_tilemap
    alias_method :dispose_tilemap_ex_multi_layer, :dispose_tilemap_ex
    #-------------------------------------------------------------------------
    # * Aliased method: create_tilemap_ex
    #-------------------------------------------------------------------------
    def create_tilemap_ex
      create_tilemap_ex_multi_layer
      create_multi_layer_ex
    end
    #-------------------------------------------------------------------------
    # * New method: create_multi_layer_ex
    #-------------------------------------------------------------------------
    def create_multi_layer_ex
      @tilemap_layer_ex = []
      @extra_res.each_index do |a|
        @tilemap_layer_ex[a] ||= []
        $game_map.layer_data.each_with_index do |d,b|
          temp_map = Game_Map.new
          temp_map.setup($game_map.layer_subs.at(b))
          tileset = RPG::Cache.tileset(temp_map.tileset_name)
          @tilemap_layer_ex[a][b] = Tilemap.new(@viewport_ex[a])
          @tilemap_layer_ex[a][b].tileset = tileset
          for i in 0..6
            autotile = RPG::Cache.autotile(temp_map.autotile_names[i])
            @tilemap_layer_ex[a][b].autotiles[i] = autotile
          end
          @tilemap_layer_ex[a][b].map_data   = temp_map.data
          @tilemap_layer_ex[a][b].priorities = temp_map.priorities
        end
      end
    end
    #-------------------------------------------------------------------------
    # * Aliased method: update_new_tilemap
    #-------------------------------------------------------------------------
    def update_new_tilemap
      update_new_tilemap_multi_layer
      @tilemap_ex && @extra_res.each_index do |a|
        $game_map.layer_data.each_index do |b|
          if @tilemap_layer_ex && @tilemap_layer_ex[a] &&
            @tilemap_layer_ex[a][b] && @tilemap_layer_ex[a][b].not.disposed?
            @tilemap_ex[a].not.disposed?
            @tilemap_layer_ex[a][b].ox = @tilemap_ex[a].ox
            @tilemap_layer_ex[a][b].oy = @tilemap_ex[a].oy
            @tilemap_layer_ex[a][b].update
          end
        end
      end
    end
    #-------------------------------------------------------------------------
    # * Aliased method: dispose_tilemap_ex
    #-------------------------------------------------------------------------
    def dispose_tilemap_ex
      @tilemap_layer_ex.flatten.dispose
      dispose_tilemap_ex_multi_layer
    end
  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
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_sec_accessor :layer_data, :layer_subs, 'Array.new'
  #--------------------------------------------------------------------------
  # * Alias Method
  #--------------------------------------------------------------------------
  alias_method :setup_multilayer, :setup
  #--------------------------------------------------------------------------
  # * Aliased Method : setup
  #--------------------------------------------------------------------------
  def setup(*args)
    setup_multilayer(*args)
    @map_type = 'XP'
    decide_map_layer(*args)
  end
  #--------------------------------------------------------------------------
  # * Overwriten Method : decide_map_layer
  #--------------------------------------------------------------------------
  def decide_map_layer(*args)
    return if layer_subs.include?(@map_id)
    @layer_data, @layer_subs = [], []
    child_ids.each do |submap_id|
      map_info = mapInfo[submap_id]
      unless map_info.nil?
        if map_info.parent_id == map_id &&
          map_info.name.include?("[" + 'join' + "]")
        then
          submap = load_map_data(submap_id)
          unless submap
            print "Map #{submap_id} doesn't exist"
            next
          end
          if [submap.width,submap.height] != [width,height]
            raise "Dimension of child maps must be same with parent's dimension"
          end
          @layer_data << data
          @layer_subs << submap_id
          old_zsize = data.zsize
          data.resize(data.xsize, data.ysize, old_zsize + 3)
          for x in 0...data.xsize
            for y in 0...data.ysize
              if @map_type == 'XP'
                data[x, y, old_zsize]     = submap.data[x, y, 0]
                data[x, y, old_zsize + 1] = submap.data[x, y, 1]
                data[x, y, old_zsize + 2] = submap.data[x, y, 2]
              else
                data[x, y, old_zsize]     = submap.data[x, y, 1]
                data[x, y, old_zsize + 1] = submap.data[x, y, 2]
              end
            end
          end
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Overwriten Method : passable?
  #--------------------------------------------------------------------------
  def passable?(x, y, d, s = nil)
    return false unless valid?(x, y)
    bit = (1 << (d / 2 - 1)) & 0x0f
    (event_tiles(x, y, s) + layered_tiles(x, y)).each do |tile_id|
      return false if tile_id.nil?
      if @passages[tile_id] & bit != 0
        return false
      elsif @passages[tile_id] & 0x0f == 0x0f
        return false
      elsif @priorities[tile_id] == 0
        return true
      end
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Overwriten Method : bush?
  #--------------------------------------------------------------------------
  def bush?(x, y)
    return false if @map_id == 0
      layered_tiles(x, y).each do |tile_id|
      return false if tile_id.nil?
      passage = @passages[tile_id]
      return true if passage & 0x40 == 0x40
    end
    return false
  end
  #--------------------------------------------------------------------------
  # * Overwriten Method : counter?
  #--------------------------------------------------------------------------
  def counter?(x, y)
    return false if @map_id == 0
    layered_tiles(x, y).each do |tile_id|
      return false if tile_id.nil?
      passage = @passages[tile_id]
      return true if passage & 0x80 == 0x80
    end
    return false
  end
  #--------------------------------------------------------------------------
  # * Overwriten Method : terrain_tag
  #--------------------------------------------------------------------------
  def terrain_tag(x, y)
    return 0 if @map_id == 0
    layered_tiles(x, y).each do |tile_id|
      return 0 if tile_id.nil?
      tag = @terrain_tags[tile_id]
      return tag if tag > 0
    end
    return 0
  end
  #--------------------------------------------------------------------------
  # * New Method : layered_tiles
  #--------------------------------------------------------------------------
  def layered_tiles(x, y)
    z_data.collect {|z| tile_id(x, y, z) }
  end
  #--------------------------------------------------------------------------
  # * New Method : z_data
  #--------------------------------------------------------------------------
  unless method_defined?(:z_data)
    def z_data
      (0...data.zsize).to_a.reverse
    end
  end
  #--------------------------------------------------------------------------
  # * New Method : event_tiles
  #--------------------------------------------------------------------------
  def event_tiles(x, y, s=nil)
    return [] unless self.respond_to?(:events_xy_nt)
    e = events_xy_nt(x,y).select {|e| e.tile_id >= 0 && e != s }
    e.collect {|event| event.tile_id }
  end
  #--------------------------------------------------------------------------
  # * New Method : tile_id
  #--------------------------------------------------------------------------
  unless method_defined?(:tile_id)
    def tile_id(x, y, z)
      data[x, y, z]
    end
  end
end