[RGSS] Drago - Custom Resolution II

#==============================================================================
# ** Drago - Custom Resolution
# Version : 2.17
# Contact : littledrago.blogspot.com / forum.chaos-project.com
#==============================================================================
($imported ||= {})[:drg_custom_resolution] = 2.17
#==============================================================================
#
# Introduction :
#
#   Version 2 from previous Drago - Custom Resolution
#
# Issue :
#
#  - Normal transition didn't work when resolution is more than 640x480
#  - ALT+Enter is disabled by default
#  - Custom menu system will require an edit to match the new resolution
#  - Anything that modify Sprite_Character & Spriteset_Map will require an edit
#
# Script Call :
#
#  Graphics.window
#  Graphics.fullscreen
#  Graphics.fullscreen?     # returns true if game is fullscreen
#
#    $game_map.start_zoom(X, Y, ZOOM_VALUE, DURATION = 20)
#    $game_map.zoom(X = nil, Y = nil, ZOOM_VALUE)
#    $game_map.zoom_in(X = nil, Y = nil, DURATION = 20)
#    $game_map.zoom_out(X = nil, Y = nil, DURATION = 20)
#
#    $game_map.reverse(true / false) # Flip the map
#
#    $game_map.start_tilemap_opacity(OPACITY = 255, DURATION = 20)
#    $game_map.start_tilemap_tone(TONE = Tone.new(0,0,0,0), DURATION = 0)
#
#
#    change_tilemap_tone(TONE,*CHARACTER)     # change tilemap tone
#    change_character_tone(TONE,*CHARACTER)   # change character tone without
#                                               changing the tilemap
#
#   X, Y       = Zoom focus
#
#   ZOOM_VALUE = Integer from 1-12
#
#   OPACITY    = Integer from 0-255
#
#   TONE       = [R,G,B,A] or Tone.new(R,G,B,A)
#
#   CHARACTER  = $game_map.events.values # all events
#              = $game_map.events.keys   # all events
#              = $game_player            # player
#              = -1                      # player
#              = 0                       # this event
#              = [2,3,4,6]               # events with selected id
#              = [-1,2,3,4,6]            # player & events with selected id
#              = [0,2,3,4,6]             # this event & events with selected id
#              = (1..99)                 # events in range
#              = [(1..8),20,25,(30..42)] # events in range
#
#    * will not change the character tone if left out
#
# Links :
#
#  - Fantasist's Transitions Pack
#    http://forum.chaos-project.com/index.php/topic,1390.0.html
#  - ForeverZer0's Add-ons
#    http://forum.chaos-project.com/index.php/topic,7862.0.html
#  - ThallionDarkshine's Add-ons
#    http://forum.chaos-project.com/index.php/topic,12655.0.html
#  - Drago Transition Pack
#    http://forum.chaos-project.com/index.php/topic,13488.0.html
#
#  - Adjust Menu Position
#    http://forum.chaos-project.com/index.php/topic,13781.0.html
#
#  - ThallionDarkshine's F12 Fix
#    http://forum.chaos-project.com/index.php/topic,13629.0.html
#  - Zeriab's F12 Pause with images
#    http://forum.chaos-project.com/index.php/topic,3613.0.html
#
# Special Thanks :
#
# - ForeverZer0 & KK20 for method used in this script
# - Wecoc for autotile addon
#
#==============================================================================

module LiTTleDRAgo

  SCREEN_SIZE = [640,490]
  # Define the resolution of the game screen. These values can be anything
  # within reason. Centering, viewports, etc. will all be taken care of, but it
  # is recommended that you use values divisible by 32 for best results.


  AUTOTILE_SPEED = {}

  AUTOTILE_SPEED[:map_id] = :speed
  AUTOTILE_SPEED[0]       = 6                              # default speed
  #AUTOTILE_SPEED[35]      = 0                              # unchanged autotile
  #AUTOTILE_SPEED[159]     = 16
  # Speed of the autotile based on map_id

  CONTROL_SCREEN_SIZE = false
  # Control screen size with a mouse

  HIGH_PRIORITY = true
  # Change Game process priority to high

  SPRITE_COMPACT = true
  # Keep the sprite to the very minimum number

  CHARACTER_Z_FIX = {
    '178-Switch01'  => 0,
    '180-Switch03'  => 0,
    '181-Switch04'  => 0,
    '199-Support07' => 0,
  }
  # Fix the screen_z value for events based on Graphic name.
  # You can also define z value for event by inserting <z: Z_VALUE>
  # on event name.
  # This way, flat events such as pitfall won't overlap with player z value.

end


core = "This script needs Drago - Core Engine ver 1.47 or above"
rmvx = "This script not for RMVX"
implemented = "%1$s has already implemented, Please remove the %1$s script"
zoom = sprintf(implemented,"Map Zoom")
tone = sprintf(implemented,"Tilemap Tone Changer" )

($imported[:drg_core_engine] || 0) >= 1.47 || raise(core)
LiTTleDRAgo::XP || LiTTleDRAgo::VXA  || raise(rmvx)
$imported[:drg_cr_map_zoom]          && raise(zoom)
$imported[:drg_tilemap_tone_changer] && raise(tone)
#==============================================================================
# ** Graphics
#------------------------------------------------------------------------------
#  This module handles all Graphics
#==============================================================================

class << Graphics
  #-------------------------------------------------------------------------
  # * Alias Listing
  #-------------------------------------------------------------------------
  alias_sec_method :zer0_graphics_transition,            :transition
  alias_sec_method :drg_resolution_change_resize_screen, :resize_screen
  alias_sec_method :drg_resolution_change_update,        :update
  #-------------------------------------------------------------------------
  # * Aliased method: resize_screen
  #-------------------------------------------------------------------------
  def resize_screen(width, height)
    width = (width / 32.0).round * 32
    height = (height / 32.0).round * 32
    if $game_map.respond_to?(:screen_size)
      $game_map.screen_size[0] = width
      $game_map.screen_size[1] = height
    end
    drg_resolution_change_resize_screen(width, height)
  end
  #-------------------------------------------------------------------------
  # * Aliased method: transition
  #-------------------------------------------------------------------------
  def transition(duration = 8, *args)
    if width <= 640 && height <= 480
      return zer0_graphics_transition(duration, *args)
    end
    if duration > 0
      viewport = Viewport.new(0,0,width,height)
      sprite  = Sprite.new(viewport)
      sprite.bitmap = Graphics.snap_to_bitmap
      sprite2 = Sprite.new(viewport)
      sprite2.z = sprite.z - 10
      sprite2.blend_type = 1
      zer0_graphics_transition(0)
      fade = 255 / duration
      if (file = args.at(0)).is_a?(String)
        bitmap = Bitmap.new(file)
        sprite2.bitmap = bitmap.stretch(width,height)
        bitmap.dispose
      end
      duration.times {[sprite,sprite2].each {|s|s.opacity -= fade} && update }
      [sprite.bitmap, sprite2.bitmap, sprite, sprite2, viewport].dispose
    end
    zer0_graphics_transition(0)
  end
  #-------------------------------------------------------------------------
  # * Aliased method: update
  #-------------------------------------------------------------------------
  def update
    drg_resolution_change_update
    update_resolution_adjust
  end
  #-------------------------------------------------------------------------
  # * New method: update_resolution_adjust
  #-------------------------------------------------------------------------
  def update_resolution_adjust
    return unless LiTTleDRAgo::XP && $game_player
    return unless Game_Player.const_defined?(:CENTER_X)
    change   = Game_Player.const_get(:CENTER_X) != $game_player.center_x
    change ||= Game_Player.const_get(:CENTER_Y) != $game_player.center_y
    return unless change
    resize_screen(width,height)
    $game_player.center($game_player.x,$game_player.y)
  end
  #-------------------------------------------------------------------------
  # * Overwriten method: fullscreen
  #-------------------------------------------------------------------------
  def fullscreen
    @fullscreen = true
    fill_monitor
    LiTTleDRAgo.hide_borders
  end
  #-------------------------------------------------------------------------
  # * Overwriten method: window
  #-------------------------------------------------------------------------
  def window
    @fullscreen = false
    LiTTleDRAgo.show_borders
    if $game_map && $game_map.screen_size.all? {|s| s.is_a?(Numeric)}
      x,y = $game_map.screen_size[0..1]
      x += ($game_map.screen_size[2] ||= 1)
      $game_map.screen_size[2] *= -1
      drg_resolution_change_resize_screen(x,y)
    else
      x,y = LiTTleDRAgo::SCREEN_SIZE
    end
    resize_screen(x,y)
  end
  #-------------------------------------------------------------------------
  # * Overwriten method: fullscreen?
  #-------------------------------------------------------------------------
  define_method(:fullscreen?) { @fullscreen == true }
end

Graphics.window
Graphics.disable_alt_enter
Graphics.control_screen_size LiTTleDRAgo::CONTROL_SCREEN_SIZE
Graphics.high_priority     = LiTTleDRAgo::HIGH_PRIORITY
GC.start
#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  This class handles the map. It includes scrolling and passable determining
#  functions. Refer to "$game_map" for the instance of this class.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variable
  #--------------------------------------------------------------------------
  attr_sec_accessor :zoom_x, :zoom_y, 'Integer(1)'
  attr_sec_accessor :screen_size,     'LiTTleDRAgo::SCREEN_SIZE'
  attr_sec_accessor :tilemap_tone,    'Tone.new(0,0,0)'
  attr_sec_accessor :tilemap_opacity, 'Integer(255)'
  attr_sec_accessor :tilemap_hue,     'Integer(0)'
  #---------------------------------------------------------------------------
  # * Redirect Listing
  #---------------------------------------------------------------------------
  [:tilemap_tone,:tilemap_opacity].each do |meth|
    redirect_method :"#{meth}_changing?",   "(@#{meth}_duration ||= 0) > 0"
  end
  #---------------------------------------------------------------------------
  # * Define Sec Listing
  #---------------------------------------------------------------------------
  define_sec_method(:zooming?)      {(@zoom_duration ||= 0) > 0}
  define_sec_method(:screen_tile_x) {(Graphics.width  / 32.0).ceil}
  define_sec_method(:screen_tile_y) {(Graphics.height / 32.0).ceil}
  #-------------------------------------------------------------------------
  # * Alias Listing
  #-------------------------------------------------------------------------
  alias_sec_method(:drg_scroll_right_adjust, :scroll_right)
  alias_sec_method(:drg_scroll_down_adjust,  :scroll_down)
  alias_sec_method(:tilemap_effect_update,   :update)
  alias_sec_method(:get_map_data,            :data)
  #--------------------------------------------------------------------------
  # * Aliased method: Scroll Down
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    times = vxa_map_multiplier
    if loop_vertical?
      @display_y += distance
      @display_y %= height * times
      @parallax_y += distance if @parallax_y && @parallax_loop_y
    else
      last_y = @display_y
      result = [@display_y + distance, (map_edge.at(1) / zoom_y)].min
      drg_scroll_down_adjust(distance)
      @display_y = result
    end
  end
  #--------------------------------------------------------------------------
  # * Aliased method: Scroll Right
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    times = vxa_map_multiplier
    if loop_horizontal?
      @display_x += distance
      @display_x %= width * times
      @parallax_x += distance if @parallax_x && @parallax_loop_x
    else
      last_x = @display_x
      result = [@display_x + distance, (map_edge.at(0) / zoom_x)].min
      drg_scroll_right_adjust(distance)
      @display_x = result
    end
  end
  #--------------------------------------------------------------------------
  # * New method: zoom
  #--------------------------------------------------------------------------
  def zoom(*zoom)
    if zoom.size == 1
      zoom = (zoom.first)
    elsif zoom.size == 3
      x,y,zoom = zoom[0..2]
    end
    return unless zoom.is_a?(Numeric)
    old_zoom = @zoom_x
    @zoom_x = [[zoom,12].min, 1].max
    @zoom_y = [[zoom,12].min, 1].max
    $game_player.center(x,y) if x && y
  end
  #--------------------------------------------------------------------------
  # * New method: zoom_in
  #--------------------------------------------------------------------------
  def zoom_in(x = nil,y = nil, duration = 20)
    start_zoom(x,y, zoom_x >= 1 ? zoom_x + 1 : 1, duration)
  end
  #--------------------------------------------------------------------------
  # * New method: zoom_out
  #--------------------------------------------------------------------------
  def zoom_out(x = nil,y = nil,duration = 20)
    start_zoom(x,y, zoom_x - 1 >= 1 ? zoom_x - 1 : zoom_x - 0.5, duration)
  end
  #--------------------------------------------------------------------------
  # * New method: map_edge
  #--------------------------------------------------------------------------
  def map_edge
    times = vxa_map_multiplier
    [_w = [(width  * zoom_x - screen_tile_x).ceil * times, 0].max,
     _h = [(height * zoom_y - screen_tile_y).ceil * times, 0].max]
  end
  #--------------------------------------------------------------------------
  # * New method: autotile_speed
  #--------------------------------------------------------------------------
  def autotile_speed(id = @map_id)
    speed = LiTTleDRAgo::AUTOTILE_SPEED
    @autotile_speed.is_a?(Array) || @autotile_speed = []
    @autotile_speed[id] ||= (speed[id] || speed[0] || 0)
  end
  #--------------------------------------------------------------------------
  # * New method: autotile_speed=
  #--------------------------------------------------------------------------
  def autotile_speed=(*value)
    @autotile_speed.is_a?(Array) || @autotile_speed = []
    @autotile_speed[@map_id]     = [value.first,0].max if value.size == 1
    @autotile_speed[value.first] = [value.at(1),0].max if value.size > 1
  end
  #--------------------------------------------------------------------------
  # * New method: vxa_map_multiplier
  #--------------------------------------------------------------------------
  def vxa_map_multiplier
    LiTTleDRAgo::VXA ? 1 : 128
  end
  #--------------------------------------------------------------------------
  # * New method: screen_is_solid?
  #--------------------------------------------------------------------------
  def screen_is_solid?
    tone = screen.tone.to_s.gsub(/([(),0 ])/i){''}
    return true if tone['255.255.255.']
    return true if tone['255.-255.-255.']
    return true if tone['-255.255.-255.']
    return true if tone['-255.-255.255.']
    return true if tone['255.255.-255.']
    return true if tone['255.-255.255.']
    return true if tone['-255.255.255.']
    return true if tone['-255.-255.-255.']
  end
  #--------------------------------------------------------------------------
  # * Aliased method: data
  #--------------------------------------------------------------------------
  def data
    data = self.reverse ? reverse_data : get_map_data
    data.make_changes = true
    data
  end
  #--------------------------------------------------------------------------
  # * New method: reverse_data
  #--------------------------------------------------------------------------
  def reverse_data
    @reverse_data ||= []
    @reverse_data[@map_id] ||= get_map_data.reverse(true,false,false)
  end
  #--------------------------------------------------------------------------
  # * New method: reverse=
  #--------------------------------------------------------------------------
  def reverse=(val)
    return val if @reverse == val
    @reverse = ((@reverse_data||=[])[@map_id] = nil) || val
    spriteset && spriteset.reload_tilemap
    @reverse
  end
  #--------------------------------------------------------------------------
  # * New method: reverse
  #--------------------------------------------------------------------------
  def reverse
    @reverse && LiTTleDRAgo::XP
  end
  #--------------------------------------------------------------------------
  # * New method: start_tilemap_tone
  #--------------------------------------------------------------------------
  def start_tilemap_tone(tone = Tone.new(0,0,0,0), duration = 0)
    @tilemap_tone_target = tone.is_a?(Array) ? Tone.new(*tone) : tone.clone
    @tilemap_tone_duration = duration
    tilemap_tone_changing? || @tilemap_tone = @tilemap_tone_target.clone
  end
  #--------------------------------------------------------------------------
  # * New method: start_tilemap_opacity
  #--------------------------------------------------------------------------
  def start_tilemap_opacity(opacity = 255, duration = 0)
    @tilemap_opacity_target = opacity * 1.0
    @tilemap_opacity_duration = duration
    tilemap_opacity_changing? || @tilemap_opacity = @tilemap_opacity_target
  end
  #--------------------------------------------------------------------------
  # * New method: update_tilemap_tone
  #--------------------------------------------------------------------------
  def update_tilemap_tone
    if tilemap_tone_changing?
      d = @tilemap_tone_duration
      target = @tilemap_tone_target
      @tilemap_tone.red   = (@tilemap_tone.red   * (d - 1) + target.red) / d
      @tilemap_tone.green = (@tilemap_tone.green * (d - 1) + target.green) / d
      @tilemap_tone.blue  = (@tilemap_tone.blue  * (d - 1) + target.blue) / d
      @tilemap_tone.gray  = (@tilemap_tone.gray  * (d - 1) + target.gray) / d
      @tilemap_tone_duration -= 1
      tilemap_tone_changing? || @tilemap_tone = @tilemap_tone_target.clone
    end
  end
  #--------------------------------------------------------------------------
  # * New method: update_tilemap_opacity
  #--------------------------------------------------------------------------
  def update_tilemap_opacity
    if tilemap_opacity_changing?
      d = @tilemap_opacity_duration
      @tilemap_opacity = (@tilemap_opacity * (d - 1) +
      @tilemap_opacity_target) / d
      @tilemap_opacity_duration -= 1
      tilemap_opacity_changing? || @tilemap_opacity = @tilemap_opacity_target
    end
  end
  #--------------------------------------------------------------------------
  # * New method: start_zoom
  #--------------------------------------------------------------------------
  def start_zoom(x,y, zoom_target, duration=20)
    @x_zoom = x
    @y_zoom = y
    @zoom_target = zoom_target * 1.0
    @zoom_duration = @zoom_x == @zoom_target ? 0 : duration
    zooming? || zoom(@x_zoom,@y_zoom,@zoom_target)
  end
  #--------------------------------------------------------------------------
  # * New method: update_zooming
  #--------------------------------------------------------------------------
  def update_zooming
    if zooming?
      d = @zoom_duration
      power = (@zoom_x * (d - 1) + @zoom_target) / d
      @zoom_duration -= 1
      zoom(@x_zoom,@y_zoom,power)
      zoom(@x_zoom,@y_zoom,@zoom_target) unless zooming?
    end
  end
  #--------------------------------------------------------------------------
  # * Aliased method: update
  #--------------------------------------------------------------------------
  def update(*args)
    tilemap_effect_update(*args)
    update_tilemap_tone
    update_tilemap_opacity
    update_zooming
  end
end
#==============================================================================
# ** Interpreter
#------------------------------------------------------------------------------
#  This interpreter runs event commands. This class is used within the
#  Game_System class and the Game_Event class.
#==============================================================================
unless LiTTleDRAgo::VX
  class Interpreter
    #---------------------------------------------------------------------------
    # * Redirect Listing
    #---------------------------------------------------------------------------
    redirect_method :zoom,                  '$game_map.zoom'
    redirect_method :zoom_in,               '$game_map.zoom_in'
    redirect_method :zoom_out,              '$game_map.zoom_out'
    redirect_method :start_zoom,            '$game_map.start_zoom'
    redirect_method :start_tilemap_opacity, '$game_map.start_tilemap_opacity'
    redirect_method :start_tilemap_tone,    '$game_map.start_tilemap_tone'
    [:change_tilemap_tone,:change_character_tone].each do |meth|
      redirect_method :"#{meth}", :"$game_map.spriteset.#{meth}"
    end
  end
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles the player. Its functions include event starting
#  determinants and map scrolling. Refer to "$game_player" for the one
#  instance of this class.
#==============================================================================
class Game_Player
  #---------------------------------------------------------------------------
  # * Define Sec Listing
  #---------------------------------------------------------------------------
  define_sec_method(:center_x) {((Graphics.width/2)  / $game_map.zoom_x-16) * 4}
  define_sec_method(:center_y) {((Graphics.height/2) / $game_map.zoom_y-16) * 4}
  #-------------------------------------------------------------------------
  # * Alias Listing
  #-------------------------------------------------------------------------
  alias_sec_method(:drg_adjust_viewport_center, :center)
  #-------------------------------------------------------------------------
  # * Aliased method: center
  #-------------------------------------------------------------------------
  def center(x, y)
    if LiTTleDRAgo::XP
      Game_Player.const_set(:CENTER_X, center_x)
      Game_Player.const_set(:CENTER_Y, center_y)
    end
    drg_adjust_viewport_center(x, y)
    max_x = $game_map.map_edge.at(0) / $game_map.zoom_x
    max_y = $game_map.map_edge.at(1) / $game_map.zoom_y
    if LiTTleDRAgo::XP
      $game_map.display_x = [0, [(x * 32*4) - center_x, max_x.ceil].min].max
      $game_map.display_y = [0, [(y * 32*4) - center_y, max_y.ceil].min].max
    elsif $game_map.respond_to?(:set_display_pos)
      $game_map.set_display_pos(x - center_x, y - center_y)
    end
  end
end

#==============================================================================
# ** Tilemap
#------------------------------------------------------------------------------
#
#==============================================================================
class Tilemap
  #---------------------------------------------------------------------------
  # * Public Instance Variables
  #---------------------------------------------------------------------------
  method_defined?(:tileset)   || attr_accessor(:tileset)
  method_defined?(:priorities)|| attr_accessor(:priorities)
  method_defined?(:autotiles) || attr_sec_accessor(:autotiles,'Array.new')
end

#==============================================================================
# ** Table
#------------------------------------------------------------------------------
#
#==============================================================================
class Table
  #--------------------------------------------------------------------------
  # * Public Instance Variable
  #--------------------------------------------------------------------------
  attr_sec_accessor :table_changes, :orig_value, 'Array.new'
  attr_accessor     :make_changes
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias_sec_method :set_method, :"[]="
  #--------------------------------------------------------------------------
  # * Set Data
  #--------------------------------------------------------------------------
  def []=(*args)
    if @make_changes
      table_changes.push([*args]) && orig_value.push(self[*args[0..-2]])
      @make_changes = false
    end
    set_method(*args)
  end
  #--------------------------------------------------------------------------
  # * Reverse
  #--------------------------------------------------------------------------
  def reverse(rx=true,ry=true,rz=true)
    reverse = self.clone
    _x = (0...xsize).to_a
    _y = (0...ysize).to_a
    _z = (0...zsize).to_a
    _x.each do |x|
      _rx = rx ? _x[-1-x] : x
       ysize == 1 && (reverse[x] = self[_rx]) && next
      _y.each do |y|
        _ry = ry ? _y[-1-y] : y
        zsize == 1 && (reverse[x,y] = self[_rx,_ry]) && next
        _z.each do |z|
          _rz = rz ? _z[-1-z] : z
          reverse[x,y,z] = self[_rx,_ry,_rz]
        end
      end
    end
    reverse
  end
end

#==============================================================================
# ** RPG::Cache
#==============================================================================
ModCache = LiTTleDRAgo.cache
module ModCache
  #----------------------------------------------------------------------------
  # * Self
  #----------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # * Constant
    #--------------------------------------------------------------------------
    AUTO_INDEX = [[
      [27,28,33,34],  [ 5,28,33,34],  [27, 6,33,34],  [ 5, 6,33,34],
      [27,28,33,12],  [ 5,28,33,12],  [27, 6,33,12],  [ 5, 6,33,12],
      [27,28,11,34],  [ 5,28,11,34],  [27, 6,11,34],  [ 5, 6,11,34],
      [27,28,11,12],  [ 5,28,11,12],  [27, 6,11,12],  [ 5, 6,11,12],
      [25,26,31,32],  [25, 6,31,32],  [25,26,31,12],  [25, 6,31,12],
      [15,16,21,22],  [15,16,21,12],  [15,16,11,22],  [15,16,11,12],
      [29,30,35,36],  [29,30,11,36],  [ 5,30,35,36],  [ 5,30,11,36],
      [39,40,45,46],  [ 5,40,45,46],  [39, 6,45,46],  [ 5, 6,45,46],
      [25,30,31,36],  [15,16,45,46],  [13,14,19,20],  [13,14,19,12],
      [17,18,23,24],  [17,18,11,24],  [41,42,47,48],  [ 5,42,47,48],
      [37,38,43,44],  [37, 6,43,44],  [13,18,19,24],  [13,14,43,44],
      [37,42,43,48],  [17,18,47,48],  [13,18,43,48],  [ 1, 2, 7, 8]],

     [[27,28,33,34],  [49,50,55,56],  [51,52,57,58],  [49,52,55,58],
      [63,64,69,70],  [65,66,71,72],  [51,52,69,70],  [ 5, 6,33,12],
      [61,62,67,68],  [49,50,67,68],  [53,54,59,60],  [ 5, 6,11,34],
      [61,64,67,70],  [ 5,28,11,12],  [27, 6,11,12],  [ 5, 6,11,12],
      [25,26,31,32],  [25, 6,31,32],  [25,26,31,12],  [25, 6,31,12],
      [15,16,21,22],  [15,16,21,12],  [15,16,11,22],  [15,16,11,12],
      [29,30,35,36],  [29,30,11,36],  [ 5,30,35,36],  [ 5,30,11,36],
      [39,40,45,46],  [ 5,40,45,46],  [39, 6,45,46],  [ 5, 6,45,46],
      [25,30,31,36],  [15,16,45,46],  [13,14,19,20],  [13,14,19,12],
      [17,18,23,24],  [17,18,11,24],  [41,42,47,48],  [ 5,42,47,48],
      [37,38,43,44],  [37, 6,43,44],  [13,18,19,24],  [13,14,43,44],
      [37,42,43,48],  [17,18,47,48],  [13,18,43,48],  [ 1, 2, 7, 8]]
    ].freeze
    #--------------------------------------------------------------------------
    # * Public Instance Variable
    #--------------------------------------------------------------------------
    attr_sec_reader :cache, 'Hash.new'
    #--------------------------------------------------------------------------
    # * New method: autotile_cr_tilemap
    #--------------------------------------------------------------------------
    def autotile_cr_tilemap(filename)
      key = "Graphics/Autotiles/CR#{filename}"
      if !@cache.include?(key) || @cache[key].disposed?
        @cache[key] = (filename=='') ? Bitmap.new(128,96) : autotile(filename)
        new_bm = self.format_autotiles(@cache[key], filename)
        @cache[key].dispose
        @cache[key] = new_bm
        @cache[key].instance_variable_set(:@autotile_name, filename)
      end
      return @cache[key]
    end
    #--------------------------------------------------------------------------
    # * New method: include?
    #--------------------------------------------------------------------------
    unless method_defined?(:include?)
      def include?(key)
        @cache[key] && !@cache[key].disposed?
      end
    end
    #--------------------------------------------------------------------------
    # * New method: format_autotiles
    #--------------------------------------------------------------------------
    def format_autotiles(bitmap, filename)
      if bitmap.height > 32
        frames = bitmap.width / 96
        index = bitmap.height == 192 ? AUTO_INDEX[1] : AUTO_INDEX[0]
        template = Bitmap.new(256*frames,192)
        frames.times {|a| (0...6).each { |i| (0...8).each { |j|
          index[8*i+j].each { |number|
            number -= 1
            x, y = 16 * (number % 6), 16 * (number / 6)
            ox, oy = (32 * j + x % 32) + (a * 256), 32 * i + y % 32
            rect = Rect.new(x + (a * 96), y, 16, 16)
            template.blt(ox, oy, bitmap, rect)
        }}}}
        return template
      else
        return bitmap
      end
    end
    #--------------------------------------------------------------------------
    # * New method: tile
    #--------------------------------------------------------------------------
    unless method_defined?(:format_tile)
      def format_tile(bitmap, tile_id, hue)
        filename = bitmap.pathname
        key = [filename, tile_id, hue]
        unless include?(key)
          @cache[key] = empty_bitmap
          x = (tile_id - 384) % 8 * 32
          y = (tile_id - 384) / 8 * 32
          rect = Rect.new(x, y, 32, 32)
          @cache[key].blt(0, 0, bitmap, rect)
          @cache[key].hue_change(hue)
        end
        @cache[key]
      end
    end
    #--------------------------------------------------------------------------
    # * New method: clear_tile_cache
    #--------------------------------------------------------------------------
    def clear_tile_cache
      @cache ||= {}
      @cache.reject! do |keys|
        keys.is_a?(Array) && keys.size == 3 &&
        keys[0].is_a?(String) && keys[0].downcase["tilemap"]
      end
      GC.start
    end
  end
end

#==============================================================================
# ** Bitmap
#------------------------------------------------------------------------------
#
#==============================================================================
class Bitmap
  #--------------------------------------------------------------------------
  # * Public Instance Variable
  #--------------------------------------------------------------------------
  attr_sec_accessor :pathname, 'String.new'
  #--------------------------------------------------------------------------
  # ● Alias Method
  #--------------------------------------------------------------------------
  $@ || alias_method(:cr_path_init, :initialize)
  #--------------------------------------------------------------------------
  # ● Object Initialization
  #--------------------------------------------------------------------------
  def initialize(*args)
    @pathname = args.at(0) if args.at(0).is_a?(String)
    cr_path_init(*args)
  end
end
#==============================================================================
# ** RPG::Weather
#------------------------------------------------------------------------------
#  A class for weather effects (rain, storm, and snow). It is used within the
# Spriteset_Map class.
#==============================================================================
CRWeather = LiTTleDRAgo::VX ? Spriteset_Weather : RPG::Weather
class CRWeather
  #--------------------------------------------------------------------------
  # * Public Instance Variable
  #--------------------------------------------------------------------------
  attr_reader :viewport
  attr_accessor :zoom_x, :zoom_y
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  $@ || alias_method(:init_custom_resolution, :initialize)
  #--------------------------------------------------------------------------
  # * Aliased method: initialize
  #--------------------------------------------------------------------------
  def initialize(viewport)
    @viewport = viewport
    init_custom_resolution(@viewport)
  end
  #--------------------------------------------------------------------------
  # * Overwriten method: update
  #--------------------------------------------------------------------------
  def update
    return if @type == 0
    return if $game_map && $game_map.screen_is_solid?
    update_screen if respond_to?(:update_screen)
    @sprites.each {|sprite| update_sprite(sprite) }
  end
  #--------------------------------------------------------------------------
  # * Update Sprite
  #--------------------------------------------------------------------------
  def update_sprite(sprite)
    sprite.ox = @ox
    sprite.oy = @oy
    case @type
    when 1, :rain  then update_sprite_rain(sprite)
    when 2, :storm then update_sprite_storm(sprite)
    when 3, :snow  then update_sprite_snow(sprite)
    end
    create_new_particle(sprite) if sprite.opacity < 64
  end
  #--------------------------------------------------------------------------
  # * Update Sprite [Rain]
  #--------------------------------------------------------------------------
  def update_sprite_rain(sprite)
    sprite.bitmap = @rain_bitmap
    sprite.x -= 2 * sprite.zoom_x
    sprite.y += 16 * sprite.zoom_y
    sprite.opacity -= 8
  end
  #--------------------------------------------------------------------------
  # * Update Sprite [Storm]
  #--------------------------------------------------------------------------
  def update_sprite_storm(sprite)
    sprite.bitmap = @storm_bitmap
    sprite.x -= 8 * sprite.zoom_x
    sprite.y += 16 * sprite.zoom_y
    sprite.opacity -= 12
  end
  #--------------------------------------------------------------------------
  # * Update Sprite [Snow]
  #--------------------------------------------------------------------------
  def update_sprite_snow(sprite)
    sprite.bitmap = @snow_bitmap
    sprite.x -= 2 * sprite.zoom_x
    sprite.y += 8 * sprite.zoom_y
    sprite.opacity -= 8
  end
  #--------------------------------------------------------------------------
  # * Create New Particle
  #--------------------------------------------------------------------------
  def create_new_particle(sprite)
    sprite.x = rand(Graphics.width + 100) - 100 + @ox
    sprite.y = rand(Graphics.height + 200) - 200 + @oy
    sprite.zoom_x = @zoom_x || 1
    sprite.zoom_y = @zoom_y || 1
    sprite.x *= sprite.zoom_x
    sprite.y *= sprite.zoom_y
    sprite.opacity = 160 + rand(96)
  end
  #---------------------------------------------------------------------------
  # * New method: method_missing
  #---------------------------------------------------------------------------
  def method_missing(val,*a,&b)
    en = @sprites.flatten.find_all {|s|s.respond_to?(val.to_sym)}
    if en.empty?
      text = "Undefined method #{val} at #{self.inspect}"
      raise(NoMethodError,text,caller(1))
    end
    return en.map {|s| s.send(val.to_sym,*a,&b)}
  end
end

#==============================================================================
# ** Plane
#------------------------------------------------------------------------------
#  This class is the rewrite of the default plane class
#==============================================================================

class CRPlane < Sprite
  #---------------------------------------------------------------------------
  # * Public Instance Variable
  #---------------------------------------------------------------------------
  attr_reader :bitmap
  #---------------------------------------------------------------------------
  # * New method: z=
  #---------------------------------------------------------------------------
  def z=(z)
    super(z * 1000)
  end
  #---------------------------------------------------------------------------
  # * New method: ox=
  #---------------------------------------------------------------------------
  def ox=(ox)
    return if $game_map && $game_map.screen_is_solid?
    return if bitmap.nil? || bitmap.disposed?
    super(ox % bitmap.width)  if bitmap.is_a?(Bitmap)
  end
  #---------------------------------------------------------------------------
  # * New method: oy=
  #---------------------------------------------------------------------------
  def oy=(oy)
    return if $game_map && $game_map.screen_is_solid?
    return if bitmap.nil? || bitmap.disposed?
    super(oy % bitmap.height) if bitmap.is_a?(Bitmap)
  end
  #---------------------------------------------------------------------------
  # * New method: dispose
  #---------------------------------------------------------------------------
  def dispose
    @plane && (@plane.disposed? || @plane.dispose)
    super unless disposed?
  end
  #---------------------------------------------------------------------------
  # * New method: bitmap=
  #---------------------------------------------------------------------------
  def bitmap=(tile)
    return if @bitmap == tile
    @bitmap = tile
    if @bitmap.is_a?(Bitmap)
      xx = 1 + (Graphics.width.to_f / tile.width).ceil
      yy = 1 + (Graphics.height.to_f / tile.height).ceil
      @plane.dispose if @plane.respond_to?(:dispose) && @plane.not.disposed?
      @plane = Bitmap.new(@bitmap.width * xx, @bitmap.height * yy)
      (0..xx).each {|x| (0..yy).each {|y|
        @plane.blt(x * @bitmap.width, y * @bitmap.height, @bitmap, @bitmap.rect)
      }}
      super(@plane)
    else
      super(nil)
    end
  end
  #---------------------------------------------------------------------------
  # * Undefine methods dealing with coordinates to do nothing.
  #---------------------------------------------------------------------------
  undef :x, :x=, :y, :y=   if method_defined?(:x)
end

#==============================================================================
# ** Viewport
#------------------------------------------------------------------------------
#
#==============================================================================
class Viewport
  #--------------------------------------------------------------------------
  # * Overwriten method: update_viewport_sizes
  #--------------------------------------------------------------------------
  def update_viewport_sizes
    map = $game_map
    w, h = Graphics.width, Graphics.height
    hor = $game_map.loop_horizontal?
    ver = $game_map.loop_vertical?
    _w = ($game_map.width  * 32 * $game_map.zoom_x).floor
    _h = ($game_map.height * 32 * $game_map.zoom_y).floor
    dx = w > _w && !hor ? ((w - _w).floor.abs / 32) * 16 : 0
    dw = hor ? w : [w, $game_map.width  * 32 * $game_map.zoom_x].min
    dy = h > _h && !ver ? ((h - _h).floor.abs / 32) * 16 : 0
    dh = ver ? h : [h, $game_map.height * 32 * $game_map.zoom_y].min
    resize(Rect.new(dx, dy, dw, dh))
  end
end
#==============================================================================
# ** ZTilemap
#------------------------------------------------------------------------------
#  This class is the rewrite of the default tilemap class
#==============================================================================

class ZTilemap
  #---------------------------------------------------------------------------
  # * Public Instance Variables
  #---------------------------------------------------------------------------
  attr_reader       :map_data,  :viewport
  attr_accessor     :tileset,   :tone,    :priorities, :sprite_compact
  attr_sec_accessor :autotiles, 'Array.new'
  attr_sec_accessor :ox, :oy,   :zoom_x,  :zoom_y, :hue, 'Integer(1)'
  attr_sec_accessor :opacity,  'Integer(255)'
  attr_sec_reader   :layers, :bitmap_layers, :extra_map_data, 'Array.new'
  #---------------------------------------------------------------------------
  # * Redirect Listing
  #---------------------------------------------------------------------------
  redirect_method :width,       '$game_map.screen_tile_x + 2'
  redirect_method :height,      '$game_map.screen_tile_y + 2'
  #---------------------------------------------------------------------------
  # * Define Sec Listing
  #---------------------------------------------------------------------------
  define_sec_method(:all_sprites) { layers.flatten.select {|s| is_sprite?(s)}}
  define_sec_method(:is_sprite?)  { |s|  s.is_a?(Sprite) && s.not.disposed?  }
  #---------------------------------------------------------------------------
  # * Alias Listing
  #---------------------------------------------------------------------------
  alias_method :bitmaps, :autotiles
  #---------------------------------------------------------------------------
  # * Object Initialization
  #---------------------------------------------------------------------------
  def initialize(viewport)
    @viewport       = viewport
    @sprite_compact = false#LiTTleDRAgo::SPRITE_COMPACT
    create_sprites
    create_carrot
  end
  #---------------------------------------------------------------------------
  # * New method: create_sprites
  #---------------------------------------------------------------------------
  def create_sprites
    6.times do |i|
      layers[i] ||= []
      (i % 6 == 0 ? 1 : height).times do |s|
        layers[i][s] = Sprite.new(@viewport) unless is_sprite?(layers[i][s])
      end
      layers[i].each_with_index do |s,r|
        next unless is_sprite?(s)
        s.y = r * 32 * zoom_y
        s.z = (i % 6 == 0) ? 0 : (r * 32 + 32 + (i % 6) * 32)
        s.mirror = $game_map.reverse
      end
    end
  end
  #---------------------------------------------------------------------------
  # * New method: create_carrot
  #---------------------------------------------------------------------------
  def create_carrot
    @draw_tiles = carrot do |x,y,data,prio|
      [0,1,2].each do |r|
        if (id = data[x,y,r]).to_i == 0 || (layer = prio[id]).nil?
          next
        elsif @layer_clear && @layer_clear.not.include?(layer)
          @bitmap_layers[layer].fill_rect(x*32,y*32,32,32,Color.erase)
          @layer_clear.push(layer)
        end
        refresh_tiles(x,y,r,id)
      end
    end
    @change_tone         = carrot {|s| all_sprites.tone    = (@tone = s)   }
    @change_opacity      = carrot {|s| all_sprites.opacity = (@opacity = s)}
    @change_autotile_hue = carrot do |a,old,hue|
      [old.to_i != 0 && a.hue_change((old - 360).abs)] && a.hue_change(hue)
    end
  end
  #---------------------------------------------------------------------------
  # * New method: ox=, oy=, zoom_x=, zoom_y=
  #---------------------------------------------------------------------------
  [:ox, :oy, :zoom_x, :zoom_y].each do |a|
    meth = "def %1$s=(%1$s) (@%1$s != %1$s) && (@%1$s = %1$s) && %2$s end"
    module_eval(sprintf(meth, a ,'adjust_sprites'))
  end
  #---------------------------------------------------------------------------
  # * New method: tone=
  #---------------------------------------------------------------------------
  def tone=(*tone)
    new_tone = tone.flatten.size == 4 ? Tone.new(*tone.flatten) :
               tone.first.is_a?(Tone) ? tone.first : nil
    @tone.to_s == new_tone.to_s || @change_tone.call(new_tone.clone)
  end
  #---------------------------------------------------------------------------
  # * New method: opacity=
  #---------------------------------------------------------------------------
  def opacity=(opacity)
    opacity = [[opacity.round,255].min,0].max
    @opacity == opacity || @change_opacity.call(opacity)
  end
  #---------------------------------------------------------------------------
  # * New method: hue=
  #---------------------------------------------------------------------------
  def hue=(hue)
    return if @hue == (hue % 360)
    old = self.hue
    @hue = hue % 360
    all_autotiles = @autotiles + extra_map_data.map {|m| m[:autotiles]}.flatten
    @change_autotile_hue.call(all_autotiles.uniq, old, @hue)
    refresh
  end
  #---------------------------------------------------------------------------
  # * New method: Adjust Sprites
  #---------------------------------------------------------------------------
  def adjust_sprites
    @times_compact ||= []
    @layers_used && @layers.size.times do |i|
      layer = @layers[i]
      (i % 6 == 0 ? 1 : height).times do |r|
        sprite = layer[r]
        d = 32
        _r = 32 + (i % 6) * 32
        _y = r * 32 * zoom_y
        _z = i % 6 == 0 ? 0 : r * d + _r # (r * d + _r)
        unless is_sprite?(sprite)
          change = _y <= @viewport.height
          if @sprite_compact
            change &&= !char_out_range?(_r, (height-1)*d+_r)
            change &&= @layers_used[i] > 0
          end
          change || next
          sprite = (layer[r] = Sprite.new(@viewport))
          sprite.bitmap  = bitmap_layers[i]
          sprite.tone    = tone if tone
          sprite.opacity = opacity
          sprite.mirror  = $game_map.reverse
          sprite.zoom_x, sprite.zoom_y = zoom_x, zoom_y
        else
          change = _y > @viewport.height
          if (@times_compact[i] ||= 0) < 10 && @sprite_compact
            change ||=  (r > 0 && char_out_range?(_r, (height-1)*d+_r))
            change ||=  (r > 0 && @layers_used[i] == 0)
          end
          sprite.y, sprite.z = _y, _z.ceil
          change && [sprite.dispose, @times_compact[i] += 1] && next
        end
        sprite.y, sprite.z = _y, _z.ceil
        _wd = @viewport.width/zoom_x
        _ox = sprite.mirror ? (sprite.bitmap.width-ox)-_wd  : (_wd+=10) && ox
        if layer.select { |s| is_sprite?(s) }.size == 1
          sprite.src_rect.set(_ox, oy, _wd, @viewport.height/zoom_x + 10)
        else
          sprite.src_rect.set(_ox, (oy + r*32), _wd, 33)
        end
        sprite.zoom_x, sprite.zoom_y = zoom_x, zoom_y
      end
    end
  end
  #---------------------------------------------------------------------------
  # * New method: char_out_range?
  #---------------------------------------------------------------------------
  def char_out_range?(z1,z2)
    return false unless (s = $game_map.spriteset).is_a?(Spriteset_Map)
    s.character_sprites.all? do |d|
      d.not.disposed? && d.opacity > 0 && d.visible &&
      (d.z).not.between?(z1,z2)
    end
  end
  #---------------------------------------------------------------------------
  # * New method: Frame Dispose
  #---------------------------------------------------------------------------
  def dispose
    all_sprites.each   { |s| s.dispose }
    bitmap  = bitmap_layers
    bitmap += extra_map_data.map {|m| m[:autotiles]}.flatten - @autotiles
    bitmap += extra_map_data.map {|m| m[:tileset]}.flatten
    bitmap.compact.each { |s| s.disposed? || s.dispose }
    @layers.clear
    GC.start
  end
  #---------------------------------------------------------------------------
  # * New method: Change Map Data
  #---------------------------------------------------------------------------
  def map_data=(data)
    return if @map_data == data
    @map_data = data
    @map_data_reverse = data.reverse(true,false,false)
    6.times do |i|
      bitmap_layers[i].dispose if bitmap_layers[i] && bitmap_layers[i].disposed?
      bitmap_layers[i] =  Bitmap.new($game_map.width*32,$game_map.height*32)
      layers[i].each { |s| is_sprite?(s) && s.bitmap = bitmap_layers[i] }
    end
    refresh
  end
  #---------------------------------------------------------------------------
  # * New method: Map Data
  #---------------------------------------------------------------------------
  def map_data
    $game_map.reverse ? @map_data_reverse : @map_data
  end
  #---------------------------------------------------------------------------
  # * New method: Change priorities
  #---------------------------------------------------------------------------
  def priorities=(priorities)
    return if @priorities == priorities
    @priorities = priorities
    refresh
  end
  #---------------------------------------------------------------------------
  # * New method: Frame Refresh
  #---------------------------------------------------------------------------
  def refresh
    return unless @priorities && @map_data
    LiTTleDRAgo.cache.clear_tile_cache
    @animated_tiles   = []
    @unrefreshed_tile = []
    @layers_used      = []
    7.times do |i|
      @total_frames   = [] if i == 0
      @current_frame  = [] if i == 0
      bm = (@current_frame[i] = @layers_used[i] = 0) && autotiles[i]
      bm.nil? && @total_frames[i] = 1
      bm.nil? || @total_frames[i] = bm.width / (bm.height > 32 ? 256 : 32)
      extra_map_data.each do |data|
        data[:total_frames]  = [] if i == 0
        data[:current_frame] = [] if i == 0
        bm = (data[:current_frame][i] = 0) && data[:autotiles][i]
        bm.nil? && data[:total_frames][i] = 1
        bm.nil? || data[:total_frames][i] = bm.width / (bm.height>32 ? 256 : 32)
      end
    end
    _w = @viewport.width
    _h = @viewport.height
    layers[0][0].src_rect.set(ox, oy, _w/zoom_x, _h/zoom_y )
    (0...map_data.xsize).each do |x|
      (0...map_data.ysize).each do |y|
        if in_range?(x,y)
          update_map_changes(x,y)
        else
          next if @unrefreshed_tile.include?([x,y])
          @unrefreshed_tile.push([x,y])
          @unrefreshed_tile.uniq!
        end
      end
    end
    adjust_sprites
  end
  #---------------------------------------------------------------------------
  # * New method: Refresh Tiles
  #---------------------------------------------------------------------------
  def refresh_tiles(x,y,z,i,d = nil)
    return if i.nil? || i == 0
    i < 384 ? refresh_autotile(x,y,z,i,d) : refresh_regular_tile(x,y,z,i,d)
  end
  #---------------------------------------------------------------------------
  # * New method: Refresh Autotile
  #---------------------------------------------------------------------------
  def refresh_autotile(x,y,z,id,data)
    layer  = data.nil? ? @priorities[id]        : data[:priorities][id]
    tframe = data.nil? ? @total_frames          : data[:total_frames]
    cframe = data.nil? ? @current_frame         : data[:current_frame]
    bitmap = data.nil? ? @autotiles.at(id/48-1) : data[:autotiles].at(id/48-1)
    return if bitmap.nil? || layer.nil?
    div = (fid = id / 48 - 1) &&(id % 48)
    if @animated_tiles.not.include?([x,y]) && tframe[fid] > 1
      @animated_tiles.push([x,y])
      @animated_tiles.uniq!
    end
    rect = Rect.new((div % 8)*32 + cframe[fid] * 256, (div / 8)*32, 32, 32)
    bitmap_layers[layer].blt(x*32, y*32, bitmap, rect)
    @layers_used[layer] = [(@layers_used[layer] + 1) % 10000,1].max
  end
  #---------------------------------------------------------------------------
  # * New method: Refresh Regular Tile
  #---------------------------------------------------------------------------
  def refresh_regular_tile(x,y,z,id,data)
    tileset = data.nil? ? @tileset        : data[:tileset]
    layer   = data.nil? ? @priorities[id] : data[:priorities][id]
    return if layer.nil? || tileset.not.is_a?(Bitmap)
    bitmap  = LiTTleDRAgo.cache.format_tile(tileset, id, hue)
    bitmap_layers[layer].blt(x*32, y*32, bitmap, Rect.new(0, 0, 32, 32))
    @layers_used[layer] = [(@layers_used[layer] + 1) % 10000, 1].max
  end
  #---------------------------------------------------------------------------
  # * New method: force_refresh
  #---------------------------------------------------------------------------
  def force_refresh
    refresh
    (@unrefreshed_tile ||= []).each {|x,y| update_map_changes(x,y)}
    (@unrefreshed_tile.clear)
  end
  #---------------------------------------------------------------------------
  # * New method: Frame Update
  #---------------------------------------------------------------------------
  def update
    update_map_data
    update_autotile
    update_unrefreshed_tile
  end
  #---------------------------------------------------------------------------
  # * New method: Update Unrefreshed Tile
  #---------------------------------------------------------------------------
  def update_unrefreshed_tile
    if @unrefreshed_tile && @unrefreshed_tile.not.empty?
      unrefreshed = @unrefreshed_tile.select { |x,y| in_range?(x,y) }
      if unrefreshed.not.empty?
        (unrefreshed).each {|x,y| update_map_changes(x,y)}
        (@unrefreshed_tile -= unrefreshed) && adjust_sprites
      end
    end
  end
  #---------------------------------------------------------------------------
  # * New method: Update Map Data
  #---------------------------------------------------------------------------
  def update_map_data
    if map_data.table_changes.not.empty?
      map_data.table_changes.each do|item|
        x,y,z,tile_id = item
        update_map_changes(x,y)
      end
      map_data.table_changes.clear
      map_data.make_changes = false
      adjust_sprites
    end
  end
  #---------------------------------------------------------------------------
  # * New method: Update the autotile
  #---------------------------------------------------------------------------
  def update_autotile
    return if $game_map.screen_is_solid?
    speed = $game_map.autotile_speed
    total = [(@autotile_total || 0) / 10, 0].max
    if speed > 0 && Graphics.frame_count % (speed + total) == 0
      7.times do |i|
        extra_map_data.each do |data|
          next if (total = data[:total_frames].at(i)) == 0
          data[:current_frame][i] = (data[:current_frame].at(i) + 1) % total
        end
        next if (total = @total_frames.at(i)) == 0
        @current_frame[i] = (@current_frame.at(i) + 1) % total
      end
      animated = @animated_tiles.select { |x,y| in_range?(x,y) }
      animated.each {|x,y| update_map_changes(x,y) }
      @autotile_total = animated.size
    end
  end
  #---------------------------------------------------------------------------
  # * New method: in_range?
  #---------------------------------------------------------------------------
  def in_range?(x=nil,y=nil)
    return false if layers[0].nil? || layers[0][0].nil?
    rect = @layers[0][0].src_rect
    _x = x && (x * 32).between?(rect.x-32, rect.x + rect.width)
    _y = y && (y * 32).between?(rect.y-32, rect.y + rect.height)
    return _x && _y if x && y
    return _x if x
    return _y if y
    return false
  end
  #---------------------------------------------------------------------------
  # * New method: Update Map Changes
  #---------------------------------------------------------------------------
  def update_map_changes(x,y)
    @layer_clear ||= []
    @layer_clear.clear
    draw = [[x,y,map_data,priorities]]
    draw += extra_map_data.map {|data|[x,y,data[:map].data,data[:priorities]]}
    draw.each {|data| @draw_tiles.call(*data)}
  end
end
#==============================================================================
# ** Game_Character
#------------------------------------------------------------------------------
#  This class deals with characters. It's used as a superclass for the
#  determinants and map scrolling. Refer to "$game_player" for the one
#  Game_Player and Game_Event classes.
#==============================================================================
class Game_Character
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias_sec_method(:screen_x_before_zoom, :screen_x)
  alias_sec_method(:screen_y_before_zoom, :screen_y)
  alias_sec_method(:screen_z_before_zoom, :screen_z)
  #--------------------------------------------------------------------------
  # * Aliased method: screen_x
  #--------------------------------------------------------------------------
  def screen_x(*args)
    screen_x_before_zoom(*args) * $game_map.zoom_x
  end
  #--------------------------------------------------------------------------
  # * Aliased method: screen_y
  #--------------------------------------------------------------------------
  def screen_y(*args)
    screen_y_before_zoom(*args) * $game_map.zoom_y
  end
  #--------------------------------------------------------------------------
  # * Aliased method: screen_z
  #--------------------------------------------------------------------------
  def screen_z(*args)
    if self.is_a?(Game_Event)
      return 999                  if @always_on_top
      return $1.to_i              if self.name[/\<Z:\s*([-]?\d+)\s*\>/i]
      return screen_z_tilemap_fix if screen_z_tilemap_fix.is_a?(Integer)
    end
    return screen_z_before_zoom(*args)
  end
  #--------------------------------------------------------------------------
  # * New method: screen_z_tilemap_fix
  #--------------------------------------------------------------------------
  def screen_z_tilemap_fix
    LiTTleDRAgo::CHARACTER_Z_FIX.each do |key,value|
      if value.is_a?(Array) && key.is_a?(Integer)
        return key if value.any?{|v|"#{v}".downcase == @character_name.downcase}
      elsif key.is_a?(Array) && value.is_a?(Integer)
        return value if key.any?{|v|"#{v}".downcase == @character_name.downcase}
      elsif (key.is_a?(String) || key.is_a?(Symbol)) && value.is_a?(Integer)
        return value if "#{key}".downcase == @character_name.downcase
      end
    end
    return nil
  end
end

#==============================================================================
# ** Sprite_Character
#------------------------------------------------------------------------------
#  This sprite is used to display the character.It observes the Game_Character
#  class and automatically changes sprite conditions.
#==============================================================================
class Sprite_Character
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias_sec_method(:zoom_update_scrolling, :update)
  #--------------------------------------------------------------------------
  # * Aliased method: update
  #--------------------------------------------------------------------------
  def update(*args)
    if @old_character_zoom_x
      self.zoom_x = @old_character_zoom_x
      self.zoom_y = @old_character_zoom_y
    end
    zoom_update_scrolling(*args)
    @old_character_zoom_x = self.zoom_x
    @old_character_zoom_y = self.zoom_y
    self.zoom_x *= $game_map.zoom_x
    self.zoom_y *= $game_map.zoom_y
  end
  #--------------------------------------------------------------------------
  # * New method: in_range?
  #--------------------------------------------------------------------------
  unless method_defined?(:in_range?)
    def in_range?
      cw = self.src_rect ? self.src_rect.width : 32
      ch = self.src_rect ? self.src_rect.height : 32
      return @character.screen_x.round.between?(self.viewport.x - cw,
        self.viewport.x + self.viewport.width) &&
      @character.screen_y.round.between?(self.viewport.y - ch,
        self.viewport.y + self.viewport.height)
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  This class brings together map screen sprites, tilemaps, etc.
#  It's used within the Scene_Map class.
#==============================================================================
class Spriteset_Map
  #---------------------------------------------------------------------------
  # * Public Instance Variables
  #---------------------------------------------------------------------------
  attr_reader :character_sprites, :tilemap
  attr_reader :viewport1, :viewport2, :viewport3
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  $@ || alias_method(:init_drgcr_tilemap, :initialize)
  alias_sec_method(:update_drgcr_tilemap, :update)
  #--------------------------------------------------------------------------
  # * Aliased method: initialize
  #--------------------------------------------------------------------------
  def initialize(*args)
    check_autotile_height
    init_drgcr_tilemap(*args)
  end
  #---------------------------------------------------------------------------
  # * New method: check_autotile_height
  #---------------------------------------------------------------------------
  def check_autotile_height
    return unless LiTTleDRAgo::XP
    $game_map.autotile_names.each do |autotile_name|
      bitmap = ModCache.autotile(autotile_name)
      [@force_tilemap_enabled = true] && break if bitmap.height == 192
    end
  end
  #--------------------------------------------------------------------------
  # * Aliased method: update
  #--------------------------------------------------------------------------
  def update(*args)
    adjust_viewport
    adjust_tilemap
    adjust_old_zoom
    update_drgcr_tilemap(*args)
    update_tilemap_zoom
  end
  #---------------------------------------------------------------------------
  # * New method: adjust_old_zoom
  #---------------------------------------------------------------------------
  def adjust_old_zoom
    if @old_fog_zoom_x
      @fog.zoom_x = @old_fog_zoom_x
      @fog.zoom_y = @old_fog_zoom_y
      @panorama.zoom_x = @old_panorama_zoom_x
      @panorama.zoom_y = @old_panorama_zoom_y
    end
  end
  #---------------------------------------------------------------------------
  # * New method: viewport_sprite
  #---------------------------------------------------------------------------
  def viewport_sprite(*v)
    v.collect! {|s| s.is_a?(Symbol) ? instance_variable_get(:"@#{s}") : s }
    v.reject!  {|s| s.not.is_a?(Viewport)}
    all = instance_variables.map {|s| instance_variable_get("#{s}")}.flatten
    all.select {|s| s.respond_to?(:viewport) && v.include?(s.viewport)}
  end
  #---------------------------------------------------------------------------
  # * New method: change_tilemap_tone
  #---------------------------------------------------------------------------
  def change_tilemap_tone(tone = Tone.new(0,0,0,0), *char)
    if tone.is_a?(Array) && (3..4) === tone.size
      result = $game_map.tilemap_tone = Tone.new(*tone)
    elsif tone.is_a?(Tone)
      result = $game_map.tilemap_tone = tone
    else
      return
    end
    sprite = viewport_sprite(:viewport1)
    sprite.reject! {|s| s.is_a?(Sprite_Character)}
    sprite.each    {|s| s.tone = result if s.respond_to?(:tone=) }
    change_character_tone(tone, *char) unless char.empty?
  end
  #---------------------------------------------------------------------------
  # * New method: change_character_tone
  #---------------------------------------------------------------------------
  def change_character_tone(tone = Tone.new(0,0,0,0), *char)
    char = char.collect {|c| c.is_a?(Range) ? c.to_a : c}.flatten
    char = char.collect {|c| c.is_a?(Range) ? c.to_a : c}.flatten
    char.collect! {|c| c.is_a?(Game_Character) ? c :
                       $game_map.interpreter.get_character(c)}
    sprite = viewport_sprite(:viewport1)
    sprite.reject! {|s| s.not.is_a?(Sprite_Character) }
    sprite.reject! {|s| char.not.include?(s.character)}
    if tone.is_a?(Array) && (3..4) === tone.size
      sprite.tone(:tone=, Tone.new(*tone))
    elsif tone.is_a?(Tone)
      sprite.send(:tone=, tone)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: reload_tilemap
  #--------------------------------------------------------------------------
  def reload_tilemap
    return [dispose_tilemap, create_tilemap] if LiTTleDRAgo::VXA
    @tilemap.respond_to?(:dispose) && @tilemap.dispose
    7.times do |i|
      auto = @tilemap.autotiles[i]
      auto.respond_to?(:dispose) && (auto.disposed? || auto.dispose)
    end
    res = tilemap_enabled? ? ZTilemap : Tilemap
    @tilemap = res.new(@viewport1)
    @tilemap.tileset = ModCache.tileset($game_map.tileset_name)
    7.times do |i|
      autotile_name = $game_map.autotile_names[i]
      @tilemap.autotiles[i] = @tilemap.is_a?(ZTilemap) ?
      ModCache.autotile_cr_tilemap(autotile_name) :
      ModCache.autotile(autotile_name)
    end
    update_tilemap_effect
    @tilemap.priorities = $game_map.priorities
    @tilemap.map_data   = $game_map.data
    @tilemap.update
    @viewport_screen_width = 0
  end
  #--------------------------------------------------------------------------
  # * New method: reload_plane
  #--------------------------------------------------------------------------
  def reload_plane
    z1  = @panorama.respond_to?(:z) ? @panorama.z : -1000
    z2  = @fog.respond_to?(:z)      ? @fog.z      :  5000
    z1 /= 1000 if @panorama.is_a?(CRPlane)
    z2 /= 1000 if @fog.is_a?(CRPlane)
    res =  plane_enabled? ? CRPlane : Plane
    bitmap1 = @panorama.respond_to?(:bitmap) ? @panorama.bitmap : nil
    bitmap2 = @fog.respond_to?(:bitmap)      ? @fog.bitmap      : nil
    @panorama.respond_to?(:dispose) && @panorama.dispose
    @fog.respond_to?(:dispose) && @fog.dispose
    @panorama = res.new(@viewport1)
    @fog      = res.new(@viewport1)
    @panorama.bitmap = bitmap1 if bitmap1.is_a?(Bitmap)
    @fog.bitmap      = bitmap2 if bitmap2.is_a?(Bitmap)
    @panorama.z, @fog.z = z1, z2
    @viewport_screen_width = 0
  end
  #--------------------------------------------------------------------------
  # * New method: update_tilemap_zoom
  #--------------------------------------------------------------------------
  def update_tilemap_zoom
    @weather.zoom_x      = $game_map.zoom_x
    @weather.zoom_y      = $game_map.zoom_y
    @old_fog_zoom_x      = @fog.zoom_x
    @old_fog_zoom_y      = @fog.zoom_y
    @old_panorama_zoom_x = @panorama.zoom_x
    @old_panorama_zoom_y = @panorama.zoom_y
    @fog.zoom_x         *= $game_map.zoom_x
    @fog.zoom_y         *= $game_map.zoom_y
    @panorama.zoom_x    *= $game_map.zoom_x
    @panorama.zoom_y    *= $game_map.zoom_y
    update_tilemap_effect
  end
  #--------------------------------------------------------------------------
  # * New method: update_tilemap_effect
  #--------------------------------------------------------------------------
  def update_tilemap_effect
    return if @tilemap.not.is_a?(ZTilemap)
    @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
  end
  #--------------------------------------------------------------------------
  # * Overwriten method: viewport_size_change?
  #--------------------------------------------------------------------------
  def viewport_size_change?
    return true if @viewport_map_width  != $game_map.width  * $game_map.zoom_x
    return true if @viewport_map_height != $game_map.height * $game_map.zoom_y
    return true if @viewport_screen_width  != Graphics.width
    return true if @viewport_screen_height != Graphics.height
  end
  #--------------------------------------------------------------------------
  # * New method: adjust_viewport
  #--------------------------------------------------------------------------
  def adjust_viewport
    if viewport_size_change?
      @viewport_map_width     = $game_map.width * $game_map.zoom_x
      @viewport_map_height    = $game_map.height * $game_map.zoom_y
      @viewport_screen_width  = Graphics.width
      @viewport_screen_height = Graphics.height
      [@viewport1,@viewport2,@viewport3].compact.update_viewport_sizes
    end
  end
  #--------------------------------------------------------------------------
  # * New method: adjust_tilemap
  #--------------------------------------------------------------------------
  def adjust_tilemap
    if LiTTleDRAgo::XP
      if tilemap_enabled?
        reload_tilemap if @tilemap.is_a?(Tilemap)
      else
        reload_tilemap if @tilemap.is_a?(ZTilemap)
      end
    end
    if plane_enabled?
      reload_plane   if @panorama.is_a?(Plane)   || @fog.is_a?(Plane)
    else
      reload_plane   if @panorama.is_a?(CRPlane) || @fog.is_a?(CRPlane)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: tilemap_enabled?
  #--------------------------------------------------------------------------
  def tilemap_enabled?
    return true if @force_tilemap_enabled
    return true unless LiTTleDRAgo::RGSS1
    return true unless @viewport1.width <= 640 && @viewport1.height <= 480
    return true unless (map = $game_map) && map.zoom_x * map.zoom_y == 1
    return true unless map.tilemap_opacity >= 255
    return true unless map.tilemap_hue <= 0
    return true unless map.tilemap_tone.to_s.get_int == 0
    return true if map.reverse
    return false
  end
  #--------------------------------------------------------------------------
  # * New method: plane_enabled?
  #--------------------------------------------------------------------------
  def plane_enabled?
    return true unless LiTTleDRAgo::RGSS1
    return true unless @viewport1.width <= 640 && @viewport1.height <= 480
    return false
  end
end