Tilemap Hilfestellung

[Raziell]

Hallo zusammen,

ich habe eine Tilemap die mittels aktivem Rendering gezeichnet wird.
Aktuell will ich mich um die Kollission kümmern. Diese will ich auf zwei Arten realisieren.
Zum einen über eine Shadowmap und zum anderen über intersects von Graphics Objekten.
Jedes Teil hat ein normales Bild und ein "Schatten-Bild".
Nun habe ich ein paar Fragen zur Realisierung der Shadowmap Kollission.
Ich stelle mir das in etwa so vor:

-> Nächste Spielerposition ermitteln
-> Tiles holen auf denen der Spieler steht
-> Die Spielerposition innerhalb der Tiles ermitteln
-> Alle Pixel der Tiles die in der Position des Spielers liegen auslesen und auf die entsprechende Farbe prüfen

Mir kommt das allerdings iwie falsch und zu kompliziert vor.
Eventuell hat ja jmd. eine bessere Idee.

Danke

 

[Quaxli]

Es wäre interessant zu wissen, wie die Map aussieht: Handelt es sich um eine isometrische Sicht oder ist es nur "2D" a la Super Mario?

Grundsätzlich würde ich es so angehen: Die "Bewegung" des Spielers wird durch verschieben Karte simuliert. Also das, was Du in den ersten beiden Punkten beschrieben hast.
Danach kommt es darauf an, wie Du Dein Spiel darstellst. Ich würde aber mal behaupten, daß immer nur 1 oder 2 Tiles relevant sein können - je nachdem wo der Spieler steht (korrigiere mich, wenn ich falsch liege).
Die kompletten Pixel der Tiles auszulesen halte ich für übertrieben. Ich würde mich auf wenige Punkte , die aus der Position des Spielers berechnet werden, beschränken.

 

[Raziell]

Hi,
es handelt sich um eine orthogonale Tilemap wie beispielsweise Zelda o.ä.
Der Spieler kann also theoretisch 4 Tiles gleichzeitig berühren.

So ungefähr war mein erster Ansatz (Noch nicht zu Ende gedacht, ich prüfe testweise nur den ersten Pixel eines Tiles):

	private boolean willCollide(long delta) {
          //ermitteln der nächsten Position
		double futureX = player.x + (delta * renderer.getViewport().getHorizontalMovement()) / 1000000000;
		double futureY = player.y + (delta * renderer.getViewport().getVerticalMovement()) / 1000000000;
                
          // Zu prüfende Tiles holen
		List<Tile> playerIntersectingTiles = map.getObjectIntersectingTiles(futureX, futureY, player.width, player.height);

		for (Tile tile : playerIntersectingTiles) {
			BufferedImage shadowImage = tile.getShadowImage();

           // Testweise ersten Pixel eines Tiles holen und Farbe vergleichen (color ist die Kollissionsfarbe der Shadowmap)
			Color color = new Color(0, 255, 24);
			Color color2 = new Color(shadowImage.getRGB(1, 1));

			if (color.getRed() == color2.getRed() && color.getGreen() == color2.getGreen() && color.getBlue() == color2.getBlue()) {
				return true;
			}

		}
		return false;
	}

Allerdings funktioniert das iwie. nicht und kommt mir auch zu kompliziert vor.

 

[Raziell]

Hallo zusammen,
ich habe mir in letzter Zeit ein paar Gedanken gemacht zu dem Thema hier.

So wie es derzeit aussieht, möchte ich von einer Singleplayer Umgebung auf eine Multiplayer Umgebung
wechseln.
Mit der Programmierung des Server habe ich schon vor einiger Zeit angefangen.

Aktuell stellen sich für mich folgende Fragen:

- Ist es sinnvoll 2 verschiedene Arten der Kollissionserkennung zu verwenden? Denn ursprünglich wollte ich die Kollission zum einen über eine Shadowmap und zum anderen über intersects von Graphics Objekten realisieren.
Mir scheint das ganze allerdings iwie zu kompliziert mit 2 verschiedenen Varianten.
Meiner Meinung nach wäre eine Variante schöner.

- Wie wird eigentlich in der Regel die Kollission bei beispielsweise einem MMOPG gehandhabt? Eigentlich muss sich ja der Server darum kümmern oder?

 

[Helgon]

Bei MMOPG's handelt es sich ja meist um Spiele mit 3D Modellen und da wird Kollision mit Intersecting Rays gelöst (unteranderem zumindest)

 

[Fu3L]

- Wie wird eigentlich in der Regel die Kollission bei beispielsweise einem MMOPG gehandhabt? Eigentlich muss sich ja der Server darum kümmern oder?

Jopp, der Server weiß alles und die Clients sind quasie 'ne einfache Render- und Audioeinheit, die nebenbei auf Nutzereingabe lauscht. Den Rest macht der Server. Das kann bei Spielen, die schnelle Objekte beinhalten, durchaus nicht trivial sein (siehe hierzu https://developer.valvesoftware.com/wiki/Source_Multiplayer_Networking).

Zu deinen Kollisionen: Mit der Welt würde ich nur durch die ShadowMap auf Kollisionen testen. Bei Objekten wie Kugeln oder anderen Spielern eher über intersects grob und wie Quaxlie es in seinem Tutorial tut, dann genauer per Test, ob sich irgendwo 2 nicht transparente Pixel überlagern.

 

[Raziell]

Zu deinen Kollisionen: Mit der Welt würde ich nur durch die ShadowMap auf Kollisionen testen.

Also im Prinzip hat der Server ein Abbild der Karte mit allen Tiles.
Dann muss ich mir clientseitig ja garkeine keine Gedanken zur Kollission machen oder?
Ich muss mir allerdings iwie ein Konzept zu Shadowmap Kollission einfallen lassen, finde es garnicht so einfach zu realisieren.
Im Prinzip habe ich nämlich die einzelnen Tiles und zu jedem Tile ein "ShadowImage".
Dann muss ich doch theoretisch anhand von Punkten die über die Spielerposition berechnet werden Pixel des Shadowimages prüfen.

Bei Objekten wie Kugeln oder anderen Spielern eher über intersects grob und wie Quaxlie es in seinem Tutorial tut, dann genauer per Test, ob sich irgendwo 2 nicht transparente Pixel überlagern.

Serverseitig habe ich aber doch eigtl. nur Koordinaten der Spieler und keine Grafiken oder sollte
der Server diese ebenfalls laden?

 

[Fu3L]

Serverseitig habe ich aber doch eigtl. nur Koordinaten der Spieler und keine Grafiken oder sollte
der Server diese ebenfalls laden?

Jo, da spricht denke ich nichts gegen. Die paar KB müllen das RAM auch net unnötig zu.

Dann muss ich mir clientseitig ja garkeine keine Gedanken zur Kollission machen oder?

Das ist schwerer zu sagen.. Wenns nicht flüssig genug läuft, wirst du auf dem Client abschätzen müssen, wie du dich weiterhin bewegen wirst und das dann gegebenenfalls an die Daten, die der Server Millisekunden später schickt, anpassen.

Dann muss ich doch theoretisch anhand von Punkten die über die Spielerposition berechnet werden Pixel des Shadowimages prüfen.

Genau, du lässt dir die beiden Stücke von Spieler und ShadowMap geben, die sich überlappen und testest einfach, ob da beim Spieler ein nichttransparentes Pixel auf ein Pixel der Shadowmap trifft, dass irgendeine Funktion auslösen soll.