spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Zitat von »Schorsch«

Im Prinzip wurde schon alles wichtige gesagt. Den allgemeinen Aufbau einer Tilemap kennst du ja denke ich. Ob du jetzt std::vector, std::array, ein normales Array, ein zweidimensionales Array oder was weiß ich benutzt spielt im Prinzip erst mal keine Rolle. Das ist ja nur die intere Datenhaltung deiner Map.
Wenn du eine zweidimensionale Struktur benutzt, dann kannst du direkt über 2 Indizes (x und y) auf die Tiles zugreifen und bei einer eindimensionalen Struktur würdest du dir eine Funktion schreiben die von den zwei Koordinaten x und y auf den Index umrechnet. Das sollte hoffentlich alles klar sein und du weißt hoffentlich wie du den Part umsetzen kannst. Wenn nicht, dann musst du dir das ganze noch mal angucken und gegebenenfalls nachfragen.
Festhalten können wir also dass du eine Datenstruktur hast um die Tiles zu speichern die deine Map bilden und dass du über die Koordinaten x und y darauf zugreifen kannst.
Ich würde jetzt so vorgehen und sagen, wenn der Benutzer eine neue Map erstellt so öffnet sich ein Dialog in welchem er die Größe der Map festlegen kann. Hier können von mir aus zusätzliche Dinge angegeben werden wie Name der Map, Tilegröße, Tileset und was du sonst so alles benötigst. Mach dir hier einfach Gedanken was der Benutzer bestimmen kann und was vorab klar für dein Programm sein sollte. Für den Anfang reicht es ja wenn du hier nur die Größe angeben kannst und der Rest fest vom Programm vorgegeben ist. Erweitern kannst du später immer noch. Jetzt wirst du irgendein Fenster haben in welchem die Karte selbst erstellt wird. Wie du ja selbst weißt benutzen die meisten Tilemapeditoren ein Raster (welches normal auch als solches zu erkennen ist) auf welchem du die Tiles dann verteilst. Du kennst die Größe der Map und die Größe eines Tiles und kannst du das Raster zeichnen. Entweder renderst du einfache Linien und baust dir damit ein Raster, oder hast eine Große Grafik für das ganze Raster (dann musst du für passende Grafikgrößen sorgen da die Maps verschieden groß sein können sollen). Um das zu umgehen kannst du auch einfach eine Grafik in der Größe eines einzelnen Tiles machen. Diese Grafik ist eine Zelle deines Rasters. Jetzt renderst du im Prinzip dieses Rastertile über die ganze Map. Im Prinzip splittest du so die Grafik deines großen Rasters auf eine kleine Grafik die du dann im Programm nebeneinander setzt. Selbes Prinzip wie bei Tilemaps auch. Du stückelst eine Große Grafik und setzt sie im Programm passend zusammen.
Wenn dein Benutzer mit der Maus über die Map fährt, so kannst du jetzt auch einzelne Tiles highlighten damit der Benutzer direkt erkennt welche Fläche er bearbeitet. Wenn der Benutzer jetzt zum Beispiel ein Tile setzen möchte wird er ja vermutlich einfach auf die Map klicken müssen. Dein Programm muss also verstehen welche Zelle deiner Map unter der Maus liegt. Ich erkläre das ganze mal für einen Editor ohne Scrollbars. Willst du Scrollbars oder einen anderen Scrollmechanismus einbauen um größere Maps zu erstellen muss das ganze ein wenig angepasst werden. Das überlasse ich erst mal dir, ich will dir ja nicht die ganze Arbeit abnehmen.
Du kennst normalerweise die Koordinaten der Maus und du willst die Indizes X und Y der darunterliegenden Kachel wissen. Du weißt wie hoch und wie breit eine Kachel ist. Ich vereinfache das ganze mal ein wenig und lege ein paar Dinge fest.
Deine Map besitzt kein scrolling und wird oben links in die Ecke (an Koordinate 0,0) gerendert. Das heißt das Tile mit der Position 0,0 wird in deinem Fenster auch an die Position 0,0 gerendert. Das Tile mit der Position 1,0 würde dann zum Beispiel rechts neben das erste gerendert. Im Prinzip wie bei jeder anderen Map auch. Mir geht es nur darum dass wenn du einen Offset für deine Map einbaust (zum Beispiel für irgendwelche Menüs) dann muss dieser natürlich auch in deinen Berechnungen bedacht werden. Bevor das hier zu kompliziert wird und ich dich nur verwirre, vergiss das vielleicht erst mal einfach und mach dir da keine Gedanken. Um also die Indizes für ein Tile unter der Maus zu berechnen tust du folgendes:
IndexX = MausX / TileBreite
IndexY = MausY / TileHöhe
und das ist schon alles. Wie gesagt man kann das ganze um einen Offset erweitern falls einige Dinge neben oder vor die Map gerendert werden sollen. Für eine scroll-Funktion der Karte wäre ein Offset auch zu bedenken. Das würde ich aber erst mal alles weg lassen. Fang erst mal ganz einfach an.
Nachträglich kannst du über eine Funktion nachdenken um die Größe der Map nachträglich verändern zu können. Da würde ich mich aber drum kümmern wenn der Rest klappt. Sonst musst du über zu viel auf einmal nachdenken und kommst am Ende nur durcheinander. Sinnvoll ist es sicherlich wenn du dir mal andere Tileeditoren anguckst. Tiled ist da ein gutes Beispiel für einen sehr guten Editor der sehr viel kann. Bei Youtube gibt es sicherlich einige Videos in welchen Leute ihre eigenen Editoren vorstellen. Da könntest du auch mal drüber gucken. Dann solltest du dir bewusst werden was dein Editor können soll und wie man damit arbeiten soll. Wie gesagt, mach nicht zu viel auf einmal. Fang lieber erst mal kleiner an und Baue neue Features lieber nacheinander ein.

Zitat von »EuadeLuxe«

Ich glaube du hast da einen Denkfehler: Die Welt-Größe ergibt sich aus der Anzahl der Tiles (die Zahl, die du abfrägst, in deinem Fall <300, 400>). Daneben hast du die Größe der einzelnen Tiles (<40, 30>). Die insgesamte Fläche in Pixeln beträgt dann Weltgröße * Tile-Größe, in deinem Fall also <12000, 12000>. Du teilst nicht die Weltgröße durch die Tile-Größe, da die Weltgröße ja per Definition in Tiles angegeben wird. Um von Tiles nach Pixeln zu kommen musst du ja nur noch mit der Größe eines Tiles in Pixeln multiplizieren.

Zitat von »KeksX«

Zitat von »Sceiwen«

Zitat von »EuadeLuxe«

Ich glaube du hast da einen Denkfehler: Die Welt-Größe ergibt sich aus der Anzahl der Tiles (die Zahl, die du abfrägst, in deinem Fall <300, 400>). Daneben hast du die Größe der einzelnen Tiles (<40, 30>). Die insgesamte Fläche in Pixeln beträgt dann Weltgröße * Tile-Größe, in deinem Fall also <12000, 12000>. Du teilst nicht die Weltgröße durch die Tile-Größe, da die Weltgröße ja per Definition in Tiles angegeben wird. Um von Tiles nach Pixeln zu kommen musst du ja nur noch mit der Größe eines Tiles in Pixeln multiplizieren.

Also soll der Benutzer die Breite und die Höhe des einzelnen Tiles angeben können und dann noch wie viele er auf der X und Y Koordinate haben möchte ?
Denn ich kann mir schlecht vorstellen die komplette Größe nur aus der Breite und Höhe jedes einzelnen Tiles zu berechenen.

Wenn du 256 Tiles auf der X-Achse hast und 256 auf der Y-Achse, und jedes Tile ist 32*32px groß, dann kannst du für das Tile auf Position 256/256 folgendes machen:
TileX = (256-1) * 32;
TileY = (256-1) * 32;

Das -1 kommt daher, dass das erste Tile bei 0 ist.