Darstellungsbereich von Planes erweitern?

[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.