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.


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:


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.