Darstellungsbereich von Planes erweitern?

[Cornix]

Guten Abend, heute habe ich ein wirklich besonderes Problem mit Planes.

Ich verwende ein Script um das Spielfenster beliebig zu vergrößern oder zu verkleinern. Ich habe auch prompt von dieser Funktion gebrauch gemacht und die Auflösung auf 800x600 geändert.
Was ich nur leider nun feststellen muss ist, dass die RGSS standardklasse Plane immer nur einen Bildausschnitt von 640x480 liefert. Kann man diese Limitation auf irgendeinem Weg umgehen? Ich würde sehr gerne ein Plane über die volle Fenstergröße darstellen.

Ich danke sehr für alle Antworten.

[Doktor von Stein]

Ist das Problem auch mit der Map?
Wenn ja, ändere den Viewport.
Wenn nein, zeig uns mal bitte das Script dass du nimmst.

[Cornix]

Nein, das Problem liegt lediglich bei Planes. Alles andere wird korrekt angezeigt.

Das Script wurde ursprünglich von jemandem names Selwyn geschrieben, ich fand es im Internet, habe es allerdings seitdem stark verändert um es meinen Bedürfnissen anzupassen.

Code:

module Resolution
#==============================================================================
# Resolution Script
#------------------------------------------------------------------------------
# Script by Selwyn
# Edited by Cornix
# Requires Display.dll
#==============================================================================
  FRAME_WIDTH = 6
  FRAME_HEIGHT = 24

  title = "\0" * 256
  Win32API.new('kernel32', 'GetPrivateProfileString','PPPPLP', 'L').call("Game", "Title", "", title, 256, ".\\Game.ini")
  title.delete!("\0")
  $get_system_metrics = Win32API.new('user32', 'GetSystemMetrics', 'I', 'I')
  $window = Win32API.new('user32', 'FindWindow', 'PP', 'I').call("RGSS Player", title)
  @set_resolution  = Win32API.new('Display.dll', 'SetResolution', 'III', 'I')
  @set_window_long = Win32API.new('user32', 'SetWindowLong', 'LIL', 'L')
  @set_window_pos  = Win32API.new('user32', 'SetWindowPos', 'LLIIIII', 'I')
  
  module_function
  
  def fullscreen(width,height)
    @set_window_long.call($window, -16, 0x14000000)
    @set_window_pos.call($window, -1, 0, 0, width, height, 64)
    @set_resolution.call(width, height, 4)
  end
  
  def set_size(width,height)
    width += FRAME_WIDTH
    height += FRAME_HEIGHT

    monitor_width = $get_system_metrics.call(0)
    monitor_height = $get_system_metrics.call(1)

    x = (monitor_width - width) / 2
    y = (monitor_height - height) / 2

    @set_window_long.call($window, -16, 0x14CA0000)
    @set_window_pos.call($window, 0, x, y, width, height, 0)
    @set_resolution.call(monitor_width, monitor_height, 0)
  end
  
end

[Shining Advances]

die mitgelieferten planes können leider nur innerhalb des bereiches dargestellt werden, den das fenster normal abdeckt. das ist selbst dann so, wenn der viewport außerhalb liegt.
die einzige möglichkeit besteht wohl darin, die plane klasse mithilfe von sprites nachzuschreiben.
ich hab das mal gemacht:

Code:

class Plane
  attr_reader :bitmap
  attr_reader :ox
  attr_reader :oy
  attr_reader :z
  attr_reader :zoom_x
  attr_reader :zoom_y
  attr_reader :opacity
  attr_reader :blend_type
  attr_reader :tone
  
  def initialize(viewport=Viewport.new(0,0,480,640))
    @sprites = {}
    @viewport = viewport
    @bitmap = nil
    @z = @ox = @oy = 0
    @zoom_x = @zoom_y = 1.0
    @opacity = 255
    @blend_type = 0
    @tone = Tone.new(0,0,0,0)
    @color = Color.new(0,0,0,0)
  end
  
  def dispose
    @sprites.each{|k,v| v.dispose}
  end
  
  def bitmap=(bit)
    return if @bitmap == bit
    @bitmap = bit
    refresh
  end
  
  def refresh
    bit = @bitmap
    self.dispose
    unless bit.nil?
      for x in 0...((self.width / bit.width * @zoom_x).to_i + 2)
        for y in 0...((self.height / bit.height * @zoom_y).to_i + 2)
          @sprites[[x,y]] = Sprite.new(@viewport)
          @sprites[[x,y]].bitmap = bit
          @sprites[[x,y]].x = x * bit.width * @zoom_x
          @sprites[[x,y]].y = y * bit.height * @zoom_y
          @sprites[[x,y]].zoom_x = @zoom_x
          @sprites[[x,y]].zoom_y = @zoom_y
          @sprites[[x,y]].z = self.z
          @sprites[[x,y]].tone = @tone
          @sprites[[x,y]].blend_type = @blend_type
          @sprites[[x,y]].color = @color
          @sprites[[x,y]].opacity = @opacity
        end
      end
    end
  end
  
  def ox=(n)
    return if @ox == n
    @ox = n
    n = n / @zoom_x
    @sprites.each{|k,v|
    v.ox = n % v.bitmap.width
    }
  end
  
  def oy=(n)
    return if @oy == n
    @oy = n
    n = n / @zoom_y
    @sprites.each{|k,v|
    v.oy = n % v.bitmap.width
    }
  end
  
  def z=(n)
    return if @z == n
    @z = n
    @sprites.each{|k,v|
    v.z = n
    }
  end
  
  def width
    return @viewport.rect.width
  end
  
  def height
    return @viewport.rect.height
  end
  
  def zoom_x=(n)
    return if @zoom_x == n
    @zoom_x = n
    refresh
  end
  
  def zoom_y=(n)
    return if @zoom_y == n
    @zoom_y = n
    refresh
  end
  
  def opacity=(n)
    return if @opacity == n
    @opacity = n
    @sprites.each{|k,v|
    v.opacity = n
    }
  end
  
  def blend_type=(n)
    return if @blend_type == n
    @blend_type = n
    @sprites.each{|k,v|
    v.blend_type = n
    }
  end
  
  def tone=(t)
    return if @tone == t
    @tone = t
    @sprites.each{|k,v|
    v.tone = t
    }
  end
  
  def color=(c)
    return if @color == c
    @color = c
    @sprites.each{|k,v|
    v.color = c
    }
  end
end

[Cornix]

Sehr freundlich von dir, allerdings habe ich mir bereits damit beholfen die Plane-Klasse selbst, oder zumindest in dem von mir benötigten Maßstab, nach zu modelieren.

Das Problem ist praktisch somit für mich erledigt, es blieb die Neugierde ob es sich dabei um eine Limitation von RGSS handelt oder um sonstetwas. Oder ob es nicht einen einfachen Weg gäbe dieses Limit zu umgehen.