DGL • Thema anzeigen - Datenverwaltung In Einer Spieleengine

Datenverwaltung In Einer Spieleengine

Moderator: DGL-Team

Seite 1 von 1

[ 9 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Wolfsrudel

Betreff des Beitrags:

Verfasst: Di Mär 18, 2003 11:46

DGL Member

Registriert: Sa Mär 15, 2003 14:07
Beiträge: 7

Bei einem Echtzeitspiel muss man dynamisch Objekte eines vorher definierten Typs erstellen und wieder löschen, wenn ihre Zeit abgelaufen ist.
Meine Frage ist, wie man solche Objekttypen möglichst günstig anlegt, so dass die Engine eine theoretisch unbegrenzte Menge von Objekten verwalten kann. Bisher habe ich es immer mit arrays von records gemacht, aber was ist jetzt, wenn es noch verschiedenartige Objekte geben soll? Soll ich die einheitliche record-Definition einfach erweitern oder gibt es da eine völlig andere Strategie, seine Objekte zu verwalten?

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Di Mär 18, 2003 11:53

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Die einfachste Methode, ein dynamisches Array aus verschiedenen Objekten zu erstellen besteht in der Nutzung von Zeigern, wie an folgendem Beispiel leicht zu sehen :

Code:

 
ObjArray : array of Pointer;
...
procedure TEngine.ManageObject;
var
 i : Integer;
begin
if Length(ObjArray) > 0 then
 for i := Low(ObjArray) to High(ObjArray do
 &nbsp;begin
 &nbsp;if ObjArray[i]^ is TPlayerObject then
 &nbsp; &nbsp;with ObjArray[i]^ as TPlayerObject do
 &nbsp; &nbsp; &nbsp;TPlayerObject(ObjArray[i])^.Update;
 &nbsp;if ObjArray[i]^ is TBuilding then
 &nbsp; &nbsp;with ObjArray[i]^ as TBuilding do
 &nbsp; &nbsp; &nbsp;TBuilding (ObjArray[i])^.Update;
end;
...
 

Der Code ist nicht getestet, kann also sein das du da noch ein paar Kleinigkeiten ändern musst!

Hoffe der Code ist verständlich.Wichtig sinde folgende Operatoren/Funktionen :
Operator IS : Prüft ob eine Objekt (bzw ein Objekt hinter einem Zeiger) von einem bestimmten Typ is
Operator AS : Behandelt ein Objekt (bzw ein Objekt hinter einem Zeiger) als den hinter AS angegebene Objekttyp
Typecast : Wandelt einen Pointer (bzw ne andere Variable in den angegebenen Typ um (z.B. Zeile TBuilding (ObjArray[i])^.Update)

Mit dieser Methode lässt sich recht leicht ein Array mit verschiedenen Objekten verwalte.Alternativ kannste natürlich auch statt des dynamischen Arrays ein Objekt des Typs TList nutzen, welches eigentlich nichts weiter als eine leicht verwaltbare (z.B. via Add, Delete, Insert) Liste von Pointern ist.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Nach oben

Wolfsrudel

Betreff des Beitrags:

Verfasst: Di Mär 18, 2003 16:23

DGL Member

Registriert: Sa Mär 15, 2003 14:07
Beiträge: 7

Hey, das klingt gut! Werd mich gleich daran versuchen.

Nach oben

Lossy eX

Betreff des Beitrags:

Verfasst: Di Mär 18, 2003 16:40

DGL Member

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund

Son of Satan hat geschrieben:

Code:

 
ObjArray : array of TBasisklasse; // der name sollte anders sein
...
procedure TEngine.ManageObject;
var
 i : Integer;
begin
if Length(ObjArray) > 0 then
 for i := Low(ObjArray) to High(ObjArray do
  begin
  if ObjArray[i]^ is TPlayerObject then
    with ObjArray[i]^ as TPlayerObject do
      TPlayerObject(ObjArray[i])^.Update;
  if ObjArray[i]^ is TBuilding then
    with ObjArray[i]^ as TBuilding do
      TBuilding (ObjArray[i])^.Update;
end;
...
 

Was mir gerade aufgefallen ist.
Man könnte das noch wesentlich vereinfachen. So wie SOS es vorgeschlagen hat geht es ohne Zweifel aber ich bin nun mal faul.

Wenn du dann eine Basisklasse erstellst und TPlayerObject und TBuilding davon ableitest, dann wäre es viel einfacher.
Du müsstest alles was beide (TPlayerObject und TBuilding) Klassen besitzen in die Basisklasse übernehmen. Ich dachte danbei an die methode Update.
Und dann bräuchtest du nur noch nach der Basisklasse casten und dir wäre es sozusagen egal ob es sich um ein gebäude oder einen Spieler handelt.

Also so wie ich mir das vorstellen würde.

Code:

 
ObjArray : array of Pointer;
...
procedure TEngine.ManageObject;
var
 &nbsp;i : Integer;
begin
 &nbsp;if Length(ObjArray) > 0 then begin
 &nbsp; &nbsp;for i := Low(ObjArray) to High(ObjArray)
 &nbsp; &nbsp; &nbsp;do ObjArray[i].Update;
 &nbsp;end;
end;
...
 

Da es sich hier um Klassen handelt werden so oder so bloß deren pointer gespeichert also könnte man auch gleich die Klassen ablegen. Und dir wäre es an dieser Stelle egal um was es sich handelt du willst ja nur das Update aufrufen. Im spezialfall könntest du immer noch schauen um was es sich handelt und dieses dann expliziet casten und dinge tun.

Nach oben

lithander

Betreff des Beitrags:

Verfasst: Di Mär 18, 2003 20:03

DGL Member

Registriert: Mo Mai 06, 2002 20:27
Beiträge: 479
Wohnort: Bremen

Ich würde anstatt eines einfachen Arrays die Klasse TList verwenden. Die kann im Prinzip das gleiche wie ein dynamisches Array of Pointer aber gibt dir ein Paar ganz nützliche Funktionen an die Hand. Z.B. kannst du bei TList ganz einfach Objekte hinzufügen, löschen und was du sonst noch zur verwaltung brauchst.
Außerdem ist eine TList ziemlich schnell - besser bekommst du's auch nicht hin.

Dann würde ich einen ObjektManager bauen, der von TList erbt oder TList verwendet und alle Objekte Im Spiel managed. Natürlich kannst du diese Funktionen auch direkt in die Engine einbauen, aber eine zusätzliche Abstraktion wäre vielleicht ganz ratsam.

_________________
Selber Denken macht klug!

Nach oben

KidPaddle

Betreff des Beitrags:

Verfasst: Di Mär 18, 2003 20:37

DGL Member

Registriert: Mo Jan 20, 2003 20:10
Beiträge: 424
Wohnort: nähe Starnberg

Ab Delphi 5 steht TObjectList zu Verfügung, welches die reservierten Objekte automatisch freigeben kann.

Code:

 
TBaseObject = class(TObject)
....
 &nbsp;Methoden/Properties die überall gleich sind, z. B.:
 &nbsp;procedure Render; virtual; abstract;
....
end;
 
TBaseObjectList = class(TObjectList)
protected
 &nbsp;function GetItem(Index : Integer) : TBaseObject;
public
 &nbsp;property Items[Index : Integer] : TBaseObject read GetItem; default;
end;
 
function TBaseObject.GetItem(Index : Integer) : TBaseObject;
begin
 &nbsp;Result := (inherited Items[Index] as TBaseObject);
end;
 

So könnte eine Liste mit Objekten angesprochen werden:

Code:

 
...
begin
 &nbsp;for Loop := 0 to (BaseList.Count - 1) do begin
 &nbsp; &nbsp;BaseList[Loop].Render; 
 &nbsp;end;
end;
...
 

Damit hast Du schon eine einfache Objektverwaltung.

KidPaddle

_________________
http://www.seban.de

Nach oben

Wolfsrudel

Betreff des Beitrags:

Verfasst: Mi Mär 19, 2003 12:38

DGL Member

Registriert: Sa Mär 15, 2003 14:07
Beiträge: 7

Wow, das sind ganz schön viele Ideen für meinen kleinen Kopf!

Ich fasse zusammen (korrigiert mich, wenn ich mich irre):

- Sobald ich den Operator IS benutze, muss das anliegende Element des Pointer-Arrays eine Instanz (nennt man das so?) einer Klasse sein.

- .Update lässt mich auf die einzelnen Elemente der Instanz zugreifen.

- Lossy eX meint, dass ich alle meine verschiedenen Objektdefinitionen in eine Basisklasse aufnehmen kann, um die Objekte nicht generell voneinander unterscheiden zu müssen. Das käme dann wieder einem array of record recht nahe, es sei denn, man kann die Objekte doch irgendwie unterscheiden. Kann man das?
Das Andere ist wiederum, dass die Größe, die meine Objekte im Speicher belegen werden, je nach Objekttyp recht unterschiedlich sein können. Ich rechne damit, dass ein 'großes' Objekt etwa 5-10x so viel Speicher einnimmt wie ein 'kleines' und sehr viel komplexere Physik (ebenso KI) benötigt.

Frage: Was macht .Update alles? Muss ich .Update als Methode erst noch definieren?

- TList in der unit Classes ist eine leichter zu verwaltende Form des array of Pointer. Lithander schlägt vor, dass die Unterscheidungsroutinen für die in der TList gespeicherten Instanzen von Objektklassen sich zentral in einem Objektmanager befinden. So könnte die Engine also alle Objekte gleich behandeln, der Objektmanager setzt die einheitlichen Befehle wie 'Objekt_zeichnen' um in die für den jeweiligen Objekttyp spezifische Form. So ein Objektmanager könnte sehr nützlich sein, um die Übersichtlichkeit und somit Ausbaufähigkeit der Engine zu wahren.

- TObjectList bietet mir die Möglichkeit, einzelne Objekte aus der Objektliste zu isolieren und separat zu behandeln.

- Die Verwendung von TComponent anstatt TObjectList wäre auch zu überlegen.

Momentan tendiere ich dazu, jeden Objekttyp in eine eigene Klasse zu packen und die Basisroutinen wie 'rendern' gleích mit einzubauen.
Eine Frage noch: Wenn ich jetzt den Pointer-array benutze und recht verschiedenartig große Objekte darin ständig binde und wieder freigebe, wird das nicht auf die Dauer den heap recht zerstückeln? Ist das bei der TList besser gelöst und wie?

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Mi Mär 19, 2003 16:29

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Hi,

also ich hab bis jetzt alles egal ob Prog oder Spiel auf Class bzw record basis gemacht und hab mir Hilfsfunktionen geschrieben um einträge aus nem Dynamischen Array zu löschen, verschieben, ändern hinzufügen usw.

Da ich finde das manchmal die Pointer art manchmal etwas ankotzen, grad wenn man mit vererbung arbeitet und Pointer man immer auf speicher achten muss.

z.b. so (Dynamisches Shortcut system für Xenorate):

Code:

 
 
type
  TXHotKeyProgram = (
    xhpNone,
    xhpNext,
    xhpPrev,
    xhpStop,
    xhpPause,
    xhpPlay
  );
 
  TXHotKeyDownKey = (
    xdkNone,
    xdkAlt,
    xdkShift,
    xdkCtrl
  );
 
  TXHotKey = record
    KeyCode : Word;
    DownKey : TXHotKeyDownKey;
    Prog    : TXHotKeyProgram;
  end;
 
  TXHotKeys = class(TObject)
  private
    Keys : array of TXHotKey;
    procedure Clear;
    function GetHotKey(Index : Integer) : TXHotKey;
    function GetCount : Integer;
  public
    constructor Create;
    destructor Destroy;
    procedure Add(const _KeyCode : Word; const _DownKey : TXHotKeyDownKey; const _Prog : TXHotKeyProgram);
    procedure Delete(const _Index : Integer);
    procedure Edit(const _Index : Integer; const _KeyCode : Word; const _DownKey : TXHotKeyDownKey; const _Prog : TXHotKeyProgram);
    property HotKey[Index: Integer]: TXHotKey read GetHotKey;
  end;
 
implementation
 
constructor TXHotKeys.Create;
begin
  inherited;
end;
 
destructor TXHotKeys.Destroy;
begin
  inherited;
  Clear;
end;
 
procedure TXHotKeys.Clear;
begin
  SetLength(Keys, 0);
end;
 
function TXHotKeys.GetCount : Integer;
begin
  Result := Length(Keys);
end;
 
function TXHotKeys.GetHotKey(Index : Integer) : TXHotKey;
begin
  // Standard werte
  Result.KeyCode := 0;
  Result.Prog := xhpNone;
  // Prüfen ob der bereich gültig ist
  if (Index < 0) or (Index > High(Keys)) then Exit;
 
  // Bereich gültig, also ausgeben
  Result := Keys[Index];
end;
 
function TXHotKeys.GetCount : Integer;
begin
  Result := Length(Keys);
end;
 
procedure TXHotKeys.Add(const _KeyCode : Word; const _DownKey : TXHotKeyDownKey; const _Prog : TXHotKeyProgram);
var
  Count : Integer;
begin
  Count := Length(Keys)+1;
  SetLength(Keys, Count);
  Keys[Count-1].KeyCode := _KeyCode;
  Keys[Count-1].Prog := _Prog;
  Keys[Count-1].DownKey := _DownKey;
end;
 
procedure TXHotKeys.Delete(const _Index : Integer);
var
  OldEntrys      : array of TREintrag;
  I, Count, L, H, ActIndex : Integer;
begin
  // SwissDelphiCenter Methode
  if _Index > High(Keys) then Exit;
  if _Index < Low(Keys) then Exit;
  if _Index = High(Keys) then
  begin
    SetLength(Keys, Length(Keys) - 1);
    Exit;
  end;
  Finalize(Keys[_Index]);
  System.Move(Keys[_Index +1], Keys[_Index],
  (Length(Keys) - _Index -1) * SizeOf(TXHotKey) + 1);
  SetLength(Keys, Length(Keys) - 1);
 
  // Meine Methode
  // Find ich besser, da oberige Methode nur für Records ohne Vererbung gedacht ist
  // Da könnte man auch genauso gut Pointer verwenden :P
  {
 
  // Prüfen ob der Index im Gültigem Bereich ist
  // Wenn Nicht, dann raus aus der Prozedur
  if (_Index > High(Keys)) or (_Index < Low(Keys)) then Exit;
 
  // Anzahl Einträge, Low und High in Temporäre Variable speichern
  Count := GetCount;
  L := Low(Keys);
  H := High(Keys);
 
  // Alte Einträge vorher in das Temporäre Array speichern
  // Array vorher initialiseren, usw
  SetLength(OldEntrys, Count);
  For I := L to H do
    OldEntrys[I] := Keys[I];
 
  // Neue grösse für Einträge festlegen
  SetLength(Keys, Count-1);
  // Alte Daten, AUSSER den Eintrag den wir auslassen (löschen) möchten ins Array kopieren
  // ActIndex auf 0 setzen, das ist unser Startindex
  ActIndex := 0;
  For I := L to H do
  begin
    // Prüfen ob I der schleife nicht der Index nicht
    if I <> _Index then
    begin
      // Alten Eintrag von I in den neuen Eintrag ActIndex hinzufügen
      Keys[ActIndex] := OldEntrys[I];
      // ActIndex um 1 erhöhen
      Inc(ActIndex);
    end;
  end;
 
  }
end;
 
procedure TXHotKeys.Edit(const _Index : Integer; const _KeyCode : Word; const _DownKey : TXHotKeyDownKey; const _Prog : TXHotKeyProgram);
begin
  Keys[_Index].KeyCode := _KeyCode;
  Keys[_Index].Prog := _Prog;
  Keys[_Index].DownKey := _DownKey;
end;
 
 

bidde schön, hoffe ihr könnt was damit anfangen.

matane,
Finalspace

Nach oben

Seite 1 von 1

[ 9 Beiträge ]

Foren-Übersicht » Programmierung » Allgemein

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.