ТЕМА: Multi Layer [ACE]

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# Drago - Multi Layer
# Version: 2.02
# Author : LiTTleDRAgo
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
 
($imported ||= {})[:drg_multi_layer] = 2.02
 
core = "This script needs Drago - Core Engine ver 1.43 or above"
rmvx = "This script not for RMVX"
 
$imported[:drg_core_engine]         || raise(core)
LiTTleDRAgo::XP || LiTTleDRAgo::VXA || raise(rmvx)
 
#==============================================================================
# ** 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_sec_method :update_multi_layer_cr,     :update
  alias_sec_method :dispose_multi_layer_cr,    :dispose
  #--------------------------------------------------------------------------
  # * New Method : create_multi_layer
  #--------------------------------------------------------------------------
  def create_multi_layer
    return if @tilemap.not.is_a?(Tilemap)
    tilemap_layer.dispose
    tilemap_layer.clear
    @layer_data = $game_map.layer_data
    $game_map.layer_data.each_with_index do |data,index|
      temp_map = Game_Map.new
      temp_map.setup($game_map.layer_subs.at(index))
      tileset = LiTTleDRAgo.cache.tileset(temp_map.tileset_name)
      tilemap_layer[index] = Tilemap.new(@viewport1)
      tilemap_layer[index].map_data = temp_map.data
      if $game_map.map_type == 'XP'
        tilemap_layer[index].tileset = tileset
        for i in 0..6
          autotile_name = LiTTleDRAgo.cache.autotile(temp_map.autotile_names[i])
          tilemap_layer[index].autotiles[i] = autotile_name
        end
        tilemap_layer[index].priorities = temp_map.priorities
      else
        load = "This script needs Drago - XP Map Loader ver 1.10 or above"
        $imported[:drg_xp_map_loader] || raise(load)
        temp_map.tileset.tileset_names.each_with_index do |name, i|
          @tilemap_layer[index].bitmaps[i] = LiTTleDRAgo.cache.tileset(name)
        end
        @tilemap_layer[index].flags = temp_map.tileset.flags
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Aliased Method : update
  #--------------------------------------------------------------------------
  def update
    update_multi_layer_cr
    create_multi_layer if @layer_data != $game_map.layer_data
    tilemap_layer.ox = @tilemap.ox 
    tilemap_layer.oy = @tilemap.oy 
    tilemap_layer.update
  end
  #--------------------------------------------------------------------------
  # * Aliased Method : dispose
  #--------------------------------------------------------------------------
  def dispose
    tilemap_layer.dispose
    dispose_multi_layer_cr
  end
  #-------------------------------------------------------------------------
  # * Drago - Custom Resolution
  #-------------------------------------------------------------------------
  if $imported[:drg_custom_resolution] && LiTTleDRAgo::XP
    #-------------------------------------------------------------------------
    # * Alias Listing
    #-------------------------------------------------------------------------
    alias_sec_method :create_tilemap_ex_multi_layer,  :create_tilemap_ex
    alias_sec_method :update_new_tilemap_multi_layer, :update_tilemap_ex
    alias_sec_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 && @tilemap_layer_ex.flatten.dispose
      @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 = LiTTleDRAgo.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 = LiTTleDRAgo.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_tilemap_ex
      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 && @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'
  attr_reader :layer_tilesets
  attr_reader       :map_type
  #--------------------------------------------------------------------------
  # * Alias Method
  #--------------------------------------------------------------------------
  alias_sec_method :setup_multilayer, :setup
  #--------------------------------------------------------------------------
  # * Aliased Method : setup
  #--------------------------------------------------------------------------
  def setup(*args)
    setup_multilayer(*args)   
    @map_type ||= 'XP'
    @is_load = true # hot fix
    decide_map_layer(*args)          
  end
  #--------------------------------------------------------------------------
  # * Overwriten Method : decide_map_layer
  #--------------------------------------------------------------------------
  def decide_map_layer(*args)
    return if layer_subs.include?(@map_id)
    return if @is_load == nil
    @layer_data, @layer_subs = [], [] 
    @layer_tilesets = []
 
    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, @map_type=='XP' ? :rxdata : :rvdata2)
          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
         # p sprintf("tileset=%d, cur_size=%d", submap.tileset_id, data.zsize)
          @layer_tilesets << submap.tileset_id
          @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
        @need_redraw = true
      end
    end
  end
 
  # for separate passability
  def check_passage(x, y, bit)
    pass = true
    # проверяем первую карту
    all_tiles1(x, y).each do |tile_id|
      flag = tileset.flags[tile_id]
      if flag & 0x10 != 0                       # [?]: No effect on passage
        if flag & bit == 0 # [0] : Passable but star
          next   
        end
        if flag & bit == bit   # [?] : Impassable
          pass = false 
          break
        end
      else
        if flag & bit == 0  # [0] : Passable
          pass = true  
          break
        end
        if flag & bit == bit   # [?] : Impassable
          pass = false 
          break
        end
      end
    end
    if pass == false                           # Impassable
      return false 
    end
 
    idx = 0
 
    @layer_tilesets.each do |tileset_n|     
      all_tiles_n(x, y, idx).each do |tile_id|
        flag = $data_tilesets[tileset_n].flags[tile_id]
        if flag & 0x10 != 0    # [?]: No effect on passage
          if flag & bit == 0 # [0] : Passable but star
            next   
          end
          if flag & bit == bit   # [?] : Impassable
            pass = false 
            break
          end
        else
          if flag & bit == 0  # [0] : Passable
            pass = true  
            break
          end
          if flag & bit == bit   # [?] : Impassable
            pass = false 
            break
          end
        end
      end
 
      if pass == false                           # Impassable
        return false 
      end
      idx = idx +1
    end
 
    return pass                                
  end
 
  def all_tiles1(x, y)
    tile_events_xy(x, y).collect {|ev| ev.tile_id } + layered_tiles1(x, y)
  end
 
  def layered_tiles1(x, y)
    _z_data = z_data.reject {|s| s >= 3 }
    _z_data.collect {|z| tile_id(x, y, z) }
  end
 
  def all_tiles_n(x, y, idx)
    tile_events_xy(x, y).collect {|ev| ev.tile_id } + layered_tiles_n(x, y, idx)
  end
 
  def layered_tiles_n(x, y, idx)
    idx1 = 3 + idx*3
    idx2 = 5 + idx*3
   # p sprintf("idx1=%d,idx2=%d",idx1,idx2)
    _z_data = z_data.reject {|s| s <= idx1 || s > idx2 }
    _z_data.collect {|z| tile_id(x, y, z) }
  end
 
  #--------------------------------------------------------------------------
  # * If RMXP
  #--------------------------------------------------------------------------
  if LiTTleDRAgo::XP
    #--------------------------------------------------------------------------
    # * 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
end

##-----------------------------------------------------------------------------
#  Large Sprite ☆ Display Fix v1.3
#  Created by Neon Black at request of seita
#  v1.4 - 06.06.14 - Fix Multilayer by Caveman
#  v1.3 - 1.12.14 - Viewport/position issue fixes
#  v1.1 - 8.18.13 - Fixed an odd lag issue
#  v1.0 - 8.17.13 - Main script completed
#  For both commercial and non-commercial use as long as credit is given to
#  Neon Black and any additional authors.  Licensed under Creative Commons
#  CC BY 4.0 - http://creativecommons.org/licenses/by/4.0/
##-----------------------------------------------------------------------------
 
##------
## By default, this script only affects the player.  To allow it to affect
## an event page as well, add a comment with the tag <large sprite> to the page
## of the event you would like to have affected by this.
 
class Sprite_Character < Sprite_Base
  ##------
  ## The ID of the terrain used to display the large character above ☆ tiles.
  ## If the player is below this tile (y position), the sprite will appear
  ## above all tiles and events from that y position up.  If the player is on
  ## the same tile or above (y position) the event will appear BELOW ☆ tiles
  ## from that position up.
  ##------
  UpperTerrain = 7
 
  alias :cp_011214_update_bitmap :update_bitmap
  def update_bitmap(*args)
    if graphic_changed? && @set_upper_area_sprite
      @force_no_gfx_change = true
    else
      @force_no_gfx_change = false
    end
    cp_011214_update_bitmap(*args)
  end
 
  ## Alias the update method to add in the new graphic check.
  alias :cp_073013_update_pos :update_position
  def update_position(*args)
    cp_073013_update_pos(*args)
    move_animation(@character.screen_x - x, @character.screen_y - y)
    self.x = @character.screen_x + @character.xs
    self.y = @character.screen_y + @character.ys
    self.z = @character.screen_z + @character.zs
    check_encompassed_area if sprite_is_onscreen?
  end
 
  ## Alias the dispose to dispose the upper sprite.
  alias :cp_073013_dispose :dispose
  def dispose(*args)
    @upper_area_sprite.dispose if @upper_area_sprite
    cp_073013_dispose(*args)
  end
 
#~   ## Alias the graphic changed method to allow the sprite to revent to what it
#~   ## was during the last frame.  This allows the check to work again.
#~   alias :cp_073013_graphic_changed? :graphic_changed?
#~   def graphic_changed?(*args)
#~     cp_073013_graphic_changed?(*args) || @set_upper_area_sprite
#~   end
 
  ## Check if the sprite is onscreen.  Reduces redundant drawing.
  def sprite_is_onscreen?
    return false if @character.is_a?(Game_Vehicle) || @character.is_a?(Game_Follower)
    return false unless @character.is_a?(Game_Player) || @character.large_sprite
    return false if @character.screen_z >= 200
    top_left, bot_right = get_edge_corner_dis
    return false if top_left[0] > Graphics.width
    return false if top_left[1] > Graphics.height
    return false if bot_right[0] < 0
    return false if bot_right[1] < 0
    return true
  end
 
  ## Get the top left and bottom right positions.
  def get_edge_corner_dis
    top_left = [self.x - self.ox, self.y - self.oy]
    bot_right = [top_left[0] + self.width, top_left[1] + self.height]
    return [top_left, bot_right]
  end
 
  ## Long method that checks each position and draws the upper sprite.
  def check_encompassed_area
    if @set_upper_area_sprite && !@force_no_gfx_change
      old_src = self.src_rect.clone
      self.bitmap = @old_bitmap
      self.src_rect = old_src
    end
    @set_upper_area_sprite = false
    top_left, bot_right = get_edge_corner_dis
    last_x, last_y, copy_region = nil, nil, 0
    map_xd, map_yd = $game_map.display_x * 32, $game_map.display_y * 32
    total_height = (self.height + @character.jump_height).round
    self.width.times do |x|
      xp = map_xd.to_i + top_left[0] + x
      unless xp / 32 == last_x
        last_x = xp / 32
        last_y, copy_region = nil, 0
        total_height.times do |y|
          yp = map_yd.to_i + bot_right[1] + @character.jump_height - y
          next if yp.to_i / 32 == last_y
          last_y = yp.to_i / 32
          if last_y == (@character.screen_y + @character.jump_height +
                        map_yd).to_i / 32
            break if hasUpperTerrain?(last_x, last_y)
            next
          end
          next if !hasUpperTerrain?(last_x, last_y)
          copy_region = [self.height, total_height - y + 1].min
          set_upper_sprite
          break
        end
      end
      next if copy_region == 0
      rect = Rect.new(src_rect.x + x, src_rect.y, 1, copy_region)
      @upper_area_sprite.bitmap.blt(x, 0, self.bitmap, rect)
      self.bitmap.clear_rect(rect)
    end
    if !@set_upper_area_sprite && @upper_area_sprite
      @upper_area_sprite.visible = false
    end
  end
 
  def hasUpperTerrain?(x, y)
   # p 'ddd'
    $game_map.all_tiles1(x, y).each do |tile_id|
      if !tile_id.nil?
        tag = $data_tilesets[$game_map.tileset_id].flags[tile_id] >> 12
        if tag == UpperTerrain
        #  p 'upper'
          return true 
        end
      end
    end
    idx = 0
    $game_map.layer_tilesets.each do |tileset_n|     
      $game_map.all_tiles_n(x, y, idx).each do |tile_id|
        if !tile_id.nil?
          tag = $data_tilesets[tileset_n].flags[tile_id] >> 12
          if tag == UpperTerrain
         #   p 'upper'
            return true 
          end
        end
      end
      idx = idx +1
    end
    return false
  end
 
  ## Creates the upper sprite that's a copy of the current sprite.
  def set_upper_sprite
    return if @set_upper_area_sprite
    @upper_area_sprite ||= Sprite.new
    @upper_area_sprite.bitmap = Bitmap.new(self.width, self.height)
    props = ["x", "y", "ox", "oy", "zoom_x", "zoom_y", "angle", "mirror",
             "bush_depth", "opacity", "blend_type", "color", "tone", "visible",
             "viewport"]
    props.each do |meth|
      @upper_area_sprite.method("#{meth}=").call(self.method(meth).call)
    end
    @upper_area_sprite.z = 200
    @set_upper_area_sprite = true
    @old_bitmap, old_src_rect = self.bitmap, self.src_rect.clone
    self.bitmap = Bitmap.new(@old_bitmap.width, @old_bitmap.height)
    self.bitmap.blt(0, 0, @old_bitmap, @old_bitmap.rect)
    self.src_rect = old_src_rect
  end
end
 
class Game_Event < Game_Character
  attr_reader :large_sprite
 
  alias :cp_081713_setup_page_settings :setup_page_settings
  def setup_page_settings(*args)
    cp_081713_setup_page_settings(*args)
    get_large_sprite_conditions
  end
 
  def get_large_sprite_conditions
    @large_sprite = false
    return if @list.nil? || @list.empty?
    @list.each do |line|
      next unless line.code == 108 || line.code == 408
      case line.parameters[0]
      when /<large sprite>/i
        @large_sprite = true
      end
    end
  end
end