Objekte aus Textdatei erstellen

[Acuaplano]

Moin Moin,

Ich arbeite grad' an einem kleinen Spiel mit der Andorra 2D-Engine, wobei jedoch mein Problem eher Delphi bezogen ist. Das Problem liegt in der Mapgenerierung, die in Textdateien abgespeichert wird. Bis jetzt sah die Mapgenerierung so aus:
Es steht ein Raster, dass aus Zahlen besteht, in etwa so:
1;2,3;
5;2;7;
8;2;3;
Die Zahlen zeigen dabei die Bilder für den Maphintergrund an. Die einzelnen Bilder wurden zuvor in eine Liste mit den entsprechenden Nummern geladen. Anschließend werden beim Laden der Map für jede Zahl ein Objekt an der entsprechenden Stelle und passenden Bildchen erstellt. Funktionieren tut's wunderbar, nur reicht das noch nicht für eine richtige Map:
Wie stelle ich es an, dass Objekte von verschiedenen Klassen gebildet werden, abhängig von dem was in der Textdatei steht?
Beispiel (Mehrere Ebenen sind bereits möglich):
TBaum; 0; TBaum;
TBrett; 0; TNpc;
0; TBaum; THaus;

Dabei muss ne praktische Lösung her, da ja noch ne ganze Menge Objekte dazukommen könnten. Ich hatte mir schon gedacht, dass ich irgendwie alle Objekte in eine Liste reinpacke und dann bei der Generierung daraus gesucht wird... aber wie genau das gehen soll weiß ich auch nicht.

[jaenicke]

Warum benutzt du denn Textdateien? Hat das einen Grund?

Denn viel simpler wäre es, wenn du deinen Klassen jeweils die Methoden LoadFromStream und SaveToStream spendieren würdest, die das ganze binär speichern und laden. Dazu dann noch in der äußersten Ebene LoadFromFile und SaveToFile, die einen TFileStream aufmachen und an deine Streammethoden weitergeben, schon bist du fertig.

Das ist sehr viel einfacher, nur die Dateien sind manuell schlecht lesbar. Aber wenn das nicht wichtig ist, würde ich das eher so machen.

[Acuaplano]

Lesbar muss es nicht sein, dafür mit nem selbst gemachten Editor erstellbar, aber das sollte ja da auch kein Problem sein.
Falls ich das jetzt richtig verstanden habe (TFileStream ist Oberklasse von allen Objekten?), wird das auch nicht funktionieren, da ich die Objekte von einer anderen Klasse der Sprite Engine ableiten muss. Ansonsten müsste ich vielleicht große Teile der Engine umschreiben... und das trau ich mir nicht zu

Und um ehrlich zu sein arbeite ich auch nicht alleine daran. Ein paar andere und ich wollten einfach mal ein Spiel selber machen und ein paar Erfahrungen sammeln. Daher die simplen Texdateien .

[jaenicke]

Hier mal ein Beispiel:

Delphi-Quellcode:

unit UnitXYZ;

interface

uses
  Classes, SysUtils;

type
  TStringReaderWriter = class helper for TStream
    function ReadString: string;
    procedure WriteString(const AValue: string);
  end;

  TMyGameObject = class
  private
    type
      TExample = class
      private
        var
          FExampleString: string;
          FExampleInteger: LongInt;
        procedure SetExampleInteger(const Value: LongInt);
        procedure SetExampleString(const Value: string);
      public
        procedure SaveToStream(const ATarget: TStream);
        procedure LoadFromStream(const ASource: TStream);
        property ExampleString: string read FExampleString write SetExampleString;
        property ExampleInteger: LongInt read FExampleInteger write SetExampleInteger;
      end;
    var
      FInterestingString: string;
      FExampleObject: TExample;
    procedure SetInterestingString(const Value: string);
  public
    constructor Create;
    destructor Destroy; override;
    procedure SaveToStream(const ATarget: TStream);
    procedure LoadFromStream(const ASource: TStream);
    procedure SaveToFile(const AFilename: String);
    procedure LoadFromFile(const AFilename: String);
    property InterestingString: string read FInterestingString write SetInterestingString;
    property ExampleObject: TExample read FExampleObject;
  end;

implementation

{ TMyGameObject.TExample }

procedure TMyGameObject.TExample.LoadFromStream(const ASource: TStream);
begin
  FExampleString := ASource.ReadString;
  ASource.ReadBuffer(FExampleInteger, SizeOf(FExampleInteger));
end;

procedure TMyGameObject.TExample.SaveToStream(const ATarget: TStream);
begin
  ATarget.WriteString(FExampleString);
  ATarget.WriteBuffer(FExampleInteger, SizeOf(FExampleInteger));
end;

procedure TMyGameObject.TExample.SetExampleInteger(const Value: LongInt);
begin
  FExampleInteger := Value;
end;

procedure TMyGameObject.TExample.SetExampleString(const Value: string);
begin
  FExampleString := Value;
end;

{ TStringReaderWriter }

function TStringReaderWriter.ReadString: string;
var
  ResultString: AnsiString;
  StringSize: Integer;
begin
  Result := '';
  ReadBuffer(StringSize, SizeOf(StringSize));
  SetLength(ResultString, StringSize);
  ReadBuffer(Pointer(ResultString)^, StringSize);
  {$ifdef UNICODE}
  Result := Utf8ToString(ResultString);
  {$else}
  Result := Utf8Decode(ResultString);
  {$endif}
end;

procedure TStringReaderWriter.WriteString(const AValue: string);
var
  StringSize: Integer;
  StringToSave: AnsiString;
begin
  StringToSave := Utf8Encode(AValue);
  StringSize := Length(StringToSave);
  WriteBuffer(StringSize, SizeOf(StringSize));
  WriteBuffer(Pointer(StringToSave)^, StringSize);
end;

{ TMyGameObject }

constructor TMyGameObject.Create;
begin
  FExampleObject := TExample.Create;
end;

destructor TMyGameObject.Destroy;
begin
  FExampleObject.Free;
  inherited;
end;

procedure TMyGameObject.LoadFromFile(const AFilename: String);
var
  FileContents: TFileStream;
begin
  FileContents := TFileStream.Create(AFilename, fmOpenRead);
  try
    LoadFromStream(FileContents);
  finally
    FileContents.Free;
  end;
end;

procedure TMyGameObject.LoadFromStream(const ASource: TStream);
begin
  FInterestingString := ASource.ReadString;
  FExampleObject.LoadFromStream(ASource);
end;

procedure TMyGameObject.SaveToFile(const AFilename: String);
var
  FileContents: TFileStream;
begin
  FileContents := TFileStream.Create(AFilename, fmCreate);
  try
    SaveToStream(FileContents);
  finally
    FileContents.Free;
  end;
end;

procedure TMyGameObject.SaveToStream(const ATarget: TStream);
begin
  ATarget.WriteString(FInterestingString);
  FExampleObject.SaveToStream(ATarget);
end;

procedure TMyGameObject.SetInterestingString(const Value: string);
begin
  FInterestingString := Value;
end;

end.

Und benutzen kannst du das dann so:

Delphi-Quellcode:

var
  MyGameData: TMyGameObject;
begin
  if dlgOpen.Execute then
  begin
    MyGameData := TMyGameObject.Create;
    try
      MyGameData.LoadFromFile(dlgOpen.Filename);
      ShowMessage(MyGameData.InterestingString);
    finally
      MyGameData.Free;
    end;
  end;

Auf diese Weise ist nach außen immer alles gekapselt und du kannst die Objekte nach außen immer einfach benutzen ohne dich um die Interna zu kümmern.

[Acuaplano]

Okay, danke für die ausführliche Antwort!
Wir werden es dann mal so versuchen, aber das Hauptproblem ist ja immer noch vorhanden:

Ich versuch's mal anhand des aktuellen Codes zu erklären:

Delphi-Quellcode:

//Map bauen
    for i := 1 to reader.GetRasterX do   // 1 bis 32 (Breite des Rasters)
    begin
      for j := 1 to reader.GetRasterY do
      begin
        with TMapUB.Create(AdSpriteEngine) do
        begin
          //Map an Hand der Textdatei bauen
          Image := AdImageList1.Find(raster[j - 1, i - 1]); // *
          //Immer in 96 Abständen laden
          x := i * 96;
          y := j * 96;
        end;
      end;
    end;

Raster ist hierbei sozusagen die verarbeitete Textdatei als einfaches Array, wobei es dann als Beispiel '3' ausgeben würde und dann das entsprechende Bild ausgewählt werden würde.
Wir wollen ja aber nun, dass genau an dieser Stelle zwischen einzelnen Klassen statt einzelnen Bildern unterschieden wird.

[Acuaplano]

Ich würde es mir dann in etwa so etwa in der Art vorstellen:
raster[j - 1, i - 1].Create
Sodass das Programm eben das hier ausführen würde:
TBaum1.Create