#==============================================================================
# Tilemap Class
#------------------------------------------------------------------------------
# Script by SephirothSpawn
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  attr_reader   :map
  attr_accessor :tilemap_tone
  attr_accessor :tilemap_plane
  attr_accessor :tilemap_zoom_x
  attr_accessor :tilemap_zoom_y
  attr_accessor :tilemap_tile_width
  attr_accessor :tilemap_tile_height
  #--------------------------------------------------------------------------
  alias seph_tilemap_gmap_init initialize
  def initialize
    seph_tilemap_gmap_init
    @tilemap_tone        = nil
    @tilemap_plane       = false
    @tilemap_zoom_x      = 1.0
    @tilemap_zoom_y      = 1.0
    @tilemap_tile_width  = 32
    @tilemap_tile_height = 32
  end
  #--------------------------------------------------------------------------
end


class Tilemap
  #--------------------------------------------------------------------------
  Animated_Autotiles_Frames = 15
  #--------------------------------------------------------------------------
  Autotiles = [
    [ [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] ]
  ]
  #--------------------------------------------------------------------------
  attr_reader   :layers
  attr_accessor :tileset
  attr_accessor :autotiles
  attr_accessor :map_data
  attr_accessor :flash_data
  attr_accessor :priorities
  attr_accessor :visible
  attr_accessor :ox
  attr_accessor :oy
  #--------------------------------------------------------------------------
  def initialize(viewport, map = $game_map.map)
    @layers = []
    for l in 0...3
      layer = ($game_map.tilemap_plane ?
      Plane.new(viewport) : Sprite.new(viewport))
      layer.bitmap = Bitmap.new(map.width * 32, map.height * 32)
      layer.z = l * 150
      layer.zoom_x = $game_map.tilemap_zoom_x
      layer.zoom_y = $game_map.tilemap_zoom_y
      if (tone = $game_map.tilemap_tone).is_a?(Tone)
        layer.tone = tone
      end
      @layers << layer
    end
    @tileset    = nil  # Refers to Map Tileset Name
    @autotiles  = []   # Refers to Tileset Auto-Tiles (Actual Auto-Tiles)
    @map_data   = nil  # Refers to 3D Array Of Tile Settings
    @flash_data = nil  # Refers to 3D Array of Tile Flashdata
    @priorities = nil  # Refers to Tileset Priorities
    @visible    = true # Refers to Tilest Visibleness
    @ox         = 0    # Bitmap Offsets
    @oy         = 0    # bitmap Offsets
    @data       = nil  # Acts As Refresh Flag
    @map         = map
    @tone        = $game_map.tilemap_tone
    @plane       = $game_map.tilemap_plane
    @zoom_x      = $game_map.tilemap_zoom_x
    @zoom_y      = $game_map.tilemap_zoom_y
    @tile_width  = $game_map.tilemap_tile_width
    @tile_height = $game_map.tilemap_tile_height
  end
  #--------------------------------------------------------------------------
  def dispose
    for layer in @layers
      layer.dispose
    end
  end
  #--------------------------------------------------------------------------
  def update
    unless @data == @map_data && @tile_width == $game_map.tilemap_tile_width &&
           @tile_height == $game_map.tilemap_tile_height
      refresh
    end
    unless @tone == $game_map.tilemap_tone
      @tone = $game_map.tilemap_tone
      @tone = Tone.new(0, 0, 0, 0) if @tone.nil?
      for layer in @layers
        layer.tone = @tone
        layer.tone = @tone
      end
    end
    unless @zoom_x == $game_map.tilemap_zoom_x
      @zoom_x = $game_map.tilemap_zoom_x
      for layer in @layers
        layer.zoom_x = @zoom_x
        layer.zoom_x = @zoom_x
      end
    end
    unless @zoom_y == $game_map.tilemap_zoom_y
      @zoom_y = $game_map.tilemap_zoom_y
      for layer in @layers
        layer.zoom_y = @zoom_y
        layer.zoom_y = @zoom_y
      end
    end
    for layer in @layers
      layer.ox = @ox
      layer.oy = @oy
    end
    if Graphics.frame_count % Animated_Autotiles_Frames == 0
      refresh_autotiles
    end
  end
  #--------------------------------------------------------------------------
  def refresh
    @data = @map_data
    for p in 0..5
      for z in 0...@map_data.zsize
        for x in 0...@map_data.xsize
          for y in 0...@map_data.ysize
            id = @map_data[x, y, z]
            next if id == 0
            next unless p == @priorities[id]
            p = 2 if p > 2
            id < 384 ? draw_autotile(x, y, p, id) : draw_tile(x, y, p, id)
          end
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  def refresh_autotiles
    autotile_locations = Table.new(@map_data.xsize, @map_data.ysize,
      @map_data.zsize)
    for p in 0..5
      for z in 0...@map_data.zsize
        for x in 0...@map_data.xsize
          for y in 0...@map_data.ysize
            id = @map_data[x, y, z]
            next if id == 0
            next unless p == @priorities[id]
            p = 2 if p > 2
            if id < 384
              next unless @autotiles[id / 48 - 1].width / 96 > 1
              draw_autotile(x, y, p, id)
              autotile_locations[x, y, z] = 1
            else
              if autotile_locations[x, y, z] == 1
                draw_tile(x, y, p, id)
              end
            end
          end
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  def draw_tile(x, y, z, id)
    rect = Rect.new((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
    x *= @tile_width
    y *= @tile_height
    if @tile_width == 32 && @tile_height == 32
      @layers[z].bitmap.blt(x, y, @tileset, rect)
    else
      dest_rect = Rect.new(x, y, @tile_width, @tile_height)
      @layers[z].bitmap.stretch_blt(dest_rect, @tileset, rect)
    end
  end
  #--------------------------------------------------------------------------
  def draw_autotile(x, y, z, tile_id)
    autotile = @autotiles[tile_id / 48 - 1]
    tile_id %= 48
    bitmap = Bitmap.new(32, 32)
    tiles = Autotiles[tile_id / 8][tile_id % 8]
    frames = autotile.width / 96
    anim = (Graphics.frame_count / Animated_Autotiles_Frames) % frames * 96
    for i in 0...4
      tile_position = tiles[i] - 1
      src_rect = Rect.new(tile_position % 6 * 16 + anim,
        tile_position / 6 * 16, 16, 16)
      bitmap.blt(i % 2 * 16, i / 2 * 16, autotile, src_rect)
    end
    x *= @tile_width
    y *= @tile_height
    if @tile_width == 32 && @tile_height == 32
      @layers[z].bitmap.blt(x, y, bitmap, Rect.new(0, 0, 32, 32))
    else
      dest_rect = Rect.new(x, y, @tile_width, @tile_height)
      @layers[z].bitmap.stretch_blt(dest_rect, bitmap, Rect.new(0, 0, 32, 32))
    end
  end
  #--------------------------------------------------------------------------
  def bitmap
    bitmap = Bitmap.new(@layers[0].bitmap.width, @layers[0].bitmap.height)
    for layer in @layers
      bitmap.blt(0, 0, layer.bitmap, Rect.new(0, 0,
        bitmap.width, bitmap.height))
    end
    return bitmap
  end
  #--------------------------------------------------------------------------
end

Expand to see the code.

#==============================================================================
# Custom Resolution Script v0.82
#------------------------------------------------------------------------------
# Script by BlueScope
#==============================================================================

module Setup
  #--------------------------------------------------------------------------
  RESOLUTION = [(320).to_f, (240).to_f]
  #--------------------------------------------------------------------------
  def self.x_value
    return RESOLUTION[0] / 640
  end
  #--------------------------------------------------------------------------
  def self.y_value
    return RESOLUTION[1] / 480
  end
  #--------------------------------------------------------------------------
  def self.c_value
    return ((RESOLUTION[0] / 640) + (RESOLUTION[1] / 480)) / 2
  end
  #--------------------------------------------------------------------------
  def self.h_value
    return RESOLUTION[0]
  end
  #--------------------------------------------------------------------------
  def self.v_value
    return RESOLUTION[1]
  end
  #--------------------------------------------------------------------------
  def self.variance
    return (((RESOLUTION[0] / 640) + (RESOLUTION[1] / 480)) / 2) - 1
  end
  #--------------------------------------------------------------------------
end


module Resolution
  #--------------------------------------------------------------------------
  # The following method refers to the resolution changing script and has to
  # be placed below Selwyn's resolution script in order to work properly
  #--------------------------------------------------------------------------
  def self.fullscreen
    @default_size = size
    @set_window_long.call(@window, -16, 0x14000000)
    @set_window_pos.call(@window, -1, 0, 0, Setup.h_value, Setup.v_value, 64)
    @set_resolution.call(Setup.h_value, Setup.v_value, 4)
    @state = "fullscreen"
  end
  #--------------------------------------------------------------------------
end


class Sprite_Character < RPG::Sprite
  #--------------------------------------------------------------------------
  attr_accessor :character
  #--------------------------------------------------------------------------
  alias resolution_update update
  def update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name, @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name, @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch - (32 * Setup.variance)
      end
    end
    resolution_update
  end
  #--------------------------------------------------------------------------
end


class Spriteset_Map
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    @viewport1 = Viewport.new(0, 0, Setup.h_value, Setup.v_value)
    @viewport2 = Viewport.new(0, 0, Setup.h_value, Setup.v_value)
    @viewport3 = Viewport.new(0, 0, Setup.h_value, Setup.v_value)
    resolution_initialize
  end
  #--------------------------------------------------------------------------
end


class Game_Map
  #--------------------------------------------------------------------------
  # The following method refers to the Tilemap class and has to be placed
  # below SephirothSpawn's Tilemap class rewrite in order to work properly
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    resolution_initialize
    @tilemap_tile_width = (32 * Setup.x_value)
    @tilemap_tile_height = (32 * Setup.y_value)
  end
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    @display_y = [@display_y + distance, (self.height - 15) * (128 * Setup.y_value)].min
  end
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    @display_x = [@display_x + distance, (self.width - 20) * (128 * Setup.x_value)].min
  end
  #--------------------------------------------------------------------------
  def start_scroll(direction, distance, speed)
    @scroll_direction = direction
    @scroll_rest = distance * (128 * Setup.c_value)
    @scroll_speed = speed
  end
  #--------------------------------------------------------------------------
end


class Game_Character
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    resolution_initialize
    @move_speed = 4 + (Setup.variance * 2)
  end
  #--------------------------------------------------------------------------
  def moving?
    return (@real_x != @x * (128 * Setup.x_value) or @real_y != @y * (128 * Setup.y_value))
  end
  #--------------------------------------------------------------------------
  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    @real_x = @x * (128 * Setup.x_value)
    @real_y = @y * (128 * Setup.y_value)
    @prelock_direction = 0
  end
  #--------------------------------------------------------------------------
  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + (16 * Setup.x_value)
  end
  #--------------------------------------------------------------------------
  alias resolution_screen_y screen_y
  def screen_y
    y = (@real_y - $game_map.display_y + 3) / 4 + (32 * Setup.y_value)
    resolution_screen_y
  end
  #--------------------------------------------------------------------------
  def screen_z(height = 0)
    if @always_on_top
      return 999
    end
    z = (@real_y - $game_map.display_y + 3) / 4 + (32 * Setup.c_value)
    if @tile_id > 0
      return z + $game_map.priorities[@tile_id] * (32 * Setup.c_value)
    else
      return z + ((height > 32) ? 31 : 0)
    end
  end
  #--------------------------------------------------------------------------
  alias resolution_update update
  def update
    resolution_update
    if @anime_count > 18 - @move_speed * (2 - (Setup.variance * 2))
      if not @step_anime and @stop_count > 0
        @pattern = @original_pattern
      else
        @pattern = (@pattern + 1) % 4
      end
      @anime_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def update_jump
    @jump_count -= 1
    @real_x = (@real_x * @jump_count + @x * (128 * Setup.x_value)) / (@jump_count + 1)
    @real_y = (@real_y * @jump_count + @y * (128 * Setup.y_value)) / (@jump_count + 1)
  end
  #--------------------------------------------------------------------------
  def update_move
    distance = 2 ** @move_speed
    if @y * (128 * Setup.y_value) > @real_y
      @real_y = [@real_y + distance, @y * (128 * Setup.y_value)].min
    end
    if @x * (128 * Setup.x_value) < @real_x
      @real_x = [@real_x - distance, @x * (128 * Setup.x_value)].max
    end
    if @x * (128 * Setup.x_value) > @real_x
      @real_x = [@real_x + distance, @x * (128 * Setup.x_value)].min
    end
    if @y * (128 * Setup.y_value) < @real_y
      @real_y = [@real_y - distance, @y * (128 * Setup.y_value)].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end
  #--------------------------------------------------------------------------
end


class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  CENTER_X = ((320 * Setup.x_value) - 8) * 4
  CENTER_Y = ((240 * Setup.y_value) - 8) * 4
  #--------------------------------------------------------------------------
  def center(x, y)
    max_x = ($game_map.width - 20) * (128 * Setup.x_value)
    max_y = ($game_map.height - 15) * (128 * Setup.y_value)
    $game_map.display_x = [0, [x * (128 * Setup.x_value) - CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * (128 * Setup.y_value) - CENTER_Y, max_y].min].max
  end
  #--------------------------------------------------------------------------
end


class Window_Message < Window_Selectable
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    resolution_initialize
    self.x = 80 *- Setup.variance
    self.width = 480 *- Setup.variance
    self.height = 160 *- Setup.variance
    self.contents.font.name = 'Verdana'
    self.contents.font.size = Font.default_size * -Setup.variance
  end
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    x = y = 0
    @cursor_width = 0
    if $game_temp.choice_start == 0
      x = 8
    end
    if $game_temp.message_text != nil
      text = $game_temp.message_text
      begin
        last_text = text.clone
        text.gsub!(/\\[Vv]\[([0-9]+)\]/) { $game_variables[$1.to_i] }
      end until text == last_text
      text.gsub!(/\\[Nn]\[([0-9]+)\]/) do
        $game_actors[$1.to_i] != nil ? $game_actors[$1.to_i].name : ""
      end
      text.gsub!(/\\\\/) { "\000" }
      text.gsub!(/\\[Cc]\[([0-9]+)\]/) { "\001[#{$1}]" }
      text.gsub!(/\\[Gg]/) { "\002" }
      while ((c = text.slice!(/./m)) != nil)
        if c == "\000"
          c = "\\"
        end
        if c == "\001"
          text.sub!(/\[([0-9]+)\]/, "")
          color = $1.to_i
          if color >= 0 and color <= 7
            self.contents.font.color = text_color(color)
          end
          next
        end
        if c == "\002"
          if @gold_window == nil
            @gold_window = Window_Gold.new
            @gold_window.x = (Setup.h_value * 0.875) - @gold_window.width
            if $game_temp.in_battle
              @gold_window.y = (Setup.h_value / 10) * 3
            else
              @gold_window.y = self.y >= (128 * Setup.variance) ?
                (32 * Setup.variance) : (384 * Setup.variance)
            end
            @gold_window.opacity = self.opacity
            @gold_window.back_opacity = self.back_opacity
          end
          next
        end
        if c == "\n"
          if y >= $game_temp.choice_start
            @cursor_width = [@cursor_width, x].max
          end
          y += 1
          x = 0
          if y >= $game_temp.choice_start
            x = 8
          end
          next
        end
        draw_y = (26 *- Setup.variance) * y - (24 *- Setup.variance)
        self.contents.draw_text(4 *- Setup.variance + x, draw_y, 40, 32, c)
        x += self.contents.text_size(c).width
      end
    end
    if $game_temp.choice_max > 0
      @item_max = $game_temp.choice_max
      self.active = true
      self.index = 0
    end
    if $game_temp.num_input_variable_id > 0
      digits_max = $game_temp.num_input_digits_max
      number = $game_variables[$game_temp.num_input_variable_id]
      @input_number_window = Window_InputNumber.new(digits_max)
      @input_number_window.number = number
      @input_number_window.x = self.x + 8
      @input_number_window.y = self.y + $game_temp.num_input_start * 32
    end
  end
  #--------------------------------------------------------------------------
  def reset_window
    if $game_temp.in_battle
      self.y = (16 * Setup.variance)
    else
      case $game_system.message_position
      when 0
        self.y = (16 *- Setup.variance)
      when 1
        self.y = (160 *- Setup.variance)
      when 2
        self.y = (304 *- Setup.variance)
      end
    end
    if $game_system.message_frame == 0
      self.opacity = 255
    else
      self.opacity = 0
    end
    self.back_opacity = 160
  end
  #--------------------------------------------------------------------------
  def update_cursor_rect
    if @index >= 0
      n = $game_temp.choice_start + @index
      self.cursor_rect.set(8, n * (24 *- Setup.variance), @cursor_width,
        (24 *- Setup.variance))
    else
      self.cursor_rect.empty
    end
  end
  #--------------------------------------------------------------------------
end


begin
  Resolution.initialize
  Resolution.fullscreen
  $scene = nil
end

Expand to see the code.

#==============================================================================
# Custom Resolution Plugin :: Scene_Title
#------------------------------------------------------------------------------
# Script by BlueScope
#==============================================================================

class Scene_Title
  #--------------------------------------------------------------------------
  def main
    if $BTEST
      battle_test
      return
    end
    $data_actors        = load_data("Data/Actors.rxdata")
    $data_classes       = load_data("Data/Classes.rxdata")
    $data_skills        = load_data("Data/Skills.rxdata")
    $data_items         = load_data("Data/Items.rxdata")
    $data_weapons       = load_data("Data/Weapons.rxdata")
    $data_armors        = load_data("Data/Armors.rxdata")
    $data_enemies       = load_data("Data/Enemies.rxdata")
    $data_troops        = load_data("Data/Troops.rxdata")
    $data_states        = load_data("Data/States.rxdata")
    $data_animations    = load_data("Data/Animations.rxdata")
    $data_tilesets      = load_data("Data/Tilesets.rxdata")
    $data_common_events = load_data("Data/CommonEvents.rxdata")
    $data_system        = load_data("Data/System.rxdata")
    $game_system = Game_System.new
    @sprite = Sprite.new
    @sprite.bitmap = RPG::Cache.title($data_system.title_name)
    @sprite.zoom_x = Setup.x_value
    @sprite.zoom_y = Setup.y_value
    s1 = "New Game"
    s2 = "Continue"
    s3 = "Shutdown"
    @command_window = Window_Command.new(192, [s1, s2, s3])
    @command_window.back_opacity = 160
    @command_window.x = (320 * Setup.x_value) - @command_window.width / 2
    @command_window.y = (240 * Setup.y_value) - @command_window.height / 2
    @continue_enabled = false
    for i in 0..3
      if FileTest.exist?("Save#{i+1}.rxdata")
        @continue_enabled = true
      end
    end
    if @continue_enabled
      @command_window.index = 1
    else
      @command_window.disable_item(1)
    end
    $game_system.bgm_play($data_system.title_bgm)
    Audio.me_stop
    Audio.bgs_stop
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      Resolution.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @command_window.dispose
    @sprite.bitmap.dispose
    @sprite.dispose
  end
  #--------------------------------------------------------------------------
end

Expand to see the code.

# Custom Resolution Script v0.82
#------------------------------------------------------------------------------
# Script by BlueScope


module Setup
  #--------------------------------------------------------------------------
  RESOLUTION = [(320).to_f, (240).to_f]
  #--------------------------------------------------------------------------
  def self.x_value
    return RESOLUTION[0] / 640
  end
  #--------------------------------------------------------------------------
  def self.y_value
    return RESOLUTION[1] / 480
  end
  #--------------------------------------------------------------------------
  def self.c_value
    return ((RESOLUTION[0] / 640) + (RESOLUTION[1] / 480)) / 2
  end
  #--------------------------------------------------------------------------
  def self.h_value
    return RESOLUTION[0]
  end
  #--------------------------------------------------------------------------
  def self.v_value
    return RESOLUTION[1]
  end
  #--------------------------------------------------------------------------
  def self.variance
    return (((RESOLUTION[0] / 640) + (RESOLUTION[1] / 480)) / 2) - 1
  end
  #--------------------------------------------------------------------------
end


#BEGIN CLASS

#Script made by Squall squall@loeher.znn.com

class Win32API

  #CONSTANTS

  SCREEN_WIDTH = 240
  SCREEN_HEIGHT = 160
  GAME_INI_FILE = ".\\Game.ini"         # define "Game.ini" file
  HWND_TOPMOST = 0                      # window always active
  HWND_TOP = 0                         # window active when used only
  SWP_NOMOVE   = 0                      # window pos and sizes can be changed

  #Win32API.GetPrivateProfileString

  #Checks your game's title in Game.ini
  def Win32API.GetPrivateProfileString(section, key)
    val = "\0"*256
    gps = Win32API.new('kernel32','GetPrivateProfileString',%w(p p p p l p),'l')
    gps.call(section, key, "", val, 256, GAME_INI_FILE)
    val.delete!("\0")
    return val
  end

  #Win32API.FindWindow

  #Finds the RGSS Window
  def Win32API.FindWindow(class_name, title)
    fw = Win32API.new('user32', 'FindWindow', %(p, p), 'i')
    hWnd = fw.call(class_name, title)
    return hWnd
  end

  #Win32API.SetWindowPos

  #Changes Window position and size
  def Win32API.SetWindowPos(w, h)
    title =  Win32API.GetPrivateProfileString("Game", "Title")
    hWnd = Win32API.FindWindow("RGSS Player", title)
    swp = Win32API.new('user32', 'SetWindowPos', %(l, l, i, i, i, i, i), 'i')
    win = swp.call(hWnd, HWND_TOP, 0, 0, w + 6, h + 32, 0)
    #the line below makes the window on top of all others
    @gsm = Win32API.new('user32', 'GetSystemMetrics', 'I', 'I')
    @default_width = @gsm.call(0)
    @default_height = @gsm.call(1)
    win = swp.call(hWnd, HWND_TOPMOST, ((@default_width-w)/2),
    ((@default_height-h)/2), w + 6, h + 32, SWP_NOMOVE)
    return win
  end

  #Win32API.client_size

  #Checks the Window's width and height
  def Win32API.client_size
    title =  Win32API.GetPrivateProfileString("Game", "Title")
    hWnd = Win32API.FindWindow("RGSS Player", title)
    rect = [0, 0, 0, 0].pack('l4')
    Win32API.new('user32', 'GetClientRect', %w(l p), 'i').call(hWnd, rect)
    width, height = rect.unpack('l4')[2..3]
    return width, height
  end

#END CLASS

end 

class Sprite_Character < RPG::Sprite
  #--------------------------------------------------------------------------
  attr_accessor :character
  #--------------------------------------------------------------------------
  alias resolution_update update
  def update
    resolution_update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name, @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16 * Setup.variance
        self.oy = 32 * (1 / Setup.c_value)
      else
        self.bitmap = RPG::Cache.character(@character.character_name, @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = (@cw / 2) - (16 * Setup.variance)
        self.oy = @ch + (64 * Setup.variance)
      end
    end
    if Setup.variance < 1
      self.zoom_x = 0.50
      self.zoom_y = 0.50
    else
      self.zoom_x = 1.00
      self.zoom_y = 1.00
    end
    x = @character.screen_x
    newx = x# / 2# * Setup.x_value
    y = @character.screen_y
    newy = y# / 2# * Setup.y_value
    self.x = newx
    self.y = newy
  end
  #--------------------------------------------------------------------------
end


class Spriteset_Map
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    @viewport1 = Viewport.new(0, 0, Setup.h_value, Setup.v_value)
    @viewport2 = Viewport.new(0, 0, Setup.h_value, Setup.v_value)
    @viewport3 = Viewport.new(0, 0, Setup.h_value, Setup.v_value)
    resolution_initialize
  end
  #--------------------------------------------------------------------------
end


class Game_Map
  #--------------------------------------------------------------------------
  # The following method refers to the Tilemap class and has to be placed
  # below SephirothSpawn's Tilemap class rewrite in order to work properly
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    resolution_initialize
    @tilemap_tile_width = (32 * Setup.x_value)
    @tilemap_tile_height = (32 * Setup.y_value)
  end
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    @display_y = [@display_y + distance, (self.height - 15) * (128 * Setup.y_value)].min
  end
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    @display_x = [@display_x + distance, (self.width - 20) * (128 * Setup.x_value)].min
  end
  #--------------------------------------------------------------------------
  def start_scroll(direction, distance, speed)
    @scroll_direction = direction
    @scroll_rest = distance * (128 * Setup.c_value)
    @scroll_speed = speed
  end
  #--------------------------------------------------------------------------
end


class Game_Character
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    resolution_initialize
    @move_speed = 4 + (Setup.variance * 2)
  end
  #--------------------------------------------------------------------------
  def moving?
    return (@real_x != @x * (128 * Setup.x_value) or @real_y != @y * (128 * Setup.y_value))
  end
  #--------------------------------------------------------------------------
  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    @real_x = @x * (128 * Setup.x_value)
    @real_y = @y * (128 * Setup.y_value)
    @prelock_direction = 0
  end
  #--------------------------------------------------------------------------
  def screen_x
    return (@real_x - $game_map.display_x + 3) / 4 + (16 * Setup.x_value)
  end
  #--------------------------------------------------------------------------
  def screen_y
    y = (@real_y - $game_map.display_y + 3) / 4 + (32 * Setup.y_value)
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end
  #--------------------------------------------------------------------------
  def screen_z(height = 0)
    if @always_on_top
      return 999
    end
    z = (@real_y - $game_map.display_y + 3) / 4 + (32 * Setup.c_value)
    if @tile_id > 0
      return z + $game_map.priorities[@tile_id] * (32 * Setup.c_value)
    else
      return z + ((height > 32) ? 31 : 0)
    end
  end
  #--------------------------------------------------------------------------
  alias resolution_update update
  def update
    resolution_update
    if @anime_count > 18 - @move_speed * (2 - (Setup.variance * 2))
      if not @step_anime and @stop_count > 0
        @pattern = @original_pattern
      else
        @pattern = (@pattern + 1) % 4
      end
      @anime_count = 0
    end
  end
  #--------------------------------------------------------------------------
  def update_jump
    @jump_count -= 1
    @real_x = (@real_x * @jump_count + @x * (128 * Setup.x_value)) / (@jump_count + 1)
    @real_y = (@real_y * @jump_count + @y * (128 * Setup.y_value)) / (@jump_count + 1)
  end
  #--------------------------------------------------------------------------
  def update_move
    distance = 2 ** @move_speed
    if @y * (128 * Setup.y_value) > @real_y
      @real_y = [@real_y + distance, @y * (128 * Setup.y_value)].min
    end
    if @x * (128 * Setup.x_value) < @real_x
      @real_x = [@real_x - distance, @x * (128 * Setup.x_value)].max
    end
    if @x * (128 * Setup.x_value) > @real_x
      @real_x = [@real_x + distance, @x * (128 * Setup.x_value)].min
    end
    if @y * (128 * Setup.y_value) < @real_y
      @real_y = [@real_y - distance, @y * (128 * Setup.y_value)].max
    end
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end
  #--------------------------------------------------------------------------
end


class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  CENTER_X = ((320 * Setup.x_value) - 8) * 4
  CENTER_Y = ((240 * Setup.y_value) - 8) * 4
  #--------------------------------------------------------------------------
  def center(x, y)
    max_x = ($game_map.width - 20) * (128 * Setup.x_value)
    max_y = ($game_map.height - 15) * (128 * Setup.y_value)
    $game_map.display_x = [0, [x * (128 * Setup.x_value) - CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * (128 * Setup.y_value) - CENTER_Y, max_y].min].max
  end
  #--------------------------------------------------------------------------
end


class Window_Message < Window_Selectable
  #--------------------------------------------------------------------------
  alias resolution_initialize initialize
  def initialize
    resolution_initialize
    self.x = 80 *- Setup.variance
    self.width = 480 *- Setup.variance
    self.height = 160 *- Setup.variance
    self.contents.font.name = 'Verdana'
    self.contents.font.size = Font.default_size * -Setup.variance
  end
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    x = y = 0
    @cursor_width = 0
    if $game_temp.choice_start == 0
      x = 8
    end
    if $game_temp.message_text != nil
      text = $game_temp.message_text
      begin
        last_text = text.clone
        text.gsub!(/\\[Vv]\[([0-9]+)\]/) { $game_variables[$1.to_i] }
      end until text == last_text
      text.gsub!(/\\[Nn]\[([0-9]+)\]/) do
        $game_actors[$1.to_i] != nil ? $game_actors[$1.to_i].name : ""
      end
      text.gsub!(/\\\\/) { "\000" }
      text.gsub!(/\\[Cc]\[([0-9]+)\]/) { "\001[#{$1}]" }
      text.gsub!(/\\[Gg]/) { "\002" }
      while ((c = text.slice!(/./m)) != nil)
        if c == "\000"
          c = "\\"
        end
        if c == "\001"
          text.sub!(/\[([0-9]+)\]/, "")
          color = $1.to_i
          if color >= 0 and color <= 7
            self.contents.font.color = text_color(color)
          end
          next
        end
        if c == "\002"
          if @gold_window == nil
            @gold_window = Window_Gold.new
            @gold_window.x = (Setup.h_value * 0.875) - @gold_window.width
            if $game_temp.in_battle
              @gold_window.y = (Setup.h_value / 10) * 3
            else
              @gold_window.y = self.y >= (128 * Setup.variance) ?
                (32 * Setup.variance) : (384 * Setup.variance)
            end
            @gold_window.opacity = self.opacity
            @gold_window.back_opacity = self.back_opacity
          end
          next
        end
        if c == "\n"
          if y >= $game_temp.choice_start
            @cursor_width = [@cursor_width, x].max
          end
          y += 1
          x = 0
          if y >= $game_temp.choice_start
            x = 8
          end
          next
        end
        draw_y = (26 *- Setup.variance) * y - (24 *- Setup.variance)
        self.contents.draw_text(4 *- Setup.variance + x, draw_y, 40, 32, c)
        x += self.contents.text_size(c).width
      end
    end
    if $game_temp.choice_max > 0
      @item_max = $game_temp.choice_max
      self.active = true
      self.index = 0
    end
    if $game_temp.num_input_variable_id > 0
      digits_max = $game_temp.num_input_digits_max
      number = $game_variables[$game_temp.num_input_variable_id]
      @input_number_window = Window_InputNumber.new(digits_max)
      @input_number_window.number = number
      @input_number_window.x = self.x + 8
      @input_number_window.y = self.y + $game_temp.num_input_start * 32
    end
  end
  #--------------------------------------------------------------------------
  def reset_window
    if $game_temp.in_battle
      self.y = (16 * Setup.variance)
    else
      case $game_system.message_position
      when 0
        self.y = (16 *- Setup.variance)
      when 1
        self.y = (160 *- Setup.variance)
      when 2
        self.y = (304 *- Setup.variance)
      end
    end
    if $game_system.message_frame == 0
      self.opacity = 255
    else
      self.opacity = 0
    end
    self.back_opacity = 160
  end
  #--------------------------------------------------------------------------
  def update_cursor_rect
    if @index >= 0
      n = $game_temp.choice_start + @index
      self.cursor_rect.set(8, n * (24 *- Setup.variance), @cursor_width,
        (24 *- Setup.variance))
    else
      self.cursor_rect.empty
    end
  end
  #--------------------------------------------------------------------------
end


begin
  win = Win32API.SetWindowPos(Setup.h_value, Setup.v_value)
  if(win == 0)
    p "Size change has failed!"
  end
  $scene = nil
end

Expand to see the code.

#==============================================================================
# ** RPG::Cache
#==============================================================================

module RPG::Cache
  #--------------------------------------------------------------------------
  # * Auto-Tiles
  #--------------------------------------------------------------------------
  Autotiles = [
    [[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]]
  ]
  #--------------------------------------------------------------------------
  # * Autotile Cache
  #
  #   @autotile_cache = {
  #     filename => { [autotile_id, frame_id, hue] => bitmap, ... },
  #     ...
  #    }
  #--------------------------------------------------------------------------
  @autotile_cache = {}
  #--------------------------------------------------------------------------
  # * Autotile Tile
  #--------------------------------------------------------------------------
  def self.autotile_tile(filename, tile_id, hue = 0, frame_id = nil)
    # Gets Autotile Bitmap
    autotile = self.autotile(filename)
    # Configures Frame ID if not specified
    if frame_id.nil?
      # Animated Tiles
      frames = autotile.width / 96
      # Configures Animation Offset
      fc = Graphics.frame_count / Animated_Autotiles_Frames
      frame_id = (fc) % frames * 96
    end
    # Creates list if already not created
    @autotile_cache[filename] = {} unless @autotile_cache.has_key?(filename)
    # Gets Key
    key = [tile_id, frame_id, hue]
    # If Key Not Found
    unless @autotile_cache[filename].has_key?(key)
      # Reconfigure Tile ID
      tile_id %= 48
      # Creates Bitmap
      bitmap = Bitmap.new(32, 32)
      # Collects Auto-Tile Tile Layout
      tiles = Autotiles[tile_id / 8][tile_id % 8]
      # Draws Auto-Tile Rects
      for i in 0...4
        tile_position = tiles[i] - 1
        src_rect = Rect.new(tile_position % 6 * 16 + frame_id,
          tile_position / 6 * 16, 16, 16)
        bitmap.blt(i % 2 * 16, i / 2 * 16, autotile, src_rect)
      end
      # Saves Autotile to Cache
      @autotile_cache[filename][key] = bitmap
      # Change Hue
      @autotile_cache[filename][key].hue_change(hue)
    end
    # Return Autotile
    return @autotile_cache[filename][key]
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  This class brings together map screen sprites, tilemaps, etc.
#  It's used within the Scene_Map class.
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    init_viewports                            # Initialize Viewports
    init_tilemap                              # Initialize Tilemap
    init_panorama                             # Initialize Panorama
    init_fog                                  # Initialize Fog
    init_characters                           # Initialize Characters
    init_player                               # Initialize Player
    init_weather                              # Initialize Weather
    init_pictures                             # Initialize Pictures
    init_timer                                # Initialize Timer
    update                                    # Frame update
  end
  #--------------------------------------------------------------------------
  # * Viewport Initialization
  #--------------------------------------------------------------------------
  def init_viewports
    # Make viewports
    @viewport1 = Viewport.new(0, 0, 640, 480)
    @viewport2 = Viewport.new(0, 0, 640, 480)
    @viewport3 = Viewport.new(0, 0, 640, 480)
    @viewport2.z = 200
    @viewport3.z = 5000
  end
  #--------------------------------------------------------------------------
  # * Tilemap Initialization
  #--------------------------------------------------------------------------
  def init_tilemap
    # Make tilemap
    @tilemap = Tilemap.new(@viewport1)
    @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name)
    end
    @tilemap.map_data = $game_map.data.dup
    @tilemap.priorities = $game_map.priorities
  end
  #--------------------------------------------------------------------------
  # * Panorama Initialization
  #--------------------------------------------------------------------------
  def init_panorama
    # Make panorama plane
    @panorama = Plane.new(@viewport1)
    @panorama.z = -1000
  end
  #--------------------------------------------------------------------------
  # * Fog Initialization
  #--------------------------------------------------------------------------
  def init_fog
    # Make fog plane
    @fog = Plane.new(@viewport1)
    @fog.z = 3000
  end
  #--------------------------------------------------------------------------
  # * Character Sprite Initialization
  #--------------------------------------------------------------------------
  def init_characters
    # Make character sprites
    @character_sprites = []
    for i in $game_map.events.keys.sort
      sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
      @character_sprites.push(sprite)
    end
  end
  #--------------------------------------------------------------------------
  # * Player Initialization
  #--------------------------------------------------------------------------
  def init_player
    @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
  end
  #--------------------------------------------------------------------------
  # * Weather Initialization
  #--------------------------------------------------------------------------
  def init_weather
    # Make weather
    @weather = RPG::Weather.new(@viewport1)
  end
  #--------------------------------------------------------------------------
  # * Picture Initialization
  #--------------------------------------------------------------------------
  def init_pictures
    # Make picture sprites
    @picture_sprites = []
    for i in 1..50
      @picture_sprites.push(Sprite_Picture.new(@viewport2,
        $game_screen.pictures[i]))
    end
  end
  #--------------------------------------------------------------------------
  # * Timer Initialization
  #--------------------------------------------------------------------------
  def init_timer
    # Make timer sprite
    @timer_sprite = Sprite_Timer.new
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    update_panorama                           # Update Panorama
    update_fog                                # Update Fog
    update_tilemap                            # Update Tilemap
    update_panorama_plane                     # Update Panorama Plane
    update_fog_plane                          # Update Fog Plane
    update_character_sprites                  # Update Character Sprites
    update_weather                            # Update Weather
    update_picture_sprites                    # Update Picture Sprites
    update_timer                              # Update Timer Sprite
    update_viewports                          # Update Viewports
  end
  #--------------------------------------------------------------------------
  # * Update Panorama
  #--------------------------------------------------------------------------
  def update_panorama
    # If panorama is different from current one
    if @panorama_name != $game_map.panorama_name or
       @panorama_hue != $game_map.panorama_hue
      @panorama_name = $game_map.panorama_name
      @panorama_hue = $game_map.panorama_hue
      if @panorama.bitmap != nil
        @panorama.bitmap.dispose
        @panorama.bitmap = nil
      end
      if @panorama_name != ""
        @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue)
      end
      Graphics.frame_reset
    end
  end
  #--------------------------------------------------------------------------
  # * Update Fog
  #--------------------------------------------------------------------------
  def update_fog
    # If fog is different than current fog
    if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue
      @fog_name = $game_map.fog_name
      @fog_hue = $game_map.fog_hue
      if @fog.bitmap != nil
        @fog.bitmap.dispose
        @fog.bitmap = nil
      end
      if @fog_name != ""
        @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue)
      end
      Graphics.frame_reset
    end
  end
  #--------------------------------------------------------------------------
  # * Update Tilemap
  #--------------------------------------------------------------------------
  def update_tilemap
    # Update tilemap
    @tilemap.ox = $game_map.display_x / 4
    @tilemap.oy = $game_map.display_y / 4
    @tilemap.update
  end
  #--------------------------------------------------------------------------
  # * Update Panorama Plane
  #--------------------------------------------------------------------------
  def update_panorama_plane
    # Update panorama plane
    @panorama.ox = $game_map.display_x / 8
    @panorama.oy = $game_map.display_y / 8
  end
  #--------------------------------------------------------------------------
  # * Update Fog Plane
  #--------------------------------------------------------------------------
  def update_fog_plane
    # Update fog plane
    @fog.zoom_x = $game_map.fog_zoom / 100.0
    @fog.zoom_y = $game_map.fog_zoom / 100.0
    @fog.opacity = $game_map.fog_opacity
    @fog.blend_type = $game_map.fog_blend_type
    @fog.ox = $game_map.display_x / 4 + $game_map.fog_ox
    @fog.oy = $game_map.display_y / 4 + $game_map.fog_oy
    @fog.tone = $game_map.fog_tone
  end
  #--------------------------------------------------------------------------
  # * Update Character Sprites
  #--------------------------------------------------------------------------
  def update_character_sprites
    # Update character sprites
    for sprite in @character_sprites
      sprite.update
    end
  end
  #--------------------------------------------------------------------------
  # * Update Weather
  #--------------------------------------------------------------------------
  def update_weather
    # Update weather graphic
    @weather.type = $game_screen.weather_type
    @weather.max = $game_screen.weather_max
    @weather.ox = $game_map.display_x / 4
    @weather.oy = $game_map.display_y / 4
    @weather.update
  end
  #--------------------------------------------------------------------------
  # * Update Picture Sprites
  #--------------------------------------------------------------------------
  def update_picture_sprites
    # Update picture sprites
    for sprite in @picture_sprites
      sprite.update
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Timer
  #--------------------------------------------------------------------------
  def update_timer
    # Update timer sprite
    @timer_sprite.update
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Viewports
  #--------------------------------------------------------------------------
  def update_viewports
    # Set screen color tone and shake position
    @viewport1.tone = $game_screen.tone
    @viewport1.ox = $game_screen.shake
    # Set screen flash color
    @viewport3.color = $game_screen.flash_color
    # Update viewports
    @viewport1.update     
    @viewport3.update
  end
end

RPG::Cache::Animated_Autotiles_Frames = 16
#==============================================================================
# ** Tilemap_Options
#==============================================================================

module Tilemap_Options
  #--------------------------------------------------------------------------
  # * Tilemap Options
  #
  #
  #   Print Error Reports when not enough information set to tilemap
  #    - Print_Error_Logs          = true or false
  #
  #   Number of autotiles to refresh at edge of viewport
  #    - Viewport_Padding          = n
  #
  #   When maps are switch, automatically set
  #   $game_map.tileset_settings.flash_data (Recommended : False unless using
  #   flash_data)
  #    - Autoset_Flash_data        = true or false
  #
  #   Duration Between Flash Data Flashes
  #    - Flash_Duration            = n
  #
  #   Color of bitmap (Recommended to use low opacity value)
  #    - Flash_Bitmap_C            = Color.new(255, 255, 255, 50)
  #
  #   Update Flashtiles Default Setting
  #   Explanation : In the Flash Data Addition, because of lag, you may wish
  #   to toggle whether flash tiles flash or not. This is the default state.
  #    - Default_Update_Flashtiles = false
  #--------------------------------------------------------------------------
  Print_Error_Logs          = true
  Autoset_Flash_data        = true
  Viewport_Padding          = 2
  Flash_Duration            = 40
  Flash_Bitmap_C            = Color.new(255, 255, 255, 50)
  Default_Update_Flashtiles = false
end

#==============================================================================
# ** Tilemap_Settings
#==============================================================================

class Tilemap_Settings
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :map
  attr_accessor :is_a_plane
  attr_accessor :tone
  attr_accessor :hue
  attr_accessor :zoom_x
  attr_accessor :zoom_y
  attr_accessor :tile_size
  attr_accessor :flash_data
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(map = nil)
    # Set Instance Variables
    @map, @is_a_plane, @tone, @hue, @zoom_x, @zoom_y, @tile_size,
      @flash_data = map, false, nil, 0, 1.0, 1.0, 16, nil
  end
end

#==============================================================================
# ** Game_Map
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :tilemap_settings
  def setup_load
    # Load map from file and set @map
    @map = load_data(sprintf("Data/Map%03d.rxdata", @map_id))
  end
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :seph_tilemap_gmap_init, :initialize
  alias_method :seph_tilemap_gmap_stld, :setup_load
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    # Original Initialization
    seph_tilemap_gmap_init
    # Create Tilemap Settings
    @tilemap_settings = Tilemap_Settings.new
  end
  #--------------------------------------------------------------------------
  # * Load Map Data
  #--------------------------------------------------------------------------
  def setup_load
    # Original Load Map Data
    seph_tilemap_gmap_stld
    # Reset Tilemap Flash Data
    if Tilemap_Options::Autoset_Flash_data
      @tilemap_settings.flash_data = Table.new(@map.width, @map.height)
    end
    @tilemap_settings.map = @map
  end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================

class Spriteset_Map
  def init_tilemap
    # Make tilemap
    @tilemap = Tilemap.new(@viewport1)
    @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name)
    end
    @tilemap.map_data = $game_map.data.dup
    @tilemap.priorities = $game_map.priorities
  end
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias_method :seph_tilemap_ssmap_inittm, :init_tilemap
  #--------------------------------------------------------------------------
  # * Tilemap Initialization
  #--------------------------------------------------------------------------
  def init_tilemap
    # Original Tilemap Initialization
    seph_tilemap_ssmap_inittm
    # Set Tilemap Settings
    @tilemap.tileset_name = $game_map.tileset_name
    for i in 0..6
      @tilemap.autotiles_name[i] = $game_map.autotile_names[i]
    end
    @tilemap.tilemap_settings = $game_map.tilemap_settings
    # Setup Flash Data
    @tilemap.flash_data = $game_map.tilemap_settings.flash_data
    # Run Tilemap Setup
    @tilemap.setup
  end
end

#==============================================================================
# ** Tilemap
#==============================================================================

class Tilemap
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :layers
  attr_accessor :tileset
  attr_accessor :tileset_name
  attr_accessor :autotiles
  attr_accessor :autotiles_name
  attr_reader   :map_data
  attr_accessor :flash_data
  attr_accessor :priorities
  attr_accessor :visible
  attr_accessor :ox
  attr_accessor :oy
  attr_accessor :tilemap_settings
  attr_accessor :refresh_autotiles
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(viewport)
    # Saves Viewport
    @viewport = viewport
    # Creates Blank Instance Variables
    @layers            = []    # Refers to Array of Sprites or Planes
    @tileset           = nil   # Refers to Tileset Bitmap
    @tileset_name      = ''    # Refers to Tileset Filename
    @autotiles         = []    # Refers to Array of Autotile Bitmaps
    @autotiles_name    = []    # Refers to Array of Autotile Filenames
    @map_data          = nil   # Refers to 3D Array Of Tile Settings
    @flash_data        = nil   # Refers to 3D Array of Tile Flashdata
    @priorities        = nil   # Refers to Tileset Priorities
    @visible           = true  # Refers to Tilest Visibleness
    @ox                = 0     # Bitmap Offsets         
    @oy                = 0     # Bitmap Offsets
    @tilemap_settings  = nil   # Special Tilemap Settings
    @dispose           = false # Disposed Flag
    @refresh_autotiles = true  # Refresh Autotile Flag
  end
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  def setup
    # Print Error if Tilemap Settings not Found
    if Tilemap_Options::Print_Error_Logs
      if @tilemap_settings.nil?
        p 'Tilemap Settings have not been set. System will not crash.'
      end
      if @map_data.nil?
        p 'Map Data has not been set. System will crash.'
      end
    end
    # Creates Layers
    @layers = []
    for l in 0...3
      layer = @tilemap_settings.nil? || !@tilemap_settings.is_a_plane ?
        Sprite.new(@viewport) : Plane.new(@viewport)
      layer.bitmap = Bitmap.new(@map_data.xsize * 32, @map_data.ysize * 32)
      layer.z = l * 150
      layer.zoom_x = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_x
      layer.zoom_y = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_y
      unless @tilemap_settings.nil? || @tilemap_settings.tone.nil?
        layer.tone = @tilemap_settings.tone
      end
      @layers << layer
    end
    # Update Flags
    @refresh_data = nil
    @zoom_x   = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_x
    @zoom_y   = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_y
    @tone     = @tilemap_settings.nil? ? nil : @tilemap_settings.tone
    @hue      = @tilemap_settings.nil? ? 0   : @tilemap_settings.hue
    @tilesize = @tilemap_settings.nil? ? 32  : @tilemap_settings.tile_size
  end
  #--------------------------------------------------------------------------
  # * Map Data=
  #--------------------------------------------------------------------------
  def map_data=(map_data)
    # Save Map Data
    @map_data = map_data
    # Refresh if able
    begin ; refresh ; rescue ; end
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    # Dispose Layers (Sprites)
    @layers.each { |layer| layer.dispose }
    # Set Disposed Flag to True
    @disposed = true
  end
  #--------------------------------------------------------------------------
  # * Disposed?
  #--------------------------------------------------------------------------
  def disposed?
    return @disposed
  end
  #--------------------------------------------------------------------------
  # * Viewport
  #--------------------------------------------------------------------------
  def viewport
    return @viewport
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Set Refreshed Flag to On
    needs_refresh = true
    # If Map Data, Tilesize or HueChanges
    if @map_data != @refresh_data || (@tilemap_settings != false &&
       @hue != @tilemap_settings.hue) || (@tilemap_settings != false &&
       @tilesize != @tilemap_settings.tile_size)
      # Refresh Bitmaps
      refresh
      # Turns Refresh Flag to OFF
      needs_refresh = false
    end
    # Zoom X, Zoom Y, and Tone Changes
    unless @tilemap_settings.nil?
      if @zoom_x != @tilemap_settings.zoom_x
        @zoom_x = @tilemap_settings.zoom_x
        @layers.each {|layer| layer.zoom_x = @zoom_x}
      end
      if @zoom_y != @tilemap_settings.zoom_y
        @zoom_y = @tilemap_settings.zoom_y
        @layers.each {|layer| layer.zoom_y = @zoom_y}
      end
      if @tone != @tilemap_settings.tone
        @tone = @tilemap_settings.tone.nil? ?
          Tone.new(0, 0, 0, 0) : @tilemap_settings.tone
        @layers.each {|layer| layer.tone = @tone}
      end
    end
    # Update layer Position offsets
    for layer in @layers
      layer.ox = @ox
      layer.oy = @oy
    end
    # If Refresh Autotiles, Needs Refreshed & Autotile Reset Frame
    if @refresh_autotiles && needs_refresh &&
       Graphics.frame_count % RPG::Cache::Animated_Autotiles_Frames == 0
      # Refresh Autotiles
      refresh_autotiles
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    # Saves Map Data & Tilesize
    @refresh_data = @map_data
    @hue      = @tilemap_settings.nil? ? 0  : @tilemap_settings.hue
    @tilesize = @tilemap_settings.nil? ? 32 : @tilemap_settings.tile_size
    # Passes Through Layers
    for z in 0...@map_data.zsize
      # Passes Through X Coordinates
      for x in 0...@map_data.xsize
        # Passes Through Z Coordinates
        for y in 0...@map_data.ysize
          # Collects Tile ID
          id = @map_data[x, y, z]
          # Skip if 0 tile
          next if id == 0
          # Passes Through All Priorities
          for p in 0..5
            # Skip If Priority Doesn't Match
            next unless p == @priorities[id]
            # Cap Priority to Layer 3
            p = 2 if p > 2
            # Draw Tile
            id < 384 ? draw_autotile(x, y, p, id) : draw_tile(x, y, p, id)
          end
        end
      end
    end
  end   
  #--------------------------------------------------------------------------
  # * Refresh Auto-Tiles
  #--------------------------------------------------------------------------
  def refresh_autotiles
    # Auto-Tile Locations
    autotile_locations = Table.new(@map_data.xsize, @map_data.ysize,
      @map_data.zsize)
  # Get X Tiles
    x1 = [@ox / @tilesize - Tilemap_Options::Viewport_Padding, 0].max
    x2 = [@viewport.rect.width / @tilesize +
          Tilemap_Options::Viewport_Padding, @map_data.xsize].min
    # Get Y Tiles
    y1 = [@oy / @tilesize - Tilemap_Options::Viewport_Padding, 0].max
    y2 = [@viewport.rect.height / @tilesize +
          Tilemap_Options::Viewport_Padding, @map_data.ysize].min
    # Passes Through Layers
    for z in 0...@map_data.zsize
      # Passes Through X Coordinates
      for x in x1...x2
        # Passes Through Y Coordinates
        for y in y1...y2
          # Collects Tile ID
          id = @map_data[x, y, z]
          # Skip if 0 tile
          next if id == 0
          # Skip If Non-Animated Tile
          next unless @autotiles[id / 48 - 1].width / 96 > 1 if id < 384
          # Get Priority
          p = @priorities[id]
          # Cap Priority to Layer 3
          p = 2 if p > 2
          # If Autotile
          if id < 384
            # Draw Auto-Tile
            draw_autotile(x, y, p, id)
            # Draw Higher Tiles
            for l in 0...@map_data.zsize
              id_l = @map_data[x, y, l]
              draw_tile(x, y, p, id_l)
            end
            # Save Autotile Location
            autotile_locations[x, y, z] = 1
          # If Normal Tile
          else
            # If Autotile Drawn
            if autotile_locations[x, y, z] == 1
              # Redraw Normal Tile
              draw_tile(x, y, p, id)
              # Draw Higher Tiles
              for l in 0...@map_data.zsize
                id_l = @map_data[x, y, l]
                draw_tile(x, y, p, id_l)
              end
            end
          end
        end
      end
    end
  end     
  #--------------------------------------------------------------------------
  # * Draw Tile
  #--------------------------------------------------------------------------
  def draw_tile(x, y, z, id)
    rect = Rect.new((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
    x *= @tilesize
    y *= @tilesize
    if @tile_width == 32 && @tile_height == 32
      @layers[z].bitmap.blt(x, y, @tileset, rect)
    else
      dest_rect = Rect.new(x, y, @tilesize, @tilesize)
      @layers[z].bitmap.stretch_blt(dest_rect, @tileset, rect)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Auto-Tile
  #--------------------------------------------------------------------------
  def draw_autotile(x, y, z, tile_id)
    # Gets Autotile Filename
    filename = @autotiles_name[tile_id / 48 - 1]
    # Reconfigure Tile ID
    tile_id %= 48
    # Gets Generated Autotile Bitmap Section
    bitmap = RPG::Cache.autotile_tile(filename, tile_id, @hue)
    # Calculates Tile Coordinates
    x *= @tilesize
    y *= @tilesize
    # If Normal Tile
    if @tilesize == 32
      @layers[z].bitmap.blt(x, y, bitmap, Rect.new(0, 0, 32, 32))
    # If Altered Dimensions
    else
      dest_rect = Rect.new(x, y, @tilesize, @tilesize)
      @layers[z].bitmap.stretch_blt(dest_rect, bitmap, Rect.new(0, 0, 32, 32))
    end
  end
  #--------------------------------------------------------------------------
  # * Collect Bitmap
  #--------------------------------------------------------------------------
  def bitmap
    # Creates New Blank Bitmap
    bitmap = Bitmap.new(@layers[0].bitmap.width, @layers[0].bitmap.height)
    # Passes Through All Layers
    for layer in @layers
      bitmap.blt(0, 0, layer.bitmap,
        Rect.new(0, 0, bitmap.width, bitmap.height))
    end
    # Return Bitmap
    return bitmap
  end
end

Expand to see the code.