Abolished screen border, screenshots are now png format, removed Sprite Resizer scripts, credited mkxp-z

Data/Scripts/001_Settings.rb

@@ -1,29 +1,18 @@
 #==============================================================================#
 #                              Pokémon Essentials                              #
-#                                 Version 18.1                                 #
+#                               Version 18.1.dev                               #
 #==============================================================================#
 
 #===============================================================================
-# * The default screen width (at a zoom of 1.0; size is half this at zoom 0.5).
+# * The default screen width (at a scale of 1.0).
-# * The default screen height (at a zoom of 1.0).
+# * The default screen height (at a scale of 1.0).
-# * The default screen zoom. (1.0 means each tile is 32x32 pixels, 0.5 means
+# * The default screen scale factor. Possible values are 0.5, 1.0, 1.5 and 2.0.
-#      each tile is 16x16 pixels, 2.0 means each tile is 64x64 pixels.)
-# * Whether full-screen display lets the border graphic go outside the edges of
-#      the screen (true), or forces the border graphic to always be fully shown
-#      (false).
-# * The width of each of the left and right sides of the screen border. This is
-#      added on to the screen width above, only if the border is turned on.
-# * The height of each of the top and bottom sides of the screen border. This is
-#      added on to the screen height above, only if the border is turned on.
 # * Map view mode (0=original, 1=custom, 2=perspective).
 #===============================================================================
-SCREEN_WIDTH       = 512
+SCREEN_WIDTH  = 512
-SCREEN_HEIGHT      = 384
+SCREEN_HEIGHT = 384
-SCREEN_ZOOM        = 1.0
+SCREEN_SCALE  = 1.0
-BORDER_FULLY_SHOWS = false
+MAP_VIEW_MODE = 1
-BORDER_WIDTH       = 78
-BORDER_HEIGHT      = 78
-MAP_VIEW_MODE      = 1
 # To forbid the player from changing the screen size themselves, quote out or
 # delete the relevant bit of code in the PScreen_Options script section.
 

Data/Scripts/001_Technical/001_MKXP_Compatibility.rb

@@ -16,3 +16,17 @@ class Bitmap
     mkxp_draw_text(x, y, width, height, text, align)
   end
 end
+
+def pbSetResizeFactor(factor)
+  if !$ResizeInitialized
+    Graphics.resize_screen(SCREEN_WIDTH, SCREEN_HEIGHT)
+    $ResizeInitialized = true
+  end
+  if factor < 0 || factor == 4
+    Graphics.fullscreen = true if !Graphics.fullscreen
+  else
+    Graphics.fullscreen = false if Graphics.fullscreen
+    Graphics.scale = (factor + 1) * 0.5
+    Graphics.center
+  end
+end

Data/Scripts/001_Technical/002_Ruby Utilities.rb

@@ -165,6 +165,106 @@ module Enumerable
   end
 end
 
+#===============================================================================
+# class ByteWriter (used by def save_to_png below)
+#===============================================================================
+class ByteWriter
+  def initialize(filename)
+    @file = File.new(filename, "wb")
+  end
+
+  def <<(*data)
+    write(*data)
+  end
+
+  def write(*data)
+    data.each do |e|
+      if e.is_a?(Array)
+        e.each { |item| write(item) }
+      elsif e.is_a?(Numeric)
+        @file.putc e
+      else
+        raise "Invalid data for writing."
+      end
+    end
+  end
+
+  def write_int(int)
+    self << ByteWriter.to_bytes(int)
+  end
+
+  def close
+    @file.close
+    @file = nil
+  end
+
+  def self.to_bytes(int)
+    return [
+      (int >> 24) & 0xFF,
+      (int >> 16) & 0xFF,
+      (int >> 8) & 0xFF,
+       int & 0xFF
+    ]
+  end
+end
+
+#===============================================================================
+# class Bitmap
+#===============================================================================
+class Bitmap
+  def save_to_png(filename)
+    f = ByteWriter.new(filename)
+    #============================= Writing header =============================#
+    # PNG signature
+    f << [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]
+    # Header length
+    f << [0x00, 0x00, 0x00, 0x0D]
+    # IHDR
+    headertype = [0x49, 0x48, 0x44, 0x52]
+    f << headertype
+    # Width, height, compression, filter, interlacing
+    headerdata = ByteWriter.to_bytes(self.width).
+      concat(ByteWriter.to_bytes(self.height)).
+      concat([0x08, 0x06, 0x00, 0x00, 0x00])
+    f << headerdata
+    # CRC32 checksum
+    sum = headertype.concat(headerdata)
+    f.write_int Zlib::crc32(sum.pack("C*"))
+    #============================== Writing data ==============================#
+    data = []
+    for y in 0...self.height
+      # Start scanline
+      data << 0x00   # Filter: None
+      for x in 0...self.width
+        px = self.get_pixel(x, y)
+        # Write raw RGBA pixels
+        data << px.red
+        data << px.green
+        data << px.blue
+        data << px.alpha
+      end
+    end
+    # Zlib deflation
+    smoldata = Zlib::Deflate.deflate(data.pack("C*")).bytes.map
+    # data chunk length
+    f.write_int smoldata.size
+    # IDAT
+    f << [0x49, 0x44, 0x41, 0x54]
+    f << smoldata
+    # CRC32 checksum
+    f.write_int Zlib::crc32([0x49, 0x44, 0x41, 0x54].concat(smoldata).pack("C*"))
+    #============================== End Of File ===============================#
+    # Empty chunk
+    f << [0x00, 0x00, 0x00, 0x00]
+    # IEND
+    f << [0x49, 0x45, 0x4E, 0x44]
+    # CRC32 checksum
+    f.write_int Zlib::crc32([0x49, 0x45, 0x4E, 0x44].pack("C*"))
+    f.close
+    return nil
+  end
+end
+
 #===============================================================================
 # Kernel methods
 #===============================================================================

Data/Scripts/001_Technical/005_Win32API.rb

@@ -4,12 +4,6 @@ class Win32API
   @@GetWindowThreadProcessId = Win32API.new('user32', 'GetWindowThreadProcessId', '%w(l p)', 'l')
   @@FindWindowEx             = Win32API.new('user32', 'FindWindowEx', '%w(l l p p)', 'l')
 
-  def Win32API.SetWindowText(text)
-    hWnd = pbFindRgssWindow
-    swp = Win32API.new('user32','SetWindowTextA',%(l, p),'i')
-    swp.call(hWnd, text.to_s)
-  end
-
  # Added by Peter O. as a more reliable way to get the RGSS window
   def Win32API.pbFindRgssWindow
     return @@RGSSWINDOW if @@RGSSWINDOW
@@ -30,6 +24,24 @@ class Win32API
     raise "Can't find RGSS player window"
   end
 
+  # Returns the size of the window. Used in detecting the mouse position.
+  def Win32API.client_size
+    hWnd = pbFindRgssWindow
+    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
+
+=begin
+  # Unused
+  def Win32API.SetWindowText(text)
+    hWnd = pbFindRgssWindow
+    swp = Win32API.new('user32','SetWindowTextA',%(l, p),'i')
+    swp.call(hWnd, text.to_s)
+  end
+
+  # Unused
   def Win32API.SetWindowPos(w, h)
     hWnd = pbFindRgssWindow
     windowrect = Win32API.GetWindowRect
@@ -41,14 +53,7 @@ class Win32API
     return win
   end
 
-  def Win32API.client_size
+  # Unused
-    hWnd = pbFindRgssWindow
-    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
-
   def Win32API.GetWindowRect
     hWnd = pbFindRgssWindow
     rect = [0,0,0,0].pack('l4')
@@ -57,12 +62,14 @@ class Win32API
     return Rect.new(x,y,width-x,height-y)
   end
 
+  # Unused
   def Win32API.focusWindow
     window = Win32API.new('user32','ShowWindow','LL','L')
     hWnd = pbFindRgssWindow
     window.call(hWnd,9)
   end
 
+  # Unused
   def Win32API.fillScreen
     setWindowLong = Win32API.new('user32','SetWindowLong','LLL','L')
     setWindowPos  = Win32API.new('user32','SetWindowPos','LLIIIII','I')
@@ -76,17 +83,14 @@ class Win32API
     return [width,height]
   end
 
+  # Unused
   def Win32API.restoreScreen
     setWindowLong = Win32API.new('user32','SetWindowLong','LLL','L')
     setWindowPos  = Win32API.new('user32','SetWindowPos','LLIIIII','I')
     metrics = Win32API.new('user32','GetSystemMetrics','I','I')
     hWnd = pbFindRgssWindow
-    width  = SCREEN_WIDTH*$ResizeFactor
+    width  = SCREEN_WIDTH
-    height = SCREEN_HEIGHT*$ResizeFactor
+    height = SCREEN_HEIGHT
-    if $PokemonSystem && $PokemonSystem.border==1
-      width += BORDER_WIDTH*2*$ResizeFactor
-      height += BORDER_HEIGHT*2*$ResizeFactor
-    end
     x = [(metrics.call(0)-width)/2,0].max
     y = [(metrics.call(1)-height)/2,0].max
     setWindowLong.call(hWnd,-16,0x14CA0000)
@@ -94,6 +98,7 @@ class Win32API
     Win32API.focusWindow
     return [width,height]
   end
+=end
 end
 
 

Data/Scripts/001_Technical/008_Sprite_Resizer.rb

@@ -1,749 +0,0 @@
-#===============================================================================
-# Overriding Sprite, Viewport, and Plane to support resizing
-# By Peter O.
-# Modified by Luka S.J. and Maruno to support fullscreen and more sizes.
-# -- This is a stand-alone RGSS script. --
-#===============================================================================
-$ResizeFactor     = 1.0
-$ResizeFactorMul  = 100
-$ResizeOffsetX    = 0
-$ResizeOffsetY    = 0
-$ResizeFactorSet  = false
-$HaveResizeBorder = false
-
-if true   # Disables using Alt+Enter to go fullscreen
-  regHotKey = Win32API.new('user32', 'RegisterHotKey', 'LIII', 'I')
-  regHotKey.call(0, 1, 1, 0x0D)
-end
-
-def pbSetResizeFactor(factor)
-  if !$ResizeInitialized
-    Graphics.resize_screen(SCREEN_WIDTH, SCREEN_HEIGHT)
-    $ResizeInitialized = true
-  end
-  if factor < 0 || factor == 4
-    Graphics.fullscreen = true if !Graphics.fullscreen
-  else
-    Graphics.fullscreen = false if Graphics.fullscreen
-    Graphics.scale = (factor + 1) * 0.5
-    Graphics.center
-  end
-end
-
-=begin
-# Unused
-def pbRefreshResizeFactor
-  ObjectSpace.each_object(Sprite) { |o|
-    next if o.disposed?
-    o.x      = o.x
-    o.y      = o.y
-    o.ox     = o.ox
-    o.oy     = o.oy
-    o.zoom_x = o.zoom_x
-    o.zoom_y = o.zoom_y
-  }
-  ObjectSpace.each_object(Viewport) { |o|
-    begin
-      o.rect = o.rect
-      o.ox   = o.ox
-      o.oy   = o.oy
-    rescue RGSSError
-    end
-  }
-  ObjectSpace.each_object(Plane) { |o|
-    next if o.disposed?
-    o.zoom_x = o.zoom_x
-    o.zoom_y = o.zoom_y
-  }
-end
-
-# Unused
-def pbSetResizeFactor2(factor,force=false)
-  if $ResizeFactor!=factor || force
-    $ResizeFactor    = factor
-    $ResizeFactorMul = (factor*100).to_i
-    pbRefreshResizeFactor if $ResizeFactorSet
-  end
-  $ResizeFactorSet = true
-  $ResizeBorder.refresh if $HaveResizeBorder
-  begin
-    if Graphics.haveresizescreen
-      Graphics.oldresizescreen(
-        (Graphics.width+$ResizeOffsetX*2)*factor,
-        (Graphics.height+$ResizeOffsetY*2)*factor
-      )
-    end
-    Win32API.SetWindowPos(
-       (Graphics.width+$ResizeOffsetX*2)*factor,
-       (Graphics.height+$ResizeOffsetY*2)*factor
-    )
-  rescue
-  end
-end
-
-# Unused
-def pbConfigureFullScreen
-  params = Win32API.fillScreen
-  fullgamew = gamew = SCREEN_WIDTH
-  fullgameh = gameh = SCREEN_HEIGHT
-  if !BORDER_FULLY_SHOWS && $PokemonSystem && $PokemonSystem.border==1
-    fullgamew += BORDER_WIDTH * 2
-    fullgameh += BORDER_HEIGHT * 2
-  end
-#  factor_x = ((2*params[0])/fullgamew).floor
-#  factor_y = ((2*params[1])/fullgameh).floor
-#  factor = [factor_x,factor_y].min/2.0
-  factor_x = (params[0]/fullgamew).floor
-  factor_y = (params[1]/fullgameh).floor
-  factor = [factor_x,factor_y].min
-  offset_x = (params[0]-gamew*factor)/(2*factor)
-  offset_y = (params[1]-gameh*factor)/(2*factor)
-  $ResizeOffsetX = offset_x
-  $ResizeOffsetY = offset_y
-  ObjectSpace.each_object(Viewport) { |o|
-    begin
-      next if o.rect.nil?
-      ox = o.rect.x-$ResizeOffsetX
-      oy = o.rect.y-$ResizeOffsetY
-      o.rect.x = ox+offset_x
-      o.rect.y = oy+offset_y
-    rescue RGSSError
-    end
-  }
-  pbSetResizeFactor2(factor,true)
-end
-
-# Unused
-def pbConfigureWindowedScreen(value)
-  border = $PokemonSystem ? $PokemonSystem.border : 0
-  $ResizeOffsetX = [0,BORDER_WIDTH][border]
-  $ResizeOffsetY = [0,BORDER_HEIGHT][border]
-  pbSetResizeFactor2(value,true)
-  Win32API.restoreScreen
-end
-=end
-
-def setScreenBorderName(border)
-  if !$HaveResizeBorder
-    $ResizeBorder = ScreenBorder.new
-    $HaveResizeBorder = true
-  end
-  $ResizeBorder.bordername = border if $ResizeBorder
-end
-
-
-
-module Graphics
-  ## Nominal screen size
-  @@width  = SCREEN_WIDTH
-  @@height = SCREEN_HEIGHT
-
-  def self.width
-    return @@width.to_i
-  end
-
-  def self.height
-    return @@height.to_i
-  end
-
-  @@fadeoutvp = Viewport.new(0,0,640,480)
-  @@fadeoutvp.z     = 0x3FFFFFFF
-  @@fadeoutvp.color = Color.new(0,0,0,0)
-
-  def self.brightness
-    return 255-@@fadeoutvp.color.alpha
-  end
-
-  def self.brightness=(value)
-    value = 0 if value<0
-    value = 255 if value>255
-    @@fadeoutvp.color.alpha = 255-value
-  end
-
-  def self.fadein(frames)
-    return if frames<=0
-    curvalue = self.brightness
-    count = (255-self.brightness)
-    frames.times do |i|
-      self.brightness = curvalue+(count*i/frames)
-      self.update
-    end
-  end
-
-  def self.wait(frames)
-    return if frames<=0
-    frames.times do
-      self.update
-    end
-  end
-
-  def self.fadeout(frames)
-    return if frames<=0
-    curvalue = self.brightness
-    count = self.brightness
-    frames.times do |i|
-      self.brightness = curvalue-(count*i/frames)
-      self.update
-    end
-  end
-
-  @@haveresizescreen = true
-  @@deletefailed = false
-
-=begin
-  # TODO: Can this be removed?
-  def self.snap_to_bitmap(resize=true)
-    tempPath = ENV["TEMP"]+"\\tempscreen.bmp"
-    if safeExists?(tempPath) && @@deletefailed
-      begin
-        File.delete(tempPath)
-        @@deletefailed = false
-      rescue Errno::EACCES
-        @@deletefailed = true
-        return nil
-      end
-    end
-    if safeExists?("./rubyscreen.dll")
-      takescreen = Win32API.new("rubyscreen.dll","TakeScreenshot","p","i")
-      takescreen.call(tempPath)
-    end
-    bm = nil
-    if safeExists?(tempPath)
-      bm = Bitmap.new(tempPath)
-      begin
-        File.delete(tempPath)
-        @@deletefailed = false
-      rescue Errno::EACCES
-        @@deletefailed = true
-      end
-    end
-    bm.asOpaque if bm && bm.get_pixel(0,0).alpha==0
-    if resize
-      if bm && $ResizeOffsetX && $ResizeOffsetY && ($ResizeOffsetX!=0 || $ResizeOffsetY!=0)
-        tmpbitmap = Bitmap.new(Graphics.width*$ResizeFactor,Graphics.height*$ResizeFactor)
-        tmpbitmap.blt(0,0,bm,Rect.new(
-           $ResizeOffsetX*$ResizeFactor,$ResizeOffsetY*$ResizeFactor,tmpbitmap.width,tmpbitmap.height))
-        bm.dispose
-        bm = tmpbitmap
-      end
-      if bm && (bm.width!=Graphics.width || bm.height!=Graphics.height)
-        newbitmap = Bitmap.new(Graphics.width,Graphics.height)
-        newbitmap.stretch_blt(newbitmap.rect,bm,Rect.new(0,0,bm.width,bm.height))
-        bm.dispose
-        bm = newbitmap
-      end
-    else
-      # Thise code is used only for taking screenshots with F8.
-      # Doesn't crop out the screen border, doesn't normalise to 1x zoom.
-      # Fixes screenshots being 1 pixel too tall.
-      fullw = (Graphics.width+$ResizeOffsetX*2)*$ResizeFactor
-      fullh = (Graphics.height+$ResizeOffsetY*2)*$ResizeFactor
-      if bm && $ResizeOffsetX && $ResizeOffsetY && $ResizeFactor &&
-         (bm.width!=fullw || bm.height!=fullh)
-        tmpbitmap = Bitmap.new(fullw,fullh)
-        tmpbitmap.blt(0,0,bm,Rect.new(0,0,fullw,fullh))
-        bm.dispose
-        bm = tmpbitmap
-      end
-    end
-    return bm
-  end
-=end
-end
-
-
-=begin
-class Sprite
-  unless @SpriteResizerMethodsAliased
-    alias _initialize_SpriteResizer initialize
-    alias _x_SpriteResizer x
-    alias _y_SpriteResizer y
-    alias _ox_SpriteResizer ox
-    alias _oy_SpriteResizer oy
-    alias _zoomx_SpriteResizer zoom_x
-    alias _zoomy_SpriteResizer zoom_y
-    alias _xeq_SpriteResizer x=
-    alias _yeq_SpriteResizer y=
-    alias _oxeq_SpriteResizer ox=
-    alias _oyeq_SpriteResizer oy=
-    alias _zoomxeq_SpriteResizer zoom_x=
-    alias _zoomyeq_SpriteResizer zoom_y=
-    alias _bushdeptheq_SpriteResizer bush_depth=
-    @SpriteResizerMethodsAliased = true
-  end
-
-  def initialize(viewport=nil)
-    _initialize_SpriteResizer(viewport)
-    @resizedX=0
-    @resizedY=0
-    @resizedOx=0
-    @resizedOy=0
-    @resizedBushDepth=0
-    @resizedZoomX=1.0
-    @resizedZoomY=1.0
-    if $ResizeOffsetX!=0 && $ResizeOffsetY!=0 && !viewport
-      _xeq_SpriteResizer($ResizeOffsetX.to_f*$ResizeFactorMul/100)
-      _yeq_SpriteResizer($ResizeOffsetY.to_f*$ResizeFactorMul/100)
-    end
-    _zoomxeq_SpriteResizer(@resizedZoomX*$ResizeFactorMul/100)
-    _zoomyeq_SpriteResizer(@resizedZoomY*$ResizeFactorMul/100)
-  end
-
-  def x
-    return @resizedX
-  end
-
-  def y
-    return @resizedY
-  end
-
-  def x=(val)
-    if $ResizeFactorMul!=100
-      offset=(self.viewport) ? 0 : $ResizeOffsetX
-      value=(val+offset).to_f*$ResizeFactorMul/100
-      _xeq_SpriteResizer(value.to_i)
-      @resizedX=val.to_i
-    elsif self.viewport
-      _xeq_SpriteResizer(val)
-      @resizedX=val
-    else
-      _xeq_SpriteResizer(val + $ResizeOffsetX)
-      @resizedX=val
-    end
-  end
-
-  def y=(val)
-    if $ResizeFactorMul!=100
-      offset=(self.viewport) ? 0 : $ResizeOffsetY
-      value=(val+offset).to_f*$ResizeFactorMul/100
-      _yeq_SpriteResizer(value.to_i)
-      @resizedY=val.to_i
-    elsif self.viewport
-      _yeq_SpriteResizer(val)
-      @resizedY=val
-    else
-      _yeq_SpriteResizer(val + $ResizeOffsetY)
-      @resizedY=val
-    end
-  end
-
-  def ox
-    return @resizedOx
-  end
-
-  def oy
-    return @resizedOy
-  end
-
-  def ox=(val)
-    @resizedOx=val
-    _oxeq_SpriteResizer(val)
-  end
-
-  def oy=(val)
-    @resizedOy=val
-    _oyeq_SpriteResizer(val)
-  end
-
-  def zoom_x
-    return @resizedZoomX
-  end
-
-  def zoom_y
-    return @resizedZoomY
-  end
-
-  def zoom_x=(val)
-    value=val
-    if $ResizeFactorMul!=100
-      value=(val.to_f*$ResizeFactorMul/100)
-      if (value-0.5).abs<=0.001
-        value=0.5
-      elsif (value-1.0).abs<=0.001
-        value=1.0
-      elsif (value-1.5).abs<=0.001
-        value=1.5
-      elsif (value-2.0).abs<=0.001
-        value=2.0
-      end
-    end
-    _zoomxeq_SpriteResizer(value)
-    @resizedZoomX=val
-  end
-
-  def zoom_y=(val)
-    value=val
-    if $ResizeFactorMul!=100
-      value=(val.to_f*$ResizeFactorMul/100)
-      if (value-0.5).abs<=0.001
-        value=0.5
-      elsif (value-1.0).abs<=0.001
-        value=1.0
-      elsif (value-1.5).abs<=0.001
-        value=1.5
-      elsif (value-2.0).abs<=0.001
-        value=2.0
-      end
-    end
-    _zoomyeq_SpriteResizer(value)
-    @resizedZoomY=val
-  end
-
-  def bush_depth
-    return @resizedBushDepth
-  end
-
-  def bush_depth=(val)
-    value=((val.to_i)*$ResizeFactorMul/100)
-    _bushdeptheq_SpriteResizer(value.to_i)
-    @resizedBushDepth=val.to_i
-  end
-end
-
-
-
-class NotifiableRect < Rect
-  def setNotifyProc(proc)
-    @notifyProc = proc
-  end
-
-  def set(x,y,width,height)
-    super
-    @notifyProc.call(self) if @notifyProc
-  end
-
-  def x=(value)
-    super
-    @notifyProc.call(self) if @notifyProc
-  end
-
-  def y=(value)
-    super
-    @notifyProc.call(self) if @notifyProc
-  end
-
-  def width=(value)
-    super
-    @notifyProc.call(self) if @notifyProc
-  end
-
-  def height=(value)
-    super
-    @notifyProc.call(self) if @notifyProc
-  end
-end
-
-
-
-class Viewport
-  unless @SpriteResizerMethodsAliased
-    alias _initialize_SpriteResizer initialize
-    alias _rect_ViewportResizer rect
-    alias _recteq_SpriteResizer rect=
-    alias _oxeq_SpriteResizer ox=
-    alias _oyeq_SpriteResizer oy=
-    @SpriteResizerMethodsAliased=true
-  end
-
-  def initialize(*arg)
-    args=arg.clone
-    @oldrect=Rect.new(0,0,100,100)
-    _initialize_SpriteResizer(@oldrect)
-    newRect=NotifiableRect.new(0,0,0,0)
-    @resizedRectProc=Proc.new { |r|
-      if $ResizeFactorMul==100
-        @oldrect.set(
-           r.x.to_i+$ResizeOffsetX,
-           r.y.to_i+$ResizeOffsetY,
-           r.width.to_i,
-           r.height.to_i
-        )
-        self._recteq_SpriteResizer(@oldrect)
-      else
-        @oldrect.set(
-           ((r.x+$ResizeOffsetX)*$ResizeFactorMul/100).to_i,
-           ((r.y+$ResizeOffsetY)*$ResizeFactorMul/100).to_i,
-           (r.width*$ResizeFactorMul/100).to_i,
-           (r.height*$ResizeFactorMul/100).to_i
-        )
-        self._recteq_SpriteResizer(@oldrect)
-      end
-    }
-    newRect.setNotifyProc(@resizedRectProc)
-    if arg.length==1
-      newRect.set(args[0].x,args[0].y,args[0].width,args[0].height)
-    else
-      newRect.set(args[0],args[1],args[2],args[3])
-    end
-    @resizedRect=newRect
-    @resizedOx=0
-    @resizedOy=0
-  end
-
-  def ox
-    return @resizedOx
-  end
-
-  def ox=(val)
-    return if !val
-    _oxeq_SpriteResizer(val.to_f*$ResizeFactorMul/100)
-    @resizedOx=val
-  end
-
-  def oy
-    return @resizedOy
-  end
-
-  def oy=(val)
-    return if !val
-    _oyeq_SpriteResizer(val.to_f*$ResizeFactorMul/100)
-    @resizedOy=val
-  end
-
-  def rect
-    return @resizedRect
-  end
-
-  def rect=(val)
-    if val
-      newRect=NotifiableRect.new(0,0,100,100)
-      newRect.setNotifyProc(@resizedRectProc)
-      newRect.set(val.x.to_i,val.y.to_i,val.width.to_i,val.height.to_i)
-      @resizedRect=newRect
-    end
-  end
-end
-
-
-
-class Plane
-  unless @SpriteResizerMethodsAliased
-    alias _initialize_SpriteResizer initialize
-    alias _zoomxeq_SpriteResizer zoom_x=
-    alias _zoomyeq_SpriteResizer zoom_y=
-    alias _oxeq_SpriteResizer ox=
-    alias _oyeq_SpriteResizer oy=
-    @SpriteResizerMethodsAliased=true
-  end
-
-  def initialize(viewport=nil)
-    _initialize_SpriteResizer(viewport)
-    @resizedZoomX=1.0
-    @resizedZoomY=1.0
-    @resizedOx=0
-    @resizedOy=0
-    _zoomxeq_SpriteResizer(@resizedZoomX*$ResizeFactorMul/100)
-    _zoomyeq_SpriteResizer(@resizedZoomY*$ResizeFactorMul/100)
-  end
-
-  def ox
-    return @resizedOx
-  end
-
-  def ox=(val)
-    return if !val
-    _oxeq_SpriteResizer(val.to_f*$ResizeFactorMul/100)
-    @resizedOx=val
-  end
-
-  def oy
-    return @resizedOy
-  end
-
-  def oy=(val)
-    return if !val
-    _oyeq_SpriteResizer(val.to_f*$ResizeFactorMul/100)
-    @resizedOy=val
-  end
-
-  def zoom_x
-    return @resizedZoomX
-  end
-
-  def zoom_x=(val)
-    return if !val
-    _zoomxeq_SpriteResizer(val*$ResizeFactorMul/100)
-    @resizedZoomX=val
-  end
-
-  def zoom_y
-    return @resizedZoomY
-  end
-
-  def zoom_y=(val)
-    return if !val
-    _zoomyeq_SpriteResizer(val*$ResizeFactorMul/100)
-    @resizedZoomY=val
-  end
-end
-=end
-
-
-
-class ScreenBorder
-  def initialize
-    initializeInternal
-    refresh
-  end
-
-  def initializeInternal
-    @maximumZ=500000
-    @bordername=""
-    @sprite=IconSprite.new(0,0) rescue Sprite.new
-    @defaultwidth=640
-    @defaultheight=480
-    @defaultbitmap=Bitmap.new(@defaultwidth,@defaultheight)
-  end
-
-  def dispose
-    @borderbitmap.dispose if @borderbitmap
-    @defaultbitmap.dispose
-    @sprite.dispose
-  end
-
-  def adjustZ(z)
-    if z>=@maximumZ
-      @maximumZ=z+1
-      @sprite.z=@maximumZ
-    end
-  end
-
-  def bordername=(value)
-    @bordername=value
-    refresh
-  end
-
-  def refresh
-    @sprite.z=@maximumZ
-    @sprite.x=-BORDER_WIDTH
-    @sprite.y=-BORDER_HEIGHT
-    @sprite.visible=($PokemonSystem && $PokemonSystem.border==1)
-    @sprite.bitmap=nil
-    if @sprite.visible
-      if @bordername!=nil && @bordername!=""
-        setSpriteBitmap("Graphics/Pictures/"+@bordername)
-      else
-        setSpriteBitmap(nil)
-        @sprite.bitmap=@defaultbitmap
-      end
-    end
-    @defaultbitmap.clear
-    @defaultbitmap.fill_rect(0,0,@defaultwidth,$ResizeOffsetY,Color.new(0,0,0))
-    @defaultbitmap.fill_rect(0,$ResizeOffsetY,
-       $ResizeOffsetX,@defaultheight-$ResizeOffsetY,Color.new(0,0,0))
-    @defaultbitmap.fill_rect(@defaultwidth-$ResizeOffsetX,$ResizeOffsetY,
-       $ResizeOffsetX,@defaultheight-$ResizeOffsetY,Color.new(0,0,0))
-    @defaultbitmap.fill_rect($ResizeOffsetX,@defaultheight-$ResizeOffsetY,
-       @defaultwidth-$ResizeOffsetX*2,$ResizeOffsetY,Color.new(0,0,0))
-  end
-
-  private
-
-  def setSpriteBitmap(x)
-    if (@sprite.is_a?(IconSprite) rescue false)
-      @sprite.setBitmap(x)
-    else
-      @sprite.bitmap=x ? RPG::Cache.load_bitmap("",x) : nil
-    end
-  end
-end
-
-
-
-class Bitmap
-  # Fast methods for retrieving bitmap data
-  RtlMoveMemory_pi = Win32API.new('kernel32', 'RtlMoveMemory', 'pii', 'i')
-  RtlMoveMemory_ip = Win32API.new('kernel32', 'RtlMoveMemory', 'ipi', 'i')
-  SwapRgb = Win32API.new('./rubyscreen.dll', 'SwapRgb', 'pi', '') rescue nil
-
-  def setData(x)
-    RtlMoveMemory_ip.call(self.address, x, x.length)
-  end
-
-  def getData
-    data = "rgba" * width * height
-    RtlMoveMemory_pi.call(data, self.address, data.length)
-    return data
-  end
-
-  def swap32(x)
-    return ((x >> 24) & 0x000000FF) |
-           ((x >> 8) & 0x0000FF00) |
-           ((x << 8) & 0x00FF0000) |
-           ((x << 24) & 0xFF000000)
-  end
-
-  def asOpaque
-    data=getData
-    j=3
-    (width*height).times do
-      data[j]=0xFF
-      j+=4
-    end
-    setData(data)
-  end
-
-  def saveToPng(filename)
-    bytes=[
-       0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A,0x00,0x00,0x00,0x0D
-    ].pack("CCCCCCCCCCCC")
-    ihdr=[
-       0x49,0x48,0x44,0x52,swap32(self.width),swap32(self.height),
-       0x08,0x06,0x00,0x00,0x00
-    ].pack("CCCCVVCCCCC")
-    crc=Zlib::crc32(ihdr)
-    ihdr+=[swap32(crc)].pack("V")
-    bytesPerScan=self.width*4
-    row=(self.height-1)*bytesPerScan
-    data=self.getData
-    data2=data.clone
-    x=""
-    len=bytesPerScan*self.height
-    ttt=Time.now
-    if SwapRgb
-      SwapRgb.call(data2,data2.length)
-    else
-      # the following is considerably slower
-      b=0; c=2
-      while b!=len
-        data2[b]=data[c]
-        data2[c]=data[b]
-        b+=4; c+=4;
-      end
-    end
-#    $times.push(Time.now-ttt)
-    filter="\0"
-    while row>=0
-      thisRow=data2[row,bytesPerScan]
-      x.concat(filter)
-      x.concat(thisRow)
-      row-=bytesPerScan
-    end
-    x=Zlib::Deflate.deflate(x)
-    length=x.length
-    x="IDAT"+x
-    crc=Zlib::crc32(x)
-    idat=[swap32(length)].pack("V")
-    idat.concat(x)
-    idat.concat([swap32(crc)].pack("V"))
-    idat.concat([0,0x49,0x45,0x4E,0x44,0xAE,0x42,0x60,0x82].pack("VCCCCCCCC"))
-    File.open(filename,"wb") { |f|
-      f.write(bytes)
-      f.write(ihdr)
-      f.write(idat)
-    }
-  end
-
-  def address
-    if !@address
-      buffer, ad = "rgba", object_id * 2 + 16
-      RtlMoveMemory_pi.call(buffer, ad, 4)
-      ad = buffer.unpack("L")[0] + 8
-      RtlMoveMemory_pi.call(buffer, ad, 4)
-      ad = buffer.unpack("L")[0] + 16
-      RtlMoveMemory_pi.call(buffer, ad, 4)
-      @address=buffer.unpack("L")[0]
-    end
-    return @address
-  end
-end

Data/Scripts/005_Map renderer/001_Tilemap_XP.rb

@@ -216,27 +216,13 @@ class CustomTilemap
     @tilesetChanged = true
   end
 
-  def getResizeFactor
-    return $ResizeFactor || 1.0
-  end
-
   def ox=(val)
-    rf = getResizeFactor
-    if rf!=1.0
-      val = (val*rf).to_i
-      val = (val/rf).to_i
-    end
     wasshown = self.shown?
     @ox = val.floor
     @nowshown = (!wasshown && self.shown?)
   end
 
   def oy=(val)
-    rf = getResizeFactor
-    if rf!=1.0
-      val = (val*rf).to_i
-      val = (val/rf).to_i
-    end
     wasshown = self.shown?
     @oy = val.floor
     @nowshown = (!wasshown && self.shown?)

Data/Scripts/005_Map renderer/004_TilemapLoader.rb

@@ -17,7 +17,7 @@ class TilemapLoader
       if Tilemap.method_defined?(:passages)
         setClass(CustomTilemap)
       else
-        setClass(($ResizeFactor==1.0) ? SynchronizedTilemap : CustomTilemap)
+        setClass(SynchronizedTilemap)
       end
     end
   end

Data/Scripts/010_Scenes/005_Scene_Credits.rb

@@ -79,6 +79,10 @@ and everyone else who helped out
 
 
 
+"mkxp-z" by:
+Roza
+Based on MKXP by Ancurio et al.
+
 "RPG Maker XP" by:
 Enterbrain
 
@@ -165,7 +169,6 @@ _END_
     @credit_sprite.z      = 9998
     @credit_sprite.oy     = @realOY
     @bg_index = 0
-    @zoom_adjustment = 1.0/$ResizeFactor
     @last_flag = false
     #--------
     # Setup

Data/Scripts/017_UI/015_PScreen_Options.rb

@@ -6,7 +6,6 @@ class PokemonSystem
   attr_writer   :textskin
   attr_accessor :font
   attr_accessor :screensize
-  attr_writer   :border
   attr_writer   :language
   attr_writer   :runstyle
   attr_writer   :bgmvolume
@@ -20,8 +19,7 @@ class PokemonSystem
     @frame       = 0     # Default window frame (see also $TextFrames)
     @textskin    = 0     # Speech frame
     @font        = 0     # Font (see also $VersionStyles)
-    @screensize  = (SCREEN_ZOOM * 2).floor - 1   # 0=half size, 1=full size, 2=full-and-a-half size, 3=double size
+    @screensize  = (SCREEN_SCALE * 2).floor - 1   # 0=half size, 1=full size, 2=full-and-a-half size, 3=double size
-    @border      = 0     # Screen border (0=off, 1=on)
     @language    = 0     # Language (see also LANGUAGES in script PokemonSystem)
     @runstyle    = 0     # Run key functionality (0=hold to run, 1=toggle auto-run)
     @bgmvolume   = 100   # Volume of background music and ME
@@ -30,7 +28,6 @@ class PokemonSystem
   end
 
   def textskin;  return @textskin || 0;    end
-  def border;    return @border || 0;      end
   def language;  return @language || 0;    end
   def runstyle;  return @runstyle || 0;    end
   def bgmvolume; return @bgmvolume || 100; end
@@ -509,24 +506,11 @@ class PokemonOption_Scene
          proc { |value| $PokemonSystem.textinput = value }
        ),
        EnumOption.new(_INTL("Screen Size"),[_INTL("S"),_INTL("M"),_INTL("L"),_INTL("XL"),_INTL("Full")],
-         proc { [$PokemonSystem.screensize,4].min },
+         proc { [$PokemonSystem.screensize, 4].min },
          proc { |value|
-           oldvalue = $PokemonSystem.screensize
+           if $PokemonSystem.screensize != value
-           $PokemonSystem.screensize = value
+             $PokemonSystem.screensize = value
-           if value!=oldvalue
              pbSetResizeFactor($PokemonSystem.screensize)
-             ObjectSpace.each_object(TilemapLoader) { |o| o.updateClass if !o.disposed? }
-           end
-         }
-       ),
-       EnumOption.new(_INTL("Screen Border"),[_INTL("Off"),_INTL("On")],
-         proc { $PokemonSystem.border },
-         proc { |value|
-           oldvalue = $PokemonSystem.border
-           $PokemonSystem.border = value
-           if value!=oldvalue
-             pbSetResizeFactor($PokemonSystem.screensize)
-             ObjectSpace.each_object(TilemapLoader) { |o| o.updateClass if !o.disposed? }
            end
          }
        )

Data/Scripts/020_System and utilities/001_PSystem_Controls.rb

@@ -274,12 +274,11 @@ module Mouse
 
   # Returns the position of the mouse relative to the game window.
   def getMousePos(catch_anywhere=false)
-    resizeFactor = ($ResizeFactor) ? $ResizeFactor : 1
     x, y = screen_to_client(*getMouseGlobalPos)
     return nil unless x and y
     width, height = Win32API.client_size
     if catch_anywhere or (x>=0 and y>=0 and x<width and y<height)
-      return (x/resizeFactor).to_i, (y/resizeFactor).to_i
+      return x, y
     end
     return nil
   end

Data/Scripts/020_System and utilities/002_PSystem_System.rb

@@ -21,14 +21,7 @@ def pbChooseLanguage
 end
 
 if !respond_to?("pbSetResizeFactor")
-  def pbSetResizeFactor(dummy,dummy2=false); end
+  def pbSetResizeFactor(dummy); end
-  def setScreenBorderName(border); end
-
-  $ResizeFactor    = 1.0
-  $ResizeFactorMul = 100
-  $ResizeOffsetX   = 0
-  $ResizeOffsetY   = 0
-  $ResizeFactorSet = false
 
   module Graphics
     def self.snap_to_bitmap; return nil; end
@@ -62,12 +55,12 @@ def pbSetUpSystem
     game_system   = Game_System.new
     pokemonSystem = PokemonSystem.new
   end
-  if !$INEDITOR
+  if $INEDITOR
+    pbSetResizeFactor(1.0)
+  else
     $game_system   = game_system
     $PokemonSystem = pokemonSystem
-    pbSetResizeFactor([$PokemonSystem.screensize,3].min)
+    pbSetResizeFactor([$PokemonSystem.screensize, 4].min)
-  else
-    pbSetResizeFactor(1.0)
   end
   # Load constants
   begin
@@ -90,13 +83,10 @@ end
 def pbScreenCapture
   t = pbGetTimeNow
   filestart = t.strftime("[%Y-%m-%d] %H_%M_%S")
-  filestart = sprintf("%s.%03d",filestart,(t.to_f-t.to_i)*1000)   # milliseconds
+  filestart = sprintf("%s.%03d", filestart, (t.to_f - t.to_i) * 1000)   # milliseconds
-  capturefile = RTP.getSaveFileName(sprintf("%s.bmp",filestart))
+  capturefile = RTP.getSaveFileName(sprintf("%s.png", filestart))
-#  if capturefile && safeExists?("rubyscreen.dll")
+  Graphics.snap_to_bitmap.save_to_png(capturefile)
-    Graphics.screenshot(capturefile)
+  pbSEPlay("Pkmn exp full") if FileTest.audio_exist?("Audio/SE/Pkmn exp full")
-#    Graphics.snap_to_bitmap.saveToPng(capturefile)
-    pbSEPlay("Pkmn exp full") if FileTest.audio_exist?("Audio/SE/Pkmn exp full")
-#  end
 end
 
 def pbDebugF7

Data/Scripts/021_Debug/002_Debug_Actions.rb

@@ -816,7 +816,7 @@ def pbDebugFixInvalidTiles
     changed = false
     map = mapData.getMap(id)
     next if !map || !mapData.mapinfos[id]
-    Win32API.SetWindowText(_INTL("Processing map {1} ({2})", id, mapData.mapinfos[id].name))
+    pbSetWindowText(_INTL("Processing map {1} ({2})", id, mapData.mapinfos[id].name))
     passages = mapData.getTilesetPassages(map, id)
     # Check all tiles in map for non-existent tiles
     for x in 0...map.data.xsize

Data/Scripts/021_Debug/005_Editor_SaveData.rb

@@ -317,28 +317,28 @@ end
 def pbSaveMachines
   machines = pbLoadSpeciesTMData
   return if !machines
-  File.open("PBS/tm.txt","wb") { |f|
+  File.open("PBS/tm.txt", "wb") { |f|
     f.write(0xEF.chr)
     f.write(0xBB.chr)
     f.write(0xBF.chr)
-    f.write("\# "+_INTL("See the documentation on the wiki to learn how to edit this file."))
+    f.write("\# " + _INTL("See the documentation on the wiki to learn how to edit this file."))
     f.write("\r\n")
     keys = machines.keys.sort { |a, b| GameData::Move.get(a).id_number <=> GameData::Move.get(b).id_number }
     for i in 0...keys.length
       Graphics.update if i%50==0
-      Win32API.SetWindowText(_INTL("Writing move {1}/{2}",i,keys.length)) if i%20==0
+      pbSetWindowText(_INTL("Writing move {1}/{2}", i, keys.length)) if i % 20 == 0
       next if !machines[keys[i]]
       movename = GameData::Move.get(keys[i]).id.to_s
-      next if !movename || movename==""
+      next if !movename || movename == ""
       f.write("\#-------------------------------\r\n")
-      f.write(sprintf("[%s]\r\n",movename))
+      f.write(sprintf("[%s]\r\n", movename))
       x = []
       machines[keys[i]].each do |species|
-        speciesname = getConstantName(PBSpecies,species) rescue pbGetSpeciesConst(species) rescue nil
+        speciesname = getConstantName(PBSpecies, species) rescue pbGetSpeciesConst(species) rescue nil
-        next if !speciesname || speciesname==""
+        next if !speciesname || speciesname == ""
         x.push(speciesname)
       end
-      f.write(x.join(",")+"\r\n")
+      f.write(x.join(",") + "\r\n")
     end
   }
 end
@@ -855,7 +855,7 @@ def pbSavePokemonData
     end
     if i%20==0
       Graphics.update
-      Win32API.SetWindowText(_INTL("Processing species {1}...",i))
+      pbSetWindowText(_INTL("Processing species {1}...",i))
     end
   end
   pokedata.close
@@ -1317,7 +1317,7 @@ def pbSavePokemonFormsData
     end
     if i%20==0
       Graphics.update
-      Win32API.SetWindowText(_INTL("Processing species {1}...",i))
+      pbSetWindowText(_INTL("Processing species {1}...",i))
     end
   end
   pokedata.close

Data/Scripts/021_Debug/013_Editor_BattleAnimationEditor.rb

@@ -50,7 +50,7 @@ module ShadowText
     elsif align==1
       x+=(w/2)-(width/2)
     end
-    pbDrawShadowText(bitmap,x,y,w,h,t,
+    pbDrawShadowText(bitmap,x,y+6,w,h,t,
        disabled ? Color.new(26*8,26*8,25*8) : Color.new(12*8,12*8,12*8),
        Color.new(26*8,26*8,25*8))
   end
@@ -3485,7 +3485,7 @@ end
 # Main
 ################################################################################
 def animationEditorMain(animation)
-  viewport=Viewport.new(0,0,(512+288)*$ResizeFactor,(384+288)*$ResizeFactor)
+  viewport=Viewport.new(0, 0, SCREEN_WIDTH + 288, SCREEN_HEIGHT + 288)
   viewport.z=99999
   # Canvas
   canvas=AnimationCanvas.new(animation[animation.selected],viewport)
@@ -3719,16 +3719,11 @@ def pbAnimationEditor
     animation=PBAnimations.new
     animation[0].graphic=""
   end
-  oldsize=Win32API.client_size
+  Graphics.resize_screen(SCREEN_WIDTH + 288, SCREEN_HEIGHT + 288)
-  oldzoom = $PokemonSystem.screensize
+  pbSetResizeFactor(1)
-  oldborder = $PokemonSystem.border
-  $PokemonSystem.border = 0
-  pbSetResizeFactor
-  Win32API.SetWindowPos((512+288)*$ResizeFactor,(384+288)*$ResizeFactor)
   animationEditorMain(animation)
-  $PokemonSystem.border = oldborder
+  Graphics.resize_screen(SCREEN_WIDTH, SCREEN_HEIGHT)
-  pbSetResizeFactor(oldzoom)
+  pbSetResizeFactor($PokemonSystem.screensize)
-  Win32API.SetWindowPos(oldsize[0],oldsize[1])
   $game_map.autoplay if $game_map
 end
 

Data/Scripts/022_Compiler/003_Compiler_PBS.rb

@@ -1073,7 +1073,7 @@ module Compiler
         end
         lineno += 1
         Graphics.update if lineno%50==0
-        Win32API.SetWindowText(_INTL("Processing {1} line {2}",FileLineData.file,lineno)) if lineno%50==0
+        pbSetWindowText(_INTL("Processing {1} line {2}",FileLineData.file,lineno)) if lineno%50==0
       }
       f.close
     end

Data/Scripts/999_Main/999_Main.rb

@@ -39,7 +39,6 @@ def mainFunctionDebug
     $data_common_events = pbLoadRxData("Data/CommonEvents")
     $data_system        = pbLoadRxData("Data/System")
     $game_system        = Game_System.new
-    setScreenBorderName("border")   # Sets image file for the border
     Graphics.update
     Graphics.freeze
     $scene = pbCallTitle

mkxp.json

@@ -89,7 +89,7 @@
     // in RGSS2 or higher).
     // (default: 0)
     //
-    // "defScreenW": 640,
+    "defScreenW": 512,
 
 
     // Specify the window height on startup. If set to 0,
@@ -98,7 +98,7 @@
     // in RGSS2 or higher).
     // (default: 0)
     //
-    // "defScreenH": 480,
+    "defScreenH": 384,
 
 
     // Override the game window title