View difference between Paste ID: QJjeD5fV and JrqLLxkB

 =begin
 #===============================================================================
  Title: Unlimited Resolution
  Date: Oct 24, 2013
 --------------------------------------------------------------------------------
  ** Change log
  Nov 6, 2013
    - added some plane modifications to fix parallax images
  Oct 24, 2013
    - Initial release
 --------------------------------------------------------------------------------
  ** Terms of Use
  * Free
 --------------------------------------------------------------------------------
  ** Description
 
  This script modifies Graphics.resize_screen to overcome the 640x480 limitation.
  It also includes some code to properly display maps that are smaller than the
  screen size.
 
  Now you can have arbitrarily large game resolutions.
 
 --------------------------------------------------------------------------------
  ** Installation
 
  You should place this script above all custom scripts
 
 --------------------------------------------------------------------------------
  ** Usage
 
  As usual, simply resize your screen using the script call
 
    Graphics.resize_screen(width, height)
 
 --------------------------------------------------------------------------------
  ** Credits
 
  Unknown author for overcoming the 640x480 limitation
  Lantier, from RMW forums for posting the snippet above
  Esrever for handling the viewport
  Jet, for the custom Graphics code
 
 #===============================================================================
 =end
 $imported = {} if $imported.nil?
 $imported["TH_UnlimitedResolution"] = true
 #===============================================================================
 # ** Configuration
 #===============================================================================
 class << SceneManager
 
   alias resolution_run run
   def run(*args, &block)
     Graphics.ensure_sprite
     resolution_run(*args, &block)
   end
 end
 
 module Graphics
 
   @@super_sprite = Sprite.new
   @@super_sprite.z = (2 ** (0.size * 8 - 2) - 1)
 
   class << self
     alias :th_large_screen_resize_screen :resize_screen
 
     def freeze(*args, &block)
       @@super_sprite.bitmap = snap_to_bitmap
     end
 
     def transition(time = 10, filename = nil, vague = nil)
       if filename
         @@super_sprite.bitmap = Bitmap.new(filename)
       end
       @@super_sprite.opacity = 255
       incs = 255.0 / time
       time.times do |i|
         @@super_sprite.opacity = 255.0 - incs * i
         Graphics.wait(1)
       end
       @@super_sprite.bitmap.dispose if @@super_sprite.bitmap
       reform_sprite_bitmap
       Graphics.brightness = 255
     end
 
     def reform_sprite_bitmap
       @@super_sprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)
       @@super_sprite.bitmap.fill_rect(@@super_sprite.bitmap.rect, Color.new(0, 0, 0, 255))
     end
 
     def fadeout(frames)
       incs = 255.0 / frames
       frames.times do |i|
         i += 1
         Graphics.brightness = 255 - incs * i
         Graphics.wait(1)
       end
     end
 
     def fadein(frames)
       incs = 255.0 / frames
       frames.times do |i|
         Graphics.brightness = incs * i
         Graphics.wait(1)
       end
     end
 
     def brightness=(i)
       @@super_sprite.opacity = 255.0 - i
     end
 
     def brightness
       255 - @@super_sprite.opacity
     end
 
     def ensure_sprite
       if @@super_sprite.disposed?
         @@super_sprite = Sprite.new
         @@super_sprite.z = (2 ** (0.size * 8 - 2) - 1)
         reform_sprite_bitmap
       end
     end
   end
 
   #-----------------------------------------------------------------------------
   # Unknown Scripter. Copied from http://pastebin.com/sM2MNJZj
   #-----------------------------------------------------------------------------
   def self.resize_screen(width, height)
     wt, ht = width.divmod(32), height.divmod(32)
     #wt.last + ht.last == 0 || fail('Incorrect width or height')
     wh = -> w, h, off = 0 { [w + off, h + off].pack('l2').scan /.{4}/ }
     w, h = wh.(width, height)
     ww, hh = wh.(width, height, 32)
     www, hhh = wh.(wt.first.succ, ht.first.succ)
     base = 0x10000000  # fixed?
     mod = -> adr, val { DL::CPtr.new(base + adr)[0, val.size] = val }
     mod.(0x195F, "\x90" * 5)  # ???
     mod.(0x19A4, h)
     mod.(0x19A9, w)
     mod.(0x1A56, h)
     mod.(0x1A5B, w)
     mod.(0x20F6, w)
     mod.(0x20FF, w)
     mod.(0x2106, h)
     mod.(0x210F, h)
     # speed up y?
     #mod.(0x1C5E3, h)
     #mod.(0x1C5E8, w)
     zero = [0].pack ?l
     mod.(0x1C5E3, zero)
     mod.(0x1C5E8, zero)
     mod.(0x1F477, h)
     mod.(0x1F47C, w)
     mod.(0x211FF, hh)
     mod.(0x21204, ww)
     mod.(0x21D7D, hhh[0])
     mod.(0x21E01, www[0])
     mod.(0x10DEA8, h)
     mod.(0x10DEAD, w)
     mod.(0x10DEDF, h)
     mod.(0x10DEF0, w)
     mod.(0x10DF14, h)
     mod.(0x10DF18, w)
     mod.(0x10DF48, h)
     mod.(0x10DF4C, w)
     mod.(0x10E6A7, w)
     mod.(0x10E6C3, h)
     mod.(0x10EEA9, w)
     mod.(0x10EEB9, h)
     th_large_screen_resize_screen(width, height)
   end
 end
 
 #===============================================================================
 # Esrever's code from
 # http://www.rpgmakervxace.net/topic/100-any-chance-of-higher-resolution-or-larger-sprite-support/page-2#entry7997
 #===============================================================================
 class Game_Map
 
   #--------------------------------------------------------------------------
   # overwrite method: scroll_down
   #--------------------------------------------------------------------------
   def scroll_down(distance)
     if loop_vertical?
       @display_y += distance
       @display_y %= @map.height * 256
       @parallax_y += distance
     else
       last_y = @display_y
       dh = Graphics.height > height * 32 ? height : screen_tile_y
       @display_y = [@display_y + distance, height - dh].min
       @parallax_y += @display_y - last_y
     end
   end
 
   #--------------------------------------------------------------------------
   # overwrite method: scroll_right
   #--------------------------------------------------------------------------
   def scroll_right(distance)
     if loop_horizontal?
       @display_x += distance
       @display_x %= @map.width * 256
       @parallax_x += distance
     else
       last_x = @display_x
       dw = Graphics.width > width * 32 ? width : screen_tile_x
       @display_x = [@display_x + distance, width - dw].min
       @parallax_x += @display_x - last_x
     end
   end
 
 end # Game_Map
 
 #==============================================================================
 # ■ Spriteset_Map
 #==============================================================================
 
 class Spriteset_Map
 
   #--------------------------------------------------------------------------
   # overwrite method: create_viewports
   #--------------------------------------------------------------------------
   def create_viewports
     if Graphics.width > $game_map.width * 32 && !$game_map.loop_horizontal?
       dx = (Graphics.width - $game_map.width * 32) / 2
     else
       dx = 0
     end
     dw = [Graphics.width, $game_map.width * 32].min
     dw = Graphics.width if $game_map.loop_horizontal?
     if Graphics.height > $game_map.height * 32 && !$game_map.loop_vertical?
       dy = (Graphics.height - $game_map.height * 32) / 2
     else
       dy = 0
     end
     dh = [Graphics.height, $game_map.height * 32].min
     dh = Graphics.height if $game_map.loop_vertical?
     @viewport1 = Viewport.new(dx, dy, dw, dh)
     @viewport2 = Viewport.new(dx, dy, dw, dh)
     @viewport3 = Viewport.new(dx, dy, dw, dh)
     @viewport2.z = 50
     @viewport3.z = 100
   end
 
   #--------------------------------------------------------------------------
   # new method: update_viewport_sizes
   #--------------------------------------------------------------------------
   def update_viewport_sizes
     if Graphics.width > $game_map.width * 32 && !$game_map.loop_horizontal?
       dx = (Graphics.width - $game_map.width * 32) / 2
     else
       dx = 0
     end
     dw = [Graphics.width, $game_map.width * 32].min
     dw = Graphics.width if $game_map.loop_horizontal?
     if Graphics.height > $game_map.height * 32 && !$game_map.loop_vertical?
       dy = (Graphics.height - $game_map.height * 32) / 2
     else
       dy = 0
     end
     dh = [Graphics.height, $game_map.height * 32].min
     dh = Graphics.height if $game_map.loop_vertical?
     rect = Rect.new(dx, dy, dw, dh)
     for viewport in [@viewport1, @viewport2, @viewport3]
       viewport.rect = rect
     end
   end
 
 end # Spriteset_Map
 
 #-------------------------------------------------------------------------------
 # FenixFyre's custom Plane, simply drawing a sprite. Needs to do something about
 # the y-axis
 #-------------------------------------------------------------------------------
 class Plane
   attr_reader :ox, :oy
 
   alias :th_unlimited_resolution_initialize :initialize
   def initialize(viewport = nil)
     th_unlimited_resolution_initialize(viewport)
     @sprite = Sprite.new(viewport)
     @bitmap = nil
     @ox = 0
     @oy = 0
   end
 
   def method_missing(symbol, *args)
     @sprite.method(symbol).call(*args)
   end
 
   def bitmap=(bitmap)
     @bitmap = bitmap
     refresh
   end
 
   def bitmap
     @sprite.bitmap
   end
 
   def ox=(ox)
     w = @sprite.viewport != nil ? @sprite.viewport.rect.width : Graphics.width
     @ox = ox % w
     @sprite.ox = @ox
   end
 
   def oy=(oy)
     h = @sprite.viewport != nil ? @sprite.viewport.rect.height : Graphics.height
     @oy = oy % h
     @sprite.oy = @oy
   end
 
   def z=(n)
     @sprite.z = n
   end
 
   def z
     @sprite.z
   end
 
   def refresh
     return if @bitmap.nil?
     w = @sprite.viewport != nil ? @sprite.viewport.rect.width : Graphics.width
     h = @sprite.viewport != nil ? @sprite.viewport.rect.height : Graphics.height
     if @sprite.bitmap != nil
       @sprite.bitmap.dispose
     end
     @sprite.bitmap = Bitmap.new(w * 2, h * 2)
 
     max_x = w / @bitmap.width
     max_y = h / @bitmap.height
     for x in 0..max_x
       for y in 0..max_y
         @sprite.bitmap.blt(x * @bitmap.width, y * @bitmap.height,
          @bitmap, Rect.new(0, 0, @bitmap.width, @bitmap.height))
       end
     end
     for i in 1...4
       x = i % 2 * w
       y = i / 2 * h
       @sprite.bitmap.blt(x, y, @sprite.bitmap, Rect.new(0, 0, w, h))
     end
   end
 end
 
 #==============================================================================
 # ■ Scene_Map
 #==============================================================================
 
 class Scene_Map < Scene_Base
 
   #--------------------------------------------------------------------------
   # alias method: post_transfer
   #--------------------------------------------------------------------------
   alias scene_map_post_transfer_ace post_transfer
   def post_transfer
     @spriteset.update_viewport_sizes
     scene_map_post_transfer_ace
   end
 
 end # Scene_Map