[XP] Custom Resolution

Started by ForeverZer0, November 25, 2010, 03:28:40 am

Previous topic - Next topic

ForeverZer0

November 25, 2010, 03:28:40 am Last Edit: May 31, 2015, 02:59:57 pm by KK20
Custom Resolution
Authors: ForeverZer0, KK20, LiTTleDRAgo
Version: 0.97
Type: Game Utility
Key Term: Game Utility



Introduction

My goal in creating this script was to create a system that allowed the user to set the screen size to something other than 640 x 480, but not have make huge sacrifices in compatibility and performance. Although the script is not simply Plug-and-Play, it is about as close as one can achieve with a script of this nature.


Features
Note these were written at the time of v0.93. The following may not be entirely true for the later versions.

  • Totally re-written Tilemap and Plane class. Both classes were written to display the map across any screen size automatically. The Tilemap class is probably even more efficient than the original, which will help offset any increased lag due to using a larger screen size with more sprites being displayed.

  • Every possible autotile graphic (48 per autotile) will be cached for the next time that tile is used.

  • Autotile animation has been made as efficient as possible, with a system that stores their coodinates, but only if they change. This greatly reduces the number of iterations at each update.

  • Option to have the system create an external file to save pre-cached data for autotiles. This will decrease any loading times even more, and only takes a second, depending on the number of maps you have.

  • User defined autotile animation speed. Can change with script calls.

  • Automatic re-sizing of Bitmaps and Viewports that are 640 x 480 to the defined resolution, unless explicitely over-ridden in the method call. The graphics themselves will not be resized, but any existing scripts that use the normal screen size will already be configured to display different sizes of graphics for battlebacks, pictures, fogs, etc.

  • Option to have a log file ouput each time the game is ran, which can alert you to possible errors with map sizes, etc.




Screenshots

None.


Demo

Click here for the demo. Note, it uses v0.93.


Script

Here's the code for v0.93 (the last version ForeverZer0 made--few graphical issues):
Spoiler: ShowHide

#===============================================================================
# Custom Resolution
# Author: ForeverZer0
# Version: 0.93
# Date: 12.18.2010
#===============================================================================
#
# Introduction:
#
#   My goal in creating this script was to create a system that allowed the user
#   to set the screen size to something other than 640 x 480, but not have make
#   huge sacrifices in compatibility and performance. Although the script is
#   not simply Plug-and-Play, it is about as close as one can achieve with a
#   script of this nature.
#
# Instructions:
#
#  - Place the "screenshot.dll" from Fantasist's Transition Pack script, which
#    can be found here: http://www.sendspace.com/file/yjd54h in your game folder
#  - Place this script above main, below default scripts.
#  - In my experience, unchecking "Reduce Screen Flickering" actually helps the
#    screen not to flicker. Open menu with F1 while playing and set this to what
#    you get the best results with.
#
# Features:

#  - Totally re-written Tilemap and Plane class. Both classes were written to
#    display the map across any screen size automatically. The Tilemap class
#    is probably even more efficient than the original, which will help offset
#    any increased lag due to using a larger screen size with more sprites
#    being displayed.
#  - Every possible autotile graphic (48 per autotile) will be cached for the
#    next time that tile is used.
#  - Autotile animation has been made as efficient as possible, with a system
#    that stores their coodinates, but only if they change. This greatly reduces
#    the number of iterations at each update.
#  - System creates an external file to save pre-cached data priorities and
#    autotiles. This will decrease any loading times even more, and only takes a
#    second, depending on the number of maps you have.
#  - User defined autotile animation speed. Can change with script calls.
#  - Automatic re-sizing of Bitmaps and Viewports that are 640 x 480 to the
#    defined resolution, unless explicitely over-ridden in the method call.
#    The graphics themselves will not be resized, but any existing scripts that
#    use the normal screen size will already be configured to display different
#    sizes of graphics for transitions, battlebacks, pictures, fogs, etc.
#  - Option to have a log file ouput each time the game is ran, which can alert
#    you to possible errors with map sizes, etc.
#
# Issues/Bugs/Possible Bugs:
#
#   - Graphic related scripts and your graphics will need to be customized to
#     fit the new screen size, so this script is not for everyone.
#   - The Z-axis for the Plane class, which is used for Fogs and Panoramas has
#     been altered. It is now multiplied by 1000. This will likely be a minor
#     issue for most, since this class is very rarely used except for Fogs and
#     Panoramas, which are already far above and below respectfully.
#   - Normal transitions using graphics cannot be used. With the exception of
#     a standard fade, like that used when no graphic is defined will be used.
#     Aside from that, only special transitions from Transition Pack can be
#     used.
#
#  Credits/Thanks:
#    - ForeverZer0, for script.
#    - Creators of the Transition Pack and Screenshot.dll
#    - Selwyn, for base resolution script
#
#===============================================================================
#                             CONFIGURATION
#===============================================================================

  SCREEN = [1024, 576]
  # 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.
 
  UPDATE_COUNT = 8
  # Define the number of frames between autotile updates. The lower the number,
  # the faster the animations cycle. This can be changed in-game with the
  # following script call: $game_map.autotile_speed = SPEED
 
  PRE_CACHE_DATA = true
  # The pre-cached file is mandatory for the script to work. As long as this is
  # true, the data will be created each time the game is test-played. This is
  # not always neccessary, only when maps are altered, so you can disable it to
  # help speed up game start-up, and it will use the last created file.
 
  RESOLUTION_LOG = true
  # This will create a log in the Game directory each time the game is ran in
  # DEBUG mode, which will list possible errors with map sizes, etc.
 
#===============================================================================
# ** Resolution
#===============================================================================

class Resolution
 
  attr_reader :version
 
  def initialize
    # Define version.
    @version = 0.93
    # Set instance variables for calling basic Win32 functions.
    ini = Win32API.new('kernel32', 'GetPrivateProfileString','PPPPLP', 'L')
    title = "\0" * 256
    ini.call('Game', 'Title', '', title, 256, '.\\Game.ini')
    title.delete!("\0")
    @window = Win32API.new('user32', 'FindWindow', 'PP', 'I').call('RGSS Player', title)
    set_window_long = Win32API.new('user32', 'SetWindowLong', 'LIL', 'L')
    set_window_pos  = Win32API.new('user32', 'SetWindowPos', 'LLIIIII', 'I')
    @metrics         = Win32API.new('user32', 'GetSystemMetrics', 'I', 'I')
    # Set default size, displaying error if size is larger than the hardware.
    default_size = self.size
    if default_size[0] < SCREEN[0] || default_size[1] < SCREEN[1]
      print("\"#{title}\" requires a minimum screen resolution of [#{SCREEN[0]} x #{SCREEN[1]}]\r\n\r\n" +
            "\tYour Resolution: [#{default_size[0]} x #{default_size[1]}]")
      exit
    end
    # Apply resolution change.
    x = (@metrics.call(0) - SCREEN[0]) / 2
    y = (@metrics.call(1) - SCREEN[1]) / 2
    set_window_long.call(@window, -16, 0x14CA0000)
    set_window_pos.call(@window, 0, x, y, SCREEN[0] + 6, SCREEN[1] + 26, 0)
    @window = Win32API.new('user32', 'FindWindow', 'PP', 'I').call('RGSS Player', title)
  end
  #--------------------------------------------------------------------------
  def size
    # Returns the screen size of the machine.
    return [@metrics.call(0), @metrics.call(1)]
  end
  #--------------------------------------------------------------------------
  def snapshot(filename = 'Data/snap', quality = 0)
    # FILENAME =   Filename that the picture will be saved as.
    # FILETYPE =   0 = High Quality   1 = Low Quality
    @screen = Win32API.new('screenshot.dll', 'Screenshot', 'LLLLPLL', '')
    @screen.call(0, 0, SCREEN[0], SCREEN[1], filename, @window, quality)
  end
  #--------------------------------------------------------------------------
end

#===============================================================================
# ** Integer
#===============================================================================

class Integer
   
  def gcd(num)
    # Returns the greatest common denominator of self and num.
    min, max = self.abs, num.abs
    while min > 0
      tmp = min
      min = max % min
      max = tmp
    end
    return max
  end
 
  def lcm(num)
    # Returns the lowest common multiple of self and num.
    return [self, num].include?(0) ? 0 : (self / self.gcd(num) * num).abs
  end
end

#===============================================================================
# ** Graphics
#===============================================================================

module Graphics

  class << self
    alias zer0_graphics_transition transition
  end
 
  def self.transition(duration = 8, *args)
    # Call default transition if no instance of the resolution is defined.
    if $resolution == nil
      zer0_graphics_transition(duration, *args)
    else
      # Skip this section and instantly transition graphics if duration is 0.
      if duration > 0
        # Take a snapshot of the the screen, overlaying screen with graphic.
        $resolution.snapshot
        zer0_graphics_transition(0)
        # Create screen instance
        sprite = Sprite.new(Viewport.new(0, 0, SCREEN[0], SCREEN[1]))
        sprite.bitmap = Bitmap.new('Data/snap')
        # Use a simple fade if transition is not defined.
        fade = 255 / duration
        duration.times { sprite.opacity -= fade ; update }
        # Dispose sprite and delete snapshot file.
        [sprite, sprite.bitmap].each {|obj| obj.dispose }
        File.delete('Data/snap')
      end
     zer0_graphics_transition(0)
   end
end
end 

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

module RPG::Cache
 
  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], [13,18,43,48]
   
  ]
 
  def self.autotile(filename)
    key = "Graphics/Autotiles/#{filename}"
    if !@cache.include?(key) || @cache[key].disposed?
      # Cache the autotile graphic.
      @cache[key] = (filename == '') ? Bitmap.new(128, 96) : Bitmap.new(key)
      # Cache each configuration of this autotile.
      self.format_autotiles(@cache[key], filename)
    end
    return @cache[key]
  end

  def self.format_autotiles(bitmap, filename)
    # Iterate all 48 combinations using the INDEX, and save copy to cache.
    (0...(bitmap.width / 96)).each {|frame|
      # Iterate for each frame in the autotile. (Only for animated ones)
      template = Bitmap.new(256, 192)
      # Create a bitmap to use as a template for creation.
      (0...6).each {|i| (0...8).each {|j| AUTO_INDEX[8*i+j].each {|number|
        number -= 1
        x, y = 16 * (number % 6), 16 * (number / 6)
        rect = Rect.new(x + (frame * 96), y, 16, 16)
        template.blt(32 * j + x % 32, 32 * i + y % 32, bitmap, rect)
      }
      # Use the above created template to create individual tiles.
      index = 8*i+j
      tile = Bitmap.new(32, 32)
      sx, sy = 32 * (index % 8), 32 * (index / 8)
      rect = Rect.new(sx, sy, 32, 32)
      tile.blt(0, 0, template, rect)
      @cache[[filename, index, frame]] = tile
    }}
    # Dispose the template since it will not be used again.
    template.dispose }
  end

  def self.load_autotile(name, tile_id, frame = 0)
    # Returns the autotile for the current map with TILE_ID and FRAME.
    return @cache[[name, tile_id % 48, frame]]
  end
end

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

class Tilemap
 
  attr_reader   :map_data, :ox, :oy, :viewport
  attr_accessor :tileset, :autotiles, :priorities
 
  def initialize(viewport)
    # Initialize instance variables to store required data.
    @viewport, @autotiles, @layers, @ox, @oy = viewport, [], [], 0, 0
    # Get priority and autotile data for this tileset from instance of Game_Map.
    @priorities, @animated = $game_map.priorities, $game_map.autotile_data
    # Create a sprite and viewport to use for each priority level.
    (0..5).each {|i|
      @layers[i] = Sprite.new(viewport)
      @layers[i].z = i * 32
    }
  end
   
  def ox=(ox)
    # Set the origin of the X-axis for all the sprites.
    @ox = ox
    @layers.each {|sprite| sprite.ox = @ox }
  end
 
  def oy=(oy)
    # Set the origin of the y-axis for all the sprites.
    @oy = oy
    @layers.each {|sprite| sprite.oy = @oy }
  end
 
  def dispose
    # Dispose all of the sprites and viewports.
    @layers.each {|layer| layer.dispose }
  end
 
  def map_data=(data)
    # Set the map data to an instance variable.
    @map_data = data
    # Clear any sprites' bitmaps if it exists, or create new ones.
    @layers.each_index {|i|
      if @layers[i].bitmap != nil
        # Dispose bitmap and set to nil.
        @layers[i].bitmap = @layers[i].bitmap.dispose
      end
      # Create new bitmap, whose size is the same as the game map.
      @layers[i].bitmap = Bitmap.new($game_map.width*32, $game_map.height*32)
    }
    # Draw bitmaps accordingly.
    refresh
  end
 
  def refresh   
    # Set the animation data from the file if it exists, or create it now.
    @animated = $game_map.autotile_data
    # Iterate through all map layers, starting with the bottom.
    [0,1,2].each {|z| (0...@map_data.ysize).each {|y| (0...@map_data.xsize).each {|x|
      tile_id = @map_data[x, y, z]
      # Go to the next iteration if no bitmap is defined for this tile.
      if tile_id == 0 # No tile
        next
      elsif tile_id < 384 # Autotile
        name = $game_map.autotile_names[(tile_id / 48) - 1]
        bitmap = RPG::Cache.load_autotile(name, tile_id)
      else # Normal Tile
        bitmap = RPG::Cache.tile($game_map.tileset_name, tile_id, 0)
      end
      # Determine what the layer to draw tile, based off priority.
      layer = @priorities[tile_id]
      # Perform a block transfer from the created bitmap to the sprite bitmap.
      @layers[layer].bitmap.blt(x*32, y*32, bitmap, Rect.new(0, 0, 32, 32))
    }}}
  end
 
  def update
    # Update the sprites.
    if Graphics.frame_count % $game_map.autotile_speed == 0
      # Increase current frame of tile by one, looping by width.
      @animated[0].each_index {|i|
        @animated[2][i] = (@animated[2][i] + 1) % @animated[1][i]
        @animated[3][i].each {|data|
          # Gather data using the stored coordinates from the map data.
          tile_id, x, y = @map_data[data[0], data[1], data[2]], data[0], data[1]
          name, layer = @animated[0][i], @priorities[tile_id]
          # Load the next frame of the autotile and set it to the map.
          bitmap = RPG::Cache.load_autotile(name, tile_id, @animated[2][i])
          @layers[layer].bitmap.blt(x*32, y*32, bitmap, Rect.new(0, 0, 32, 32))
        }
      }
    end
  end
end

#===============================================================================
# Game_Map
#===============================================================================

class Game_Map
 
  attr_reader :tile_size, :autotile_speed, :autotile_data, :priority_data
 
  alias zer0_load_autotile_data_init initialize
  def initialize
    # Load pre-cached data hashes. They will be referenced during setup.
    file = File.open('Data/PreCacheMapData.rxdata', 'rb')
    @cached_priorities = Marshal.load(file)
    @cached_autotiles = Marshal.load(file)
    file.close
    # Call original method.
    zer0_load_autotile_data_init
    # Store the screen dimensions in tiles to save on calculations later.
    @tile_size = [SCREEN[0], SCREEN[1]].collect {|n| (n / 32.0).ceil }
    @autotile_speed = UPDATE_COUNT
  end
 
  alias zer0_map_edge_setup setup
  def setup(map_id)
    @priority_data = @cached_priorities[map_id]
    @autotile_data = @cached_autotiles[map_id]
    # Call original method.
    zer0_map_edge_setup(map_id)
    # Find the displayed area of the map in tiles. No calcualting every step.
    @map_edge = [self.width - @tile_size[0], self.height - @tile_size[1]]
    @map_edge.collect! {|size| size * 128 }
  end

  def scroll_down(distance)
    # Find point that the map edge meets the screen edge, using custom size.
    @display_y = [@display_y + distance, @map_edge[1]].min
  end

  def scroll_right(distance)
    # Find point that the map edge meets the screen edge, using custom size.
    @display_x = [@display_x + distance, @map_edge[0]].min
  end
 
  def autotile_speed=(speed)
    # Keep the speed above 0 to prevent the ZeroDivision Error.
    @autotile_speed = speed
    @autotile_speed = 1 if @autotile_speed < 1
  end
end

#===============================================================================
# ** Game_Character
#===============================================================================

class Game_Character
 
  def screen_z(height = 0)
    if @always_on_top
      # Return high Z value if always on top flag is present.
      return 999
    elsif height != nil && height > 32
      # Iterate through map characters to their positions relative to this one.
      characters = $game_map.events.values
      characters += [$game_player] unless self.is_a?(Game_Player)
      # Find and set any character that is one tile above this one.
      above, z = characters.find {|chr| chr.x == @x && chr.y == @y - 1 }, 0
      if above != nil
        # If found, adjust value by this one's Z, and the other's.
        z = (above.screen_z(48) >= 32 ? 33 : 31)
      end
      # Check for Blizz-ABS and adjust coordinates for the pixel-rate.
      if $BlizzABS
        x = ((@x / $game_system.pixel_rate) / 2.0).to_i
        y = ((@y / $game_system.pixel_rate) / 2.0).to_i
        return $game_map.priority_data[x, y] + z
      else
        return $game_map.priority_data[@x, @y] + z
      end
    end
    return 0
  end
end

#===============================================================================
# ** Game_Player
#===============================================================================

class Game_Player
 
  CENTER_X = ((SCREEN[0] / 2) - 16) * 4    # Center screen x-coordinate * 4
  CENTER_Y = ((SCREEN[1] / 2) - 16) * 4    # Center screen y-coordinate * 4
 
  def center(x, y)
    # Recalculate the screen center based on the new resolution.
    max_x = ($game_map.width - $game_map.tile_size[0]) * 128
    max_y = ($game_map.height - $game_map.tile_size[1]) * 128
    $game_map.display_x = [0, [x * 128 - CENTER_X, max_x].min].max
    $game_map.display_y = [0, [y * 128 - CENTER_Y, max_y].min].max
  end 
end

#===============================================================================
# ** Sprite
#===============================================================================

class Sprite
 
  alias zer0_sprite_resize_init initialize
  def initialize(view = nil)
    # Unless viewport is defined, use the new default viewport size.
    view = Viewport.new(0, 0, SCREEN[0], SCREEN[1]) if view == nil
    # Call original method.
    zer0_sprite_resize_init(view)
  end
end

#===============================================================================
# ** Viewport
#===============================================================================

class Viewport
 
  alias zer0_viewport_resize_init initialize
  def initialize(x=0, y=0, width=SCREEN[0], height=SCREEN[1], override=false)
    if x.is_a?(Rect)
      # If first argument is a Rectangle, just use it as the argument.
      zer0_viewport_resize_init(x)
    elsif [x, y, width, height] == [0, 0, 640, 480] && !override
      # Resize fullscreen viewport, unless explicitly overridden.
      zer0_viewport_resize_init(Rect.new(0, 0, SCREEN[0], SCREEN[1]))
    else
      # Call method normally.
      zer0_viewport_resize_init(Rect.new(x, y, width, height))
    end
  end
 
  def resize(*args)
    # Resize the viewport. Can call with (X, Y, WIDTH, HEIGHT) or (RECT).
    self.rect = args[0].is_a?(Rect) ? args[0] : Rect.new(*args)
  end
end

#===============================================================================
# ** Bitmap
#===============================================================================

class Bitmap
 
  alias zer0_resolution_resize_init initialize
  def initialize(width = 32, height = 32, override = false)
    if width.is_a?(String)
      # Call the filename if the first argument is a String.
      zer0_resolution_resize_init(width)
    elsif [width, height] == [640, 480] && !override
      # Resize fullscreen bitmap unless explicitly overridden.
      zer0_resolution_resize_init(SCREEN[0], SCREEN[1])
    else
      # Call method normally.
      zer0_resolution_resize_init(width, height)
    end
  end
end

#===============================================================================
# ** Plane
#===============================================================================

class Plane < Sprite
 
  def z=(z)
    # Change the Z value of the viewport, not the sprite.
    super(z * 1000)
  end
 
  def ox=(ox)
    return if @bitmap == nil
    # Have viewport stay in loop on X-axis.
    super(ox % @bitmap.width)
  end
 
  def oy=(oy)
    return if @bitmap == nil
    # Have viewport stay in loop on Y-axis.
    super(oy % @bitmap.height)
  end
 
  def bitmap
    # Return the single bitmap, before it was tiled.
    return @bitmap
  end
 
  def bitmap=(tile)
    @bitmap = tile
    # Calculate the number of tiles it takes to span screen in both directions.
    xx = 1 + (SCREEN[0].to_f / tile.width).ceil
    yy = 1 + (SCREEN[1].to_f / tile.height).ceil
    # Create appropriately sized bitmap, then tile across it with source image.
    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)
    }}
    # Set the bitmap to the sprite through its super class (Sprite).
    super(plane)
  end
 
  # Redefine methods dealing with coordinates (defined in super) to do nothing.
  def x; end
  def y; end
  def x=(x); end
  def y=(y); end
end
 
#===============================================================================
# DEBUG Mode
#===============================================================================

if $DEBUG
  if PRE_CACHE_DATA
    tilesets = load_data('Data/Tilesets.rxdata')
    maps, priority_data, autotile_data = load_data('Data/MapInfos.rxdata'), {}, {}
    maps.each_key {|map_id|
      map = load_data(sprintf("Data/Map%03d.rxdata", map_id))
      data = map.data
      tileset = tilesets[map.tileset_id]
      priorities = tileset.priorities
      autotiles = tileset.autotile_names.collect {|name| RPG::Cache.autotile(name) }
      animated = [[], [], [], []]
      autotiles.each_index {|i|
        width = autotiles[i].width
        next unless width > 96
        parameters = [tileset.autotile_names[i], width / 96, 0, []]
        [0, 1, 2, 3].each {|j| animated[j].push(parameters[j]) }
      }
      [0, 1, 2].each {|z| (0...data.ysize).each {|y| (0...data.xsize).each {|x|
        tile_id = data[x, y, z]
        next if tile_id == 0
        if tile_id < 384
          name = tileset.autotile_names[(tile_id / 48) - 1]
          index = animated[0].index(name)
          next if index == nil
          above = []
          ((z+1)...data.zsize).each {|zz| above.push(data[x, y, zz]) }
          animated[3][index].push([x, y, z]) if above.all? {|id| id == 0 }
        end
      }}}
      table = Table.new(data.xsize, data.ysize)
      (0...table.xsize).each {|x| (0...table.ysize).each {|y|
        above = [0, 1, 2].collect {|z| data[x, y-1, z] }
        above = above.compact.collect {|p| priorities[p] }
        table[x, y] = above.include?(1) ? 32 : 0
      }}
      priority_data[map_id], autotile_data[map_id] = table, animated
    }
    file = File.open('Data/PreCacheMapData.rxdata', 'wb')
    Marshal.dump(priority_data, file)
    Marshal.dump(autotile_data, file)
    file.close
    RPG::Cache.clear
  end
 
  if RESOLUTION_LOG
    undersize, mapinfo = [], load_data('Data/MapInfos.rxdata')
    file = File.open('Data/PreCacheMapData.rxdata', 'rb')
    cached_data = Marshal.load(file)
    file.close
    # Create a text file and write the header.
    file = File.open('Resolution Log.txt', 'wb')
    file.write("[RESOLUTION LOG]\r\n\r\n")
    time = Time.now.strftime("%x at %I:%M:%S %p")
    file.write("  Logged on #{time}\r\n\r\n")
    lcm = SCREEN[0].lcm(SCREEN[1]).to_f
    aspect = [(lcm / SCREEN[1]), (lcm / SCREEN[0])].collect {|num| num.round }
    file.write("RESOLUTION:\r\n  #{SCREEN[0].to_i} x #{SCREEN[1].to_i}\r\n")
    file.write("ASPECT RATIO:\r\n  #{aspect[0]}:#{aspect[1]}\r\n")
    file.write("MINIMUM MAP SIZE:\r\n  #{(SCREEN[0] / 32).ceil} x #{(SCREEN[1] / 32).ceil}\r\n\r\n")
    file.write("UNDERSIZED MAPS:\r\n")
    mapinfo.keys.each {|key|
      map = load_data(sprintf("Data/Map%03d.rxdata", key))
      next if map.width*32 >= SCREEN[0] && map.height*32 >= SCREEN[1]
      undersize.push(key)
    }
    unless undersize.empty?
      file.write("The following maps are too small for the defined resolution. They should be adjusted to prevent graphical errors.\r\n\r\n")
      undersize.sort.each {|id| file.write("    MAP[#{id}]:  #{mapinfo[id].name}\r\n") }
      file.write("\r\n")
    else
      file.write('    All maps are sized correctly.')
    end
    file.close
  end
end

# Call the resolution, setting it to a global variable for plug-ins.
$resolution = Resolution.new

Below are two types of v0.96b, which addresses some bugs and entirely changes the way the tilemap is drawn.
Normal Version
DLL-less Version
* With the DLL-less version, there is no need to put 'screenshot.dll' in your project folder

LiTTleDRAgo modified the existing script further to bring the script to v0.97. Download it:
HERE!


Instructions


  • Place script below default scripts, and above "Main".

  • (OPTIONAL) Download Transition Pack by Fantasist from here (contains 'screenshot.dll'): http://www.sendspace.com/file/yjd54h

  • Alternate 'screenshot.dll' download link: http://www.sendspace.com/file/aiirus

  • Place the screenshot.dll from it in the game folder if using v0.93 or Normal version.

  • (OPTIONAL) Because larger resolutions do not change the positions of windows in scenes, LiTTleDRAgo created a script that centers these windows to make them look more visually appealing. Get it here.


  • Any further instructions are in the script.




Compatibility

This script is not going to be for everyone obviously. A bigger screen means bigger chance of lag.
Custom scripts will need to be made to have windows for your CMS, CBS, and other scenes fill the screen properly.

I have created a second thread for numerous compatibility fixes. You can also make requests for new ones.
Go here to view the post.


Credits and Thanks


  • ForeverZer0, for the script.

  • Creators of Transition Pack and screenshot.dll

  • Selwyn, for base resolution script.

  • KK20, for v0.94 (and above) and the Tilemap rewrite (many hours and pages of notes went into this to make it one of the most realistic rewrites out there)

  • LiTTleDRAgo, for using some methods from his Core Engine script to make a DLL-less version and continued support/contributions by editing the existing script and creating compatible add-ons



Author's Notes

Please report any bugs/issues/suggestions. KK20 will be happy to fix them.
EDIT: KK20 will no longer be providing support. He has moved on to XP Ace Tilemap.
Enjoy!
I am done scripting for RMXP. I will likely not offer support for even my own scripts anymore, but feel free to ask on the forum, there are plenty of other talented scripters that can help you.

Blizzard

<3

So that's what you've been up to. <3

You think that your Tilemap is more efficient? Have you tested it or is it just an assumption? After all, the original Tilemap was made in C++.
Check out Daygames and our games:

King of Booze 2      King of Booze: Never Ever
Drinking Game for Android      Never have I ever for Android
Drinking Game for iOS      Never have I ever for iOS


Quote from: winkioI do not speak to bricks, either as individuals or in wall form.

Quote from: Barney StinsonWhen I get sad, I stop being sad and be awesome instead. True story.

Wizered67

Whenever I try to use this amazing script, it gives me an error on line 136.
no implicit conversion from nil to integer


And yes, I did put in the screenshot.dll

ForeverZer0

@blizz:
I admit it is just an assumption. To be quite honest, I am not exactly sure how the default Tilemap works. From what I can see (at my current scripting level), I can't see how it could be much more efficient, if is using standard RGSS scripts.

@wizered:
I can't seem to reproduce the problem. If you can upload me an example project that it does it in, I will be happy to look into it. The script is not quite finished yet, and it is very possible that there are some bugs left to track down.
I am done scripting for RMXP. I will likely not offer support for even my own scripts anymore, but feel free to ask on the forum, there are plenty of other talented scripters that can help you.

The Niche

Well Zero, an impressive performance. I'm proud to have my soul owned by you :L. Anyway, I'd suggest making it so the window enlarges to the point that it's fullscreen, but doesn't overlap the taskbar.
Level me down, I'm trying to become the anti-blizz!
Quote from: winkio on June 15, 2011, 07:30:23 pm
Ah, excellent.  You liked my amusing sideshow, yes?  I'm just a simple fool, my wit entertains the wise, and my wisdom fools the fools.



I'm like the bible, widely hated and beautifully quotable.

Dropbox is this way, not any other way!

Wizered67

Maybe it's just my computer. Anyway, I started a new project and it still gives the error. I uploaded the demo at http://www.sendspace.com/file/26ks62.

Guilink

Quote from: Wizered67 on November 25, 2010, 11:05:55 am
Whenever I try to use this amazing script, it gives me an error on line 136.
no implicit conversion from nil to integer


And yes, I did put in the screenshot.dll


I have the same error!

:huh:
Waiting for BABS Controller for RMX-OS update! '-'

www.manaextreme.blogspot.com (my brazilian game-newblog)

ForeverZer0

November 25, 2010, 01:31:30 pm #7 Last Edit: November 25, 2010, 01:32:41 pm by ForeverZer0
One thing to try is to restart your computer after putting in the screenshot.dll
I know Ryex had a similar issue with the WeatherCreator not reading the display.dll, but after he restarted, it worked fine. This is just an idea, but it is worth a try. Like I said, it will not do it for me, and is likely an issue with your PC's settings that I am not aware of.

Also, ensure that the dll is named exactly as this, and all downcase, although I'm not sure if it matters:

                                                           screenshot.dll

(Never used the marquee before, just trying it out  ;))
I am done scripting for RMXP. I will likely not offer support for even my own scripts anymore, but feel free to ask on the forum, there are plenty of other talented scripters that can help you.

Wizered67

November 25, 2010, 01:35:16 pm #8 Last Edit: November 25, 2010, 01:39:23 pm by Wizered67
In a few minutes a may try restarting, but I don't think thats the problem as I'm already using Game Guy's screenshot script that uses the screenshot.dll in a different project.

edit: are you sure its not just your script?(no offense) I just tried  different resolution script and it worked fine on my computer.....

Guilink

I also tried rebooting and it did not work
Waiting for BABS Controller for RMX-OS update! '-'

www.manaextreme.blogspot.com (my brazilian game-newblog)

Wizered67

I'm not a very good scripter and I don't claim to be, but is it possible that the reason we are getting the error is that Resolution.new is not being called? When I put Resolution.new in the self.snapshot area, it does this
Spoiler: ShowHide
I'm not quite sure if this is how the script was intended to work. The only problem is that it randomly gives an "undefined method +" error, although I don't know if that is my fault.

ForeverZer0

November 25, 2010, 01:57:07 pm #11 Last Edit: November 25, 2010, 01:59:30 pm by ForeverZer0
I would say "yes" its the script right away, but not everyone is having this problem. I'm not going to take offense at that by the way. I don't know of a scripter who has never had bugs/problems with their scripts. I know I have had my share  ;).

But anyways, the fact that some experience it, while others don't, with the only difference being the hardware and PC settings kind of narrows it down. I would love to be able to help you, I don't like having scripts out there that don't work, but I personally cannot get it reproduce the error, and the best I can do is make educated guesses at what it could be.

The script makes calls using the Win32API module to make low-level calls to functions on your computer, which any number of priviledge levels, parental controls, etc. could effect, along with basic configuration settings. All of these are factors that I cannot foresee, nor account for in the script.

:O.o:
Uh-oh. I may have forgot to include the method to call it. Resolution.new does need called. My bad.
I updated the instructions.
I am done scripting for RMXP. I will likely not offer support for even my own scripts anymore, but feel free to ask on the forum, there are plenty of other talented scripters that can help you.

Wizered67

Okay, so by using Resolution.new in the self.snapshot it does indeed work. However, after I move for I while I get an
undefined method + for nil:NilClass

on the line
 return $game_map.priority_data[$game_map.map_id][@x, @y] + z

ForeverZer0

Call it in Main, before processing begins, not in snapshot. It needs called before the game starts, not during every transitions. I updated the post and instructions. They are a little more clear. It was my fault I forgot to mention that it needed called. Left that part out.  :P
I am done scripting for RMXP. I will likely not offer support for even my own scripts anymore, but feel free to ask on the forum, there are plenty of other talented scripters that can help you.

Wizered67

November 25, 2010, 02:30:35 pm #14 Last Edit: November 25, 2010, 02:33:48 pm by Wizered67
Okay, I did that, but it still gives the same error.

edit: Also, if possible, you should make it so that you can't do alt + enter for fullscreen as that messes up the script.

ForeverZer0

Okay, I may have found a possible bug.
Add things to all three layers, save the map, and see if it still does it.
Let me know. If that fixes it, it is indeed a problem with the script.
I am done scripting for RMXP. I will likely not offer support for even my own scripts anymore, but feel free to ask on the forum, there are plenty of other talented scripters that can help you.

G_G

Props to you zero. I've seen you've done quite some scripting. Nice job :)

Wizered67

That still doesn't fix it......

ForeverZer0

I see from your pic that the resolution is changing. So what exactly is the problem, and when exactly is the problem occuring? During transitions? Just walking around? I'm sorry, but I am lost on this one... :O.o:
I am done scripting for RMXP. I will likely not offer support for even my own scripts anymore, but feel free to ask on the forum, there are plenty of other talented scripters that can help you.

Blizzard

I was thinking about using your Tilemap class in CP if it was more efficient. That's why I'm asking. :) I think the best way to test it would be a raw test on a couple of bigger maps with quite a number of events to see which one works better. Also, careful with the memory.
Check out Daygames and our games:

King of Booze 2      King of Booze: Never Ever
Drinking Game for Android      Never have I ever for Android
Drinking Game for iOS      Never have I ever for iOS


Quote from: winkioI do not speak to bricks, either as individuals or in wall form.

Quote from: Barney StinsonWhen I get sad, I stop being sad and be awesome instead. True story.