rpg-herumlaufkarten-speicherformat

[3_of_8]

Das wird nicht sonderlich kompliziert umzusetzen.

Pseudocode:

Delphi-Quellcode:

for I:=0 to Width-1 do
  for J:=0 to Height-1 do
  begin
    Draw(I*TILEWIDTH, J*TILEHEIGHT, TileSets[GroundLayer.TileSet][GroundLayer.Map[I, J]);
    Draw(I*TILEWIDTH, J*TILEHEIGHT, TileSets[UpperLayer.TileSet][UpperLayer.Map[I, J]);
  end;

Bei der Kollision lädst du einfach und schaust, ob die Spielfigur sich gerade ganz oder teilweise auf einem nicht-begehbaren Feld des Ground- oder Upperlayer befindet.

So in der Art wird es auch im Original-Pokemon-Spiel gemacht und auch z.B. im RPG-Maker.

[dajuhsa]

ja stimmt eigentlich^^ danke für eure Hilfe, ich werde mich im (sehr warscheinlichen) Falle einen weiteres Problems einfach an euch wenden :dp:

[dajuhsa]

hi nochmal :mrgreen: also ich dachte ich versteh es, hab mich an die arbeit zu nem level-editor gemacht und bin stecken geblieben.
Soll ich jetzt also 3 Karten machen: die Bodentexturen, die Objekte und die Kollisionen? Undwie soll ich die dann speichern? alle in den gleichen Textfile oder was :gruebel: ich komm echt nicht weiter, außerdem hat mich das code-beispiel

Delphi-Quellcode:

for I:=0 to Width-1 do 
  for J:=0 to Height-1 do 
  begin 
    Draw(I*TILEWIDTH, J*TILEHEIGHT, TileSets[GroundLayer.TileSet][GroundLayer.Map[I, J]); 
    Draw(I*TILEWIDTH, J*TILEHEIGHT, TileSets[UpperLayer.TileSet][UpperLayer.Map[I, J]); 
    //                                                  ^^^^^^^             ^^^^^^^^^
  end;

schon etwas verwirrt, was ist denn da jetzt TileSet und Map und die verschachtelten [ und ] verwirren etwas :stupid:

es besteht wohl noch etwas erklärungsbedarf für mich ^^"
bitte Hilfe

[TGLDX]

Zitat:

Soll ich jetzt also 3 Karten machen: die Bodentexturen, die Objekte und die Kollisionen? Undwie soll ich die dann speichern? alle in den gleichen Textfile oder was ich komm echt nicht weiter, außerdem hat mich das code-beispiel

Hier mal ein Beispiel:

Delphi-Quellcode:

type
  tTile = Integer; 
  tLayer = array of array of tTile;
  tMap = array[0..2] of tLayer;

Also ein Tile ist ein Feld deiner 2d-Karte. Die Karte hat 3 (oder mehr) "Layer", jedes davon ist so groß wie die Karte und stellt quasi eine "Scheibe" von ihr dar. Die einzelnen Tiles können verschiedene Informationen beinhalten. Die Tiles in Layer 0 könnten Beispielsweise den Index des zu verwenden Bildes darstellen. Die Tiles aus Layer 1 wären zum Beispiel Objekte die transparent darüber gezeichnet werden.
Das 3. Layer könnte Informationen über Passierbarkeit beinhalten (z.b 0 passierbar,1 unpassierbar, 2 nur passierbar wenn die Spielfigur fliegt). Ein anderer Ansatz wäre dabei, dass da 3. Layer Infos enthält wie z.B. 0 normales Feld,54 Figur nimmt Schaden wenn sie darüber geht, 100 unpassierbares normales Feld (Der Unterschied besteht darin, dass beim 1. Ansatz die Passierbarkeit direkt gespeichert wird,beim 2. wären zum Beispiel Felder mit Wert < 100 passierbar, mit Wert >= 100 unpassierbar).

Speichern ist im Prinzip nicht schwer, hier mal ein möglicher Aufbau der Datei:
Breite der Karte in Tiles
Höhe der Karte in Tiles
Anzahl der Layer (falls variabel)
1. Tiles des 1. Layers
...
Letztes Tile des 1. Layers
...

mfg TGLDX

[dajuhsa]

also ein file of integer, oder was?

[Namenloser]

Tipp von mir: Lass das lieber mit dem "file of ...". Das ist aus der Steinzeit und auch der "klassische" Weg, aber meiner Meinung nach wirklich nicht zu empfehlen, weil es unflexibel und kompliziert ist. Guck dir lieber mal Streams an, damit kann man meiner Meinung nach sehr viel besser arbeiten.

Hier mal eine Erklärung über die Grundstruktur der unten deklarierten typen: tMap enthält zwei Layer vom Typ tTileset. dieses tTileSet ist ein zweidimensionales Array von dem record-typ tTile. tTile wiederum enthält alle Infos zu einem Tile, in diesem Fall nur den Typ, und ob man damit kollidiert. Das kann natürlich noch erweitert werden, z.b. könntest du Portale bauen, bei denen du dann speicherst, an welcher Stelle der Spieler rauskommt, oder ein Flag für wasser etc...

Pseudocode:

Delphi-Quellcode:

type
  tTileType = (tFloor,tGrass,tTree);
  tTile = record // Natürlich könnte man sich den Record auch sparen, und stattdessen tTileType benutzen, wo man dann
                 // allerdings anhand des Typen erkennen müsste, ob es eine Kollision gibt. Ich würde hier auf jeden Fall 
                 // einen Record nehmen, denn wer weiß, was du später noch an Zusatzinformationen speichern willst
    Type: tTileType;
    Collide: Boolean;
  end;
  tTileset = array of array of tTile; // Beachte, dass der erste Index hier Y und der zweite X. Vom Gefühl her würde man es
                                      // vielleicht anderherum machen, aber die Erfahrung hat mich gelehrt, dass es sorum auf
                                      // Dauer praktischer ist
  tMap = array[0..1] of tTileset; // 0 = bottomlayer, 1= toplayer
var 
  MemStream: tMemoryStream;
  Map: tMap;
  TileSetW,TileSetH: integer; // Breite und Höhe des Tilesets
  i,y,x: integer;
begin
  // Höhe und Breite des Tilesets in lokalen Variablen zwischenspeichern
  TileSetH := high(Map[0]) + 1;
  TileSetW := high(Map[0][0]) + 1; // Normalerweise sollte man hier noch prüfen, ob es die Höhe des Tilesets >0 ist, weil es 
                                   // hier sonst eine Zugriffverletzung geben könnte
  memstream := tmemorystream.create;
  // Aus Performancegründen wird jetzt der gesamte Speicherbedarf ausgerechnet:
  // Zwei Integers (Höhe und Breite) + Anzahl der Tiles * Platzbedarf eines Tiles, und das ganze für jeden der zwei layer
  memstream.size := SizeOf(integer)*2+TileSetH*TileSetW*sizeof(tTile)*2;
  memstream.position := 0;  // Wir fangen bei 0 an zu schreiben
  // Für jeden Layer:
  for i := 0 to 1 do
    for y := 0 to TilesetH-1 do
      for x := 0 to TilesetW-1 do
        memstream.write(Map[i][y][x],sizeof(tTile)); // Das hier ist der eigentliche Teil^^
  // Inhalt des memoryStreams auf der festplatte ablegen
  memstream.savetofile('fertig.map');

  memstream.free;
end;

Okay, sieht jetzt vielleicht doch etwas kompliziert aus, aber das meiste davon sind ja auch Kommentare und Typendeklarationen :mrgreen:
So, jetzt ist meine Antwort c.a. drei fünf mal so lang ausgefallen, wie ich erwartet hatte, ich hoffe, man versteht es wenigstens :oops:

[dajuhsa]

naja, ich weiß zwar nicht was ein Stream für einen Vorteil hat, aber das erscheint mir einleuchtend. Ich hab mich auch noch nicht wirklich mit Streams befasst :oops: aber ich denke mal, das wird nicht allzu schwierig.

Zu deinem Code:

- Erstmal gefällt er mir :wink:

- erst Y dann X, das erscheint mir einleuchtend, da man es bei einem Textfile genauso macht, also erst der Zeilenindex und dann die Zeichennummer.

- die idee, das collide mit in das Tile zu nehmen erescheint mir zwar praktisch, allerdings hätte ich dann diese information zweimal, also im TopLayer und im GroundLayer, aber 14(Breite)*10(Höhe) = 140 Bits, also 18 Bytes pro Map sind ja nicht die Welt und allzu Komplex (Wasser, Portale, etc.) wird das ganze nicht werden, also kann ich das auch aus dem TopLayer ablesen(Objekt = nicht gehen können, kein Objekt = gehen können)

Delphi-Quellcode:

  memstream.write(TileSetH,4); //<-- gehört das nicht dazu? oder kann man das später irgendwie anhand der 
  memstream.write(TileSetW,4); //streamgröße rausfinden? nicht, dass später die Zeilen zu früh/spät "abgehackt" werden
  for i := 0 to 1 do
    for y := 0 to TilesetH-1 do
      for x := 0 to TilesetW-1 do
        memstream.write(Map[i][y][x],sizeof(tTile));

- warum schreibt die ganze Welt eigentlich

Delphi-Quellcode:

x := sizeOf(Integer);

wenn man doch auch einfach

Delphi-Quellcode:

x := 4;

schreiben könnte oder irre ich mich da etwa? :mrgreen:

[phXql]

Keine Magic numbers verwenden. 4 ist in dem Fall so eine :)

[Namenloser]

Du weißt nie, wie groß ein Integer mal in zukünftigen/älteren Versionen sein wird/war.

[dajuhsa]

ok ok... ich werds mir merken, aber was ist denn jetzt mit

Delphi-Quellcode:

mem.write(tilesetH,sizeof(integer));
mem.write(tilesetW,sizeof(integer));

ist das jetzt notwendig oder nicht?