Tilemap - Auflösungsunabhängig

Übersicht

BlitzMax, BlitzMax NG

Beginners-Corner

	M0rgenstern Betreff: Tilemap - Auflösungsunabhängig	So, Jul 31, 2011 14:45 Antworten mit Zitat
Hallo Leute. Ich bräuchte ein wenig Hilfe. Undzwar habe ich folgendes Problem: Ich habe einen Tilemapeditor geschrieben, nur was ganz elementares. Jetzt Wollte ich auf nem anderen PC weiterprogrammieren bzw mit diesem Editor arbeiten. Daraus ergibt sich folgendes Problem: Der Editor hat auf nem Rechner mit 12801024 super funktioniert, man konnte also auch alles sehen. Auf diesem Rechner gibts jetzt die Auflösung 1366768, das heißt ich sehe den Fenstertitel nicht und ein Teil verschwindet hinter der Taskleiste. Das Problem lässt sich zwar lösen, indem ich eine andere Standardauflösung für das Programm vorgebe, aber: Dann passen weniger/mehr Tiles auf den Schirm. Das heißt man sieht dann entweder nicht alles oder hat einen schwarzen Rand. Jetzt würde ich die Tiles gerne entsprechend Skalieren, so dass bei einer höheren Auflösung einfach größere Tiles gezeichnet werden und bei einer kleineren Auflösung kleinere. Nur leider komm ich nicht drauf wie ich das richtig anstelle und die Tiles dann entsprechend positioniere. Ich hab schonmal was gehabt da wurde 1280/momentaneXAuflösung und 1024/momentanteYAuflösung. Aber irgendwie hat das nicht so gant funktioniert. Außerdem ist mir eingefallen, dass ich alles in dem Programm/Spiel umrechnen müsste. Gibts da keine Möglichkeit das anders zu gestalten? und wenn nicht: Wie rechnet man das ordentlich um? Wäre super, wenn mir jemand helfen könnte. Lg, M0rgenstern

M0rgenstern

Betreff: Tilemap - Auflösungsunabhängig

So, Jul 31, 2011 14:45
Antworten mit Zitat

Hallo Leute.
Ich bräuchte ein wenig Hilfe.
Undzwar habe ich folgendes Problem: Ich habe einen Tilemapeditor geschrieben, nur was ganz elementares. Jetzt Wollte ich auf nem anderen PC weiterprogrammieren bzw mit diesem Editor arbeiten.
Daraus ergibt sich folgendes Problem: Der Editor hat auf nem Rechner mit 1280*1024 super funktioniert, man konnte also auch alles sehen.
Auf diesem Rechner gibts jetzt die Auflösung 1366*768, das heißt ich sehe den Fenstertitel nicht und ein Teil verschwindet hinter der Taskleiste. Das Problem lässt sich zwar lösen, indem ich eine andere Standardauflösung für das Programm vorgebe, aber: Dann passen weniger/mehr Tiles auf den Schirm. Das heißt man sieht dann entweder nicht alles oder hat einen schwarzen Rand.
Jetzt würde ich die Tiles gerne entsprechend Skalieren, so dass bei einer höheren Auflösung einfach größere Tiles gezeichnet werden und bei einer kleineren Auflösung kleinere.
Nur leider komm ich nicht drauf wie ich das richtig anstelle und die Tiles dann entsprechend positioniere. Ich hab schonmal was gehabt da wurde 1280/momentaneXAuflösung und 1024/momentanteYAuflösung. Aber irgendwie hat das nicht so gant funktioniert. Außerdem ist mir eingefallen, dass ich alles in dem Programm/Spiel umrechnen müsste. Gibts da keine Möglichkeit das anders zu gestalten? und wenn nicht: Wie rechnet man das ordentlich um?

Wäre super, wenn mir jemand helfen könnte.

Lg, M0rgenstern

	Midimaster	So, Jul 31, 2011 15:35 Antworten mit Zitat
Hier musst Du nun abwägen zwischen guter Erkennbarkeit und gleichbleibender Felderanzahl.... A. feste Feldgröße Bei einem Editor würde ich einfach den sichtbaren Bereich des Spielfeldes an die tatsächliche Windowsgröße anpassen. Zieht man das Fenster auf, sind auch mehr Felder zu sehen. Ein User mit 1024x600 muss halt dann mit einem Minimum an sichtbarem Bereich auskommen. Zu programmieren geht dies relativ leicht. Du muss ja theoretisch in den beiden For X=0 to nn bzw. ForY=0 to mm nur die Werte nn und mm vorab aus der Fenstergröße minus Bedienelemente berechnen. Natürlich muss es dann "Scrollen" geben, aber das hast Du ja vielleicht sowieso schon. B. skalierte Felder Wenn Du die immer gleiche anzahl an Felder im Editor anzeigen willst, berechnetst Du einen Faktor f# und wenn Du sauber FeldZeichnen und BedienelementeZeichnen aus einandergehalten hast müsste ein simples Code: [AUSKLAPPEN] [EINKLAPPEN] SetScale f#,f# ...vor dem Zeichnen ausreichen, um den sichtbaren Bereich ausreichend zu skalieren. Zusätzlich muss eigentlich nur noch die Mauskoordinate umgerechnet werden - dann stimmt schon wieder alles. Blöd nur, wenn der User das Seitenverhältnis des Fensters ändert. Hier würde ich auf keinen Fall die Quadrate verzerrren, sondern zusätzlich ein "Scrollfenster" wie in A. beschrieben betreiben. C. Resume Wie du siehst, kommst du um ein Scrollfenster nicht herum.... also beginne mit der Programmierung eines Editors nach System A. "Scrollen billig" Um jetzt nicht ein zu kompliziertes Scrollen schreiben zu müssen, kannst Du einfach 4 Tasten dazu bestimmen in den beiden For/Next-Schleifen den Startwert 0 zu ändern BlitzMax: [AUSKLAPPEN] [EINKLAPPEN] For x=0 To nn 'wird dann zu For X=SichtX To SichtX+nn SichtX geht dabei von 0 bis zur (ArrayBreite - AnzahlderSichtbaren) (gerechnet in Felder, nicht in Pixeln) Bei der Maus wird BlitzMax: [AUSKLAPPEN] [EINKLAPPEN] MausX=MouseX()/Raster 'wird jetzt zu: MausX=MouseX()/Raster - SichtX das wars....

Midimaster

So, Jul 31, 2011 15:35
Antworten mit Zitat

Hier musst Du nun abwägen zwischen guter Erkennbarkeit und gleichbleibender Felderanzahl....

A. feste Feldgröße

Bei einem Editor würde ich einfach den sichtbaren Bereich des Spielfeldes an die tatsächliche Windowsgröße anpassen. Zieht man das Fenster auf, sind auch mehr Felder zu sehen. Ein User mit 1024x600 muss halt dann mit einem Minimum an sichtbarem Bereich auskommen.

Zu programmieren geht dies relativ leicht. Du muss ja theoretisch in den beiden For X=0 to nn bzw. ForY=0 to mm nur die Werte nn und mm vorab aus der Fenstergröße minus Bedienelemente berechnen. Natürlich muss es dann "Scrollen" geben, aber das hast Du ja vielleicht sowieso schon.

B. skalierte Felder

Wenn Du die immer gleiche anzahl an Felder im Editor anzeigen willst, berechnetst Du einen Faktor f# und wenn Du sauber FeldZeichnen und BedienelementeZeichnen aus einandergehalten hast müsste ein simples
Code: [AUSKLAPPEN]

SetScale f#,f#

...vor dem Zeichnen ausreichen, um den sichtbaren Bereich ausreichend zu skalieren. Zusätzlich muss eigentlich nur noch die Mauskoordinate umgerechnet werden - dann stimmt schon wieder alles.

Blöd nur, wenn der User das Seitenverhältnis des Fensters ändert. Hier würde ich auf keinen Fall die Quadrate verzerrren, sondern zusätzlich ein "Scrollfenster" wie in A. beschrieben betreiben.

C. Resume

Wie du siehst, kommst du um ein Scrollfenster nicht herum.... also beginne mit der Programmierung eines Editors nach System A.

"Scrollen billig"
Um jetzt nicht ein zu kompliziertes Scrollen schreiben zu müssen, kannst Du einfach 4 Tasten dazu bestimmen in den beiden For/Next-Schleifen den Startwert 0 zu ändern

BlitzMax: [AUSKLAPPEN]

For x=0 To nn
'wird dann zu 
For X=SichtX To SichtX+nn

SichtX geht dabei von 0 bis zur (ArrayBreite - AnzahlderSichtbaren)
(gerechnet in Felder, nicht in Pixeln)

Bei der Maus wird
BlitzMax: [AUSKLAPPEN]

MausX=MouseX()/Raster
'wird jetzt zu:
MausX=MouseX()/Raster - SichtX

das wars....

	M0rgenstern	So, Jul 31, 2011 16:50 Antworten mit Zitat
Naja, das Problem ist folgendes: Das Spiel soll von der Anordnung her sein wie Pacman, Bomberman etc. also nur innerhalb eines Fensters, ohne dass die Map scrollt. Deswegen müsste ich ja alles skalieren, oder seh ich das falsch? Lg, M0rgenstern

M0rgenstern

So, Jul 31, 2011 16:50
Antworten mit Zitat

Naja, das Problem ist folgendes: Das Spiel soll von der Anordnung her sein wie Pacman, Bomberman etc. also nur innerhalb eines Fensters, ohne dass die Map scrollt.
Deswegen müsste ich ja alles skalieren, oder seh ich das falsch?

Lg, M0rgenstern

	n-Halbleiter	So, Jul 31, 2011 19:01 Antworten mit Zitat
Wenn du mit Max2D arbeitest, kannst du auch virtuelle Auflösungen nutzen. (siehe Befehl "SetVirtualResolution" - oder so ähnlich).
mfg, Calvin Maschine: Intel Core2 Duo E6750, 4GB DDR2-Ram, ATI Radeon HD4850, Win 7 x64 und Ubuntu 12.04 64-Bit Ploing! Blog "Die Seele einer jeden Ordnung ist ein großer Papierkorb." - Kurt Tucholsky (09.01.1890 - 21.12.1935)

n-Halbleiter

So, Jul 31, 2011 19:01
Antworten mit Zitat

Wenn du mit Max2D arbeitest, kannst du auch virtuelle Auflösungen nutzen. (siehe Befehl "SetVirtualResolution" - oder so ähnlich).

mfg, Calvin
Maschine: Intel Core2 Duo E6750, 4GB DDR2-Ram, ATI Radeon HD4850, Win 7 x64 und Ubuntu 12.04 64-Bit
Ploing!
Blog
"Die Seele einer jeden Ordnung ist ein großer Papierkorb." - Kurt Tucholsky (09.01.1890 - 21.12.1935)

	das wurgel	So, Jul 31, 2011 20:05 Antworten mit Zitat
Hi Wenn du nach Midimasters Methode B vorgehen willst, das ist glaube ich auch das was du am ehesten wolltest, dann ist der Faktor das kleinere von momentaneXAuflösung/1280 und momentanteYAuflösung/1024. So sieht jeder, der ein anderes Seitenverhältnis hat, seitlich oder oben und unten einen schwarzen Rand.
1 ist ungefähr 3

das wurgel

So, Jul 31, 2011 20:05
Antworten mit Zitat

Hi

Wenn du nach Midimasters Methode B vorgehen willst, das ist glaube ich auch das was du am ehesten wolltest, dann ist der Faktor das kleinere von momentaneXAuflösung/1280 und momentanteYAuflösung/1024. So sieht jeder, der ein anderes Seitenverhältnis hat, seitlich oder oben und unten einen schwarzen Rand.

1 ist ungefähr 3

	PhillipK	Mo, Aug 01, 2011 6:35 Antworten mit Zitat
Heyho M0rgenstern Ich persönlich arbeite immer mit einem batzen CONST Hierzu einmal Const ResX:Int = 1024, ResY:Int = 768 (zb) Des weiteren entweder eine zahl mit den Tiles vertikal und horizontal sichtbar (für scrollbare maps etc), welche sich aus Resx/TileSize und ResY/Tilesize ergeben. Andersrum lässt sich natürlich auch aus einer gewünschten Tilezahl die Tilesize errechnen. In diesem fall würde es ein loader tun, welcher die Pixmaps der tiles entsprechend skaliert - so hast du am ende keinen unterschied. Der vorteil an dieser komplexen methode ist, das du jederzeit alles verändern kannst und - sofern die brav überall die const-werte verwendest - alles gleich bleibt. Die 2te Methode ist die, wie von n-Halbleiter bereits genemerkt - virtualResolution. Hier gibt es zu beachten, das du nichtmehr MouseX() und MouseY() verwenden kannst, sondern zwangsweise VirtualMouseX() únd y() - allerdings nimmt dir dann Max2d alle arbeit ab! Wenn du noch nie mit VirtualResolution gearbeitet hast, hier mal ein kleines Testprogramm: BlitzMax: [AUSKLAPPEN] [EINKLAPPEN] SuperStrict Const ResX:Int = 1024, ResY:Int = 768 'auf diese werte konzepiere ich mein programm! Gleichzeitig auch fensterauflösung :) Global VResX:Float = ResX, VResY:Float = ResY 'diese werte stellen die tatsächlich dargestellte größe da. Local rotation:Int = 0 'kleine testvar Graphics(ResX, ResY) SetVirtualResolution(VResX, VResY) SetHandle(20, 20) 'Dafür sorgen, das das Rect in der mitte bleibt :) While Not KeyHit(KEY_ESCAPE) And Not AppTerminate() Cls Local mr:Int = MouseZSpeed() If mr <> 0 Then 'das mausrad wurde gedreht! 'Die variablen zur VRes anpassen! in dem fall: 1.1 oder 0.9. VResX:(1.0 + (mr / 10.0)) VResY:(1.0 + (mr / 10.0)) SetVirtualResolution(VResX, VResY) EndIf rotation = (rotation + 5) Mod 360 SetRotation(rotation) SetScale(1, 1) 'Skalierung beibehalten! DrawRect(VResX / 2, VResY / 2, 40, 40) SetRotation(0) 'Rotation 0 um text zu zeichnen! SetScale(VResX / ResX, VResY / ResY) 'Text lesbar halten! DrawText("VMouse Pos!", VirtualMouseX() + 20, VirtualMouseY() + 20) '+20 +20 wegen SetHandle() ! DrawText("VResX: " + Int(VResX), 50 * (VResX / ResX), 50 * (VResY / ResY)) 'Multiplikation mit dem faktor zwischen VRes und Res um ETWA die positionen zu behalten! DrawText("VResY: " + Int(VResY), 50 * (VResX / ResX), 70 * (VResY / ResY)) Flip 1 Wend Ich persönlich mag VirtualResolution nicht.. ich weiß nicht, obs simplere möglichkeiten gibt - aber wenn man sich das so anschaut, isses doch n ziemliches gemurkse edit: PS: Für deinen fall musst du das ganze allerdings andersrum ändern - VirtualResolution als die auflösung, für die du das ganze konzepierst und ResX/ResY müssen variabel sein - SORRY! Hatte das grade in meinem hirn mit meinem Zoomversuch vertauscht PSS: Um gleichbleibende Schriftgröße und position etc zu behalten, könnte es auch theoretisch klappen, einmal pro frame nach dem CLS das SetvirutalResolution(VResX,VResY) aufzurufen und vor dem textstuff SetVirtualResolution(ResX,ResY)

PhillipK

Mo, Aug 01, 2011 6:35
Antworten mit Zitat

Heyho M0rgenstern Smile

Ich persönlich arbeite immer mit einem batzen CONST

Hierzu einmal Const ResX:Int = 1024, ResY:Int = 768 (zb)
Des weiteren entweder eine zahl mit den Tiles vertikal und horizontal sichtbar (für scrollbare maps etc), welche sich aus Resx/TileSize und ResY/Tilesize ergeben.

Andersrum lässt sich natürlich auch aus einer gewünschten Tilezahl die Tilesize errechnen.
In diesem fall würde es ein loader tun, welcher die Pixmaps der tiles entsprechend skaliert - so hast du am ende keinen unterschied.
Der vorteil an dieser komplexen methode ist, das du jederzeit alles verändern kannst und - sofern die brav überall die const-werte verwendest - alles gleich bleibt.
Die 2te Methode ist die, wie von n-Halbleiter bereits genemerkt - virtualResolution.
Hier gibt es zu beachten, das du nichtmehr MouseX() und MouseY() verwenden kannst, sondern zwangsweise VirtualMouseX() únd y() - allerdings nimmt dir dann Max2d alle arbeit ab!

Wenn du noch nie mit VirtualResolution gearbeitet hast, hier mal ein kleines Testprogramm:

BlitzMax: [AUSKLAPPEN]

SuperStrict

Const ResX:Int = 1024, ResY:Int = 768 'auf diese werte konzepiere ich mein programm! Gleichzeitig auch fensterauflösung :)

Global VResX:Float = ResX, VResY:Float = ResY 'diese werte stellen die tatsächlich dargestellte größe da.

Local rotation:Int = 0 'kleine testvar

Graphics(ResX, ResY)
SetVirtualResolution(VResX, VResY)

SetHandle(20, 20) 'Dafür sorgen, das das Rect in der mitte bleibt :)
While Not KeyHit(KEY_ESCAPE) And Not AppTerminate()
	Cls
	
	Local mr:Int = MouseZSpeed()
	
	If mr <> 0 Then 'das mausrad wurde gedreht!
		'Die variablen zur VRes anpassen! in dem fall: 1.1 oder 0.9.
		VResX:*(1.0 + (mr / 10.0))
		VResY:*(1.0 + (mr / 10.0))
		
		SetVirtualResolution(VResX, VResY)
	EndIf
	rotation = (rotation + 5) Mod 360
	SetRotation(rotation)
	SetScale(1, 1) 'Skalierung beibehalten!
	DrawRect(VResX / 2, VResY / 2, 40, 40)
	
	SetRotation(0) 'Rotation 0 um text zu zeichnen! 
	
	SetScale(VResX / ResX, VResY / ResY) 'Text lesbar halten!
	DrawText("VMouse Pos!", VirtualMouseX() + 20, VirtualMouseY() + 20) '+20 +20 wegen SetHandle() !
	
	DrawText("VResX: " + Int(VResX), 50 * (VResX / ResX), 50 * (VResY / ResY)) 'Multiplikation mit dem faktor zwischen VRes und Res um ETWA die positionen zu behalten!
	DrawText("VResY: " + Int(VResY), 50 * (VResX / ResX), 70 * (VResY / ResY))
	Flip 1
Wend

Ich persönlich mag VirtualResolution nicht.. ich weiß nicht, obs simplere möglichkeiten gibt - aber wenn man sich das so anschaut, isses doch n ziemliches gemurkse Smile

edit:

PS:

Für deinen fall musst du das ganze allerdings andersrum ändern - VirtualResolution als die auflösung, für die du das ganze konzepierst und ResX/ResY müssen variabel sein - SORRY! Hatte das grade in meinem hirn mit meinem Zoomversuch vertauscht Very Happy

PSS: Um gleichbleibende Schriftgröße und position etc zu behalten, könnte es auch theoretisch klappen, einmal pro frame nach dem CLS das SetvirutalResolution(VResX,VResY) aufzurufen und vor dem textstuff SetVirtualResolution(ResX,ResY) Smile

	Midimaster	Mo, Aug 01, 2011 8:32 Antworten mit Zitat
ich hatte es so verstanden, dass du nur den Editor in verschiedenen Auflösungen betreiben willst. Nun, wenn auch das Spiel auf verschiedenen Auflösungen laufen soll und nicht gescrollt werden soll, bleibt Dir ja nichts anderes übrig als die Felder zu skalieren. Wie aufgeräumt sieht denn dein Code aus? Hast Du alle Codezeilen, die etwas malen logisch von den Entscheidungen, Bewegungen, Kollisionen, etc. getrennt? Dann ist es kein großes Ding das Spiel in ein skalierendes umzuwandeln... Dabei bekommst Du ja nur dann schwarze Ränder, wenn das Bildschirmverhältnis mal 4:3 oder 16:9 ist. Ich hatte das gleiche Problem bei meinem "Tatiti"-Projekt und habe es so gelöst, dass ich mit zwei Designs gearbeitet habe und die Bedienelemente oder Anzeigen auf zwei Arten darstellen konnte: 4:3 Code: [AUSKLAPPEN] [EINKLAPPEN] +++++++++++++++++++++ + + + + + Feld + + + +++++++++++++++++++++ + Anzeigen + +++++++++++++++++++++ 16:9 Code: [AUSKLAPPEN] [EINKLAPPEN] +++++++++++++++++++++ + + + + + + + + Feld + + + + +++++++++++++++++++++ Vielleicht hast Du ja auch Anzeigen (Leben, Zeit, etc....), die eigentlich nicht Teil des Spielfeldes sind? Lege sie wahlweise an den unteren Rand oder an den linken Rand . So kannst du den Bildschirm besser ausnutzen und musst nicht unnötig verkleinern.

Midimaster

Mo, Aug 01, 2011 8:32
Antworten mit Zitat

ich hatte es so verstanden, dass du nur den Editor in verschiedenen Auflösungen betreiben willst.

Nun, wenn auch das Spiel auf verschiedenen Auflösungen laufen soll und nicht gescrollt werden soll, bleibt Dir ja nichts anderes übrig als die Felder zu skalieren.

Wie aufgeräumt sieht denn dein Code aus? Hast Du alle Codezeilen, die etwas malen logisch von den Entscheidungen, Bewegungen, Kollisionen, etc. getrennt? Dann ist es kein großes Ding das Spiel in ein skalierendes umzuwandeln...

Dabei bekommst Du ja nur dann schwarze Ränder, wenn das Bildschirmverhältnis mal 4:3 oder 16:9 ist. Ich hatte das gleiche Problem bei meinem "Tatiti"-Projekt und habe es so gelöst, dass ich mit zwei Designs gearbeitet habe und die Bedienelemente oder Anzeigen auf zwei Arten darstellen konnte:

4:3
Code: [AUSKLAPPEN]

+++++++++++++++++++++
+ +
+ +
+ Feld +
+ +
+++++++++++++++++++++
+ Anzeigen +
+++++++++++++++++++++

16:9
Code: [AUSKLAPPEN]

+++++++++++++++++++++
+ + +
+ + +
+ + Feld +
+ + +
+++++++++++++++++++++

Vielleicht hast Du ja auch Anzeigen (Leben, Zeit, etc....), die eigentlich nicht Teil des Spielfeldes sind? Lege sie wahlweise an den unteren Rand oder an den linken Rand . So kannst du den Bildschirm besser ausnutzen und musst nicht unnötig verkleinern.

Übersicht

BlitzMax, BlitzMax NG

Beginners-Corner

Nach Oben

BlitzBasic Portal

Tilemap - Auflösungsunabhängig

M0rgenstern

Betreff: Tilemap - Auflösungsunabhängig

Midimaster

M0rgenstern

n-Halbleiter

das wurgel

PhillipK

Midimaster