[DELPHI] TList hoe vul ik m nu netjes??

[douweh]

Hoi, ik ben dus bezig met een spel, en daar bij gebruik ik een dynamisch aantal objecten van het type TBouwWerk, dat zijn namelijk gebouwen, een soort simcity...

een zo'n bouwerk creeer ik dan op deze manier...
(met a als TBouwWerk)

code:

a:=TCelBlokGroot.Create(DXSpriteEngine1.Engine);
aImage := DXImageList1.Items.Find('ditplaatje'); 
a.Width := a.Image.Width;
a.Height := a.Image.Height;
a.X :=50
a.Y :=50;
a.Z:=3;

Dit werkt dus prima!
maar nu de vraag hoe creer ik een dynamisch aantal van die dingen? met behulp van een TList..

Als ik iets wil adden in een list moet ik namelijk een pointer adden, naar dat object, maar hoe pak ik dat precies aan..

[whoami]

Huh serieus? Verwacht hij een pointer? heb hier geen delphi staan, maar ik dacht toch dat het met een gewone

list.items.add() ofzo gaat hoor.

[JapJap]

code:

  a: TCelBlokGroot;
  b: TList;
  ...

  b := TList.Create;
  b.Add(a);
  ...

  a := TCelBlokGroot(b[0]);

[Fiets]

Je zou een dynamische array van die dingen kunnen maken en dan hoeven ze niet eens in een TList. hmmm

setlength(array,length(array)+1)
array[array.length] := TBouwwerk (die je daarvoor gemaakt hebt);

elke keer nadat je een object maakt hiervan kun je gewoon de pointer eraan toevoegen.

Tlist.add(TBouwwerk);

elke keer een Tbouwwerk aanmaken met:

Naam := tbouwwerk.create;

[paar veranderingetjes]

[JapJap]

Fiets:
Je zou een dynamische array van die dingen kunnen maken en dan hoeven ze niet eens in een TList. hmmm

Hmmm... zou toch gewoon voor de TList gaan. 't Is bijna zelf een dynamische array (kijk naar TList.Capacity) en al die methods zijn best handig

array[array.length] := TBouwwerk (die je daarvoor gemaakt hebt);

Hmmm... zou ik niet doen. Laatste element in array is nl. array.length - 1

edit:

Ff wat aardiger zijn

[douweh]

Op woensdag 17 oktober 2001 18:43 schreef JapJap het volgende:

code:

  a: TCelBlokGroot;
  b: TList;
  ...

  b := TList.Create;
  b.Add(a);
  ...

  a := TCelBlokGroot(b[0]);

Zou je dit misschien kunnen toelichten??
het is dus de bedoeling dat er meerdere van die TCelBlokGroot gemaakt worden..
in een array zou ik t dus zo doen:

code:

SetLength(numcbgroot, Length(numcbgroot) + 1);
Index:=Length(numcbgroot)-1;
numcbgroot[Index]:=TCelBlokGroot.Create(DXSpriteEngine1.Engine);
numcbgroot[Index].Image := DXImageList1.Items.Find('cbgroot'); 
numcbgroot[Index].Width := numcbgroot[Index].Image.Width;
numcbgroot[Index].Height := numcbgroot[Index].Image.Height; numcbgroot[Index].X :=50+(16*blok1x); 
numcbgroot[Index].Y :=50+(16*blok1y);
numcbgroot[Index].startblokx:=blok1x;
numcbgroot[Index].startbloky:=blok1y;
numcbgroot[Index].Z:=3;

//waarin numcbgroot dus een array van TCelblokGroot is

maar wil dus geen array gebruiken, maar een list

[edit: ff wat duidelijker]

[Verwijderd]

Even voor de duidelijkheid: een object is in Delphi eigenlijk een pointer.
Dus als je een

code:

var a:TCelblokgroot;

hebt, dan is die a een pointer naar een stukje geheugen waar je object is opgeslagen.
De constructor TCelblokgroot.Create(...) is een speciale functie die wat geheugen reserveert, daar wat mee doet (door jou gedefinieerd) en een pointer naar dat stukje geheugen oplevert. Dus a:=TCelblokgroot.Create(...) maakt een object aan en laat a daar naar wijzen.

a.Width en dergelijke kun je nu een waarde geven. Om hem toe te voegen aan de lijst, kun je gewoon

code:

var b:TList;
(...)
b.Add(a);

doen, want a is een pointer. Als je nu nog een keer

code:

a:=TCelblokgroot.Create(...);
a.Width:=...
(...)
b.Add(a);

doet, maak je een nieuw object aan, past daar wat properties van aan, en zet de pointer naar dat nieuwe object in de lijst. Even later kun je

code:

a:=TCelblokgroot(b[10]);

doen, waarmee je de pointer naar het 10e object van de lijst toekent aan a. Omdat Delphi niet kan garanderen dat de pointer die uit de lijst komt echt een TCelblokgroot is, moet je hem nog met TCelblokgroot(...) casten om Delphi ervan te overtuigen dat het OK is. Anders geeft hij een warning ofzo.

[Verwijderd]

Op woensdag 17 oktober 2001 18:34 schreef douweh het volgende:
maar nu de vraag hoe creer ik een dynamisch aantal van die dingen? met behulp van een TList..

Als ik iets wil adden in een list moet ik namelijk een pointer adden, naar dat object, maar hoe pak ik dat precies aan..

Object referenties zijn in Delphi gewoon pointers die verwijzen naar het object, dus da's geen probleem.
Om 't jezelf gemakkelijk te maken, kun je 't beste een TList afgeleide maken die weet dat 'ie een TCelBlokGroot moet teruggeven wanneer je een Item opvraagt (scheelt weer in het typecasten) en die die objects opruimt wanneer 'ie zelf wordt opgeruimd...

Iets als...

code:

interface

type
  TCelBlokList = class(TList)
  private
    function GetItem(Index: integer): TCelBlokGroot;
  public
    property Items[Index: integer]: TCelBlokGroot read GetItem; default;
    procedure Clear; override;
  end;

implementation

function TCelBlokList.GetItem(Index: integer): TCelBlokGroot;
begin
  Result := nil;
  if (Index >= 0) and (Index < Count) then
    Result := TCelBlokGroot(inherited Items[Index]);
end;

// will also be called when the list is freed
procedure TCelBlokList.Clear; 
var
  i: integer;
begin
  for i := Count-1 downto 0 do
    Items[i].Free;
  inherited;
end;

Da's natuurlijk een kale basis, maar kun je naar eigen inzicht uitbreiden.