[RGSS3] Unlimited Resolution (unedited)

#===============================================================================
# Title: Unlimited Resolution
# Date: Jun 6, 2014
#-------------------------------------------------------------------------------
# ** Change log
# Jun 6, 2014
#   - Kaelan: fixed several bugs in the Plane class which prevented the sprite
#     from being modified correctly. Patched for compatibility with Victor's
#     Fogs and Overlays script. Include this after his script.
# Apr 20, 2014
#   - added Kaelan's suggestion for disposing the viewport when done with it
# 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
# FenixFyre, for the Plane class fix
# Kaelan, for several bug fixes
#
#===============================================================================
$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)
    last_y = @display_y
    if loop_vertical?
      @display_y += distance
      @display_y %= @map.height * 256
      @parallax_y += distance
    else
      dh = Graphics.height > height * 32 ? height : screen_tile_y
      @display_y = [@display_y + distance, height - dh].min
      @parallax_y += @display_y - last_y
    end
    @fog_y += loop_vertical? ? distance : @display_y - last_y if @fog_y
  end

  #--------------------------------------------------------------------------
  # overwrite method: scroll_right
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    last_x = @display_x
    if loop_horizontal?
      @display_x += distance
      @display_x %= @map.width * 256
      @parallax_x += distance
    else
      dw = Graphics.width > width * 32 ? width : screen_tile_x
      @display_x = [@display_x + distance, width - dw].min
      @parallax_x += @display_x - last_x
    end
    @fog_x += loop_horizontal? ? distance : @display_x - last_x if @fog_x
  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

  alias :th_unlimited_resolution_dispose :dispose
  def dispose
    th_unlimited_resolution_dispose
    @sprite.dispose if @sprite
    @sprite = nil
  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 blend_type=(blend_type)
    @blend_type = blend_type
    @sprite.blend_type = blend_type
  end

  def opacity=(opacity)
    @opacity = opacity
    @sprite.opacity = opacity
  end

  def z=(z)
    @z = z
    @sprite.z = z
  end

  def tone=(tone)
    @tone = tone
    @sprite.tone = tone
  end

  def visible=(visible)
    @visible = visible
    @sprite.visible = visible
  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*2) / @bitmap.width
    max_y = (h*2) / @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

  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