Array Zeile löschen

[VkPenguin]

Hallo,
mit eurer Hilfe habe ich inzwischen einiges an meinem Projekt geschafft. Ich brauchte mich eine Weile nicht melden,kam ich gut vorwärts . Nun gibt es aber einen Fehler in meinem Programm, der mir schon seit Anfang an zu schaffen macht, den ich aber immer vor mir hergeschoben hab. Folgendes Problem: In meinem Spiel werden die Positionen und Eigenschaften von z.B. Gegnern in Arrays (of Record) gespeichert. Wenn nun einer von ihnen stirbt (Dat[X].Alive=False) soll die Zeile gelöscht werden und alle anderen um Platz zu sparen "eins aufrücken". Grundsätzlich funktioniert das auch, aber wenn mehrere Gegner gleichzeitig ins Jenseits befördert werden entstehen Fehler. Hier meine bisherige Technik:

Delphi-Quellcode:

  X:=0;
  For I:=1 To Gegneranzahl+X DO
  Begin
   if not Gegner[I-X].alive then
   Begin
    if ((I-X)<>Gegneranzahl) THEN
    Begin
     Gegner[I-X].Wert:=Gegner[Gegneranzahl].Wert;
     Gegner[I-X].Funktion:=Gegner[Gegneranzahl].Funktion;
     Gegner[I-X].PosX:=Gegner[Gegneranzahl].PosX;
     Gegner[I-X].PosY:=Gegner[Gegneranzahl].PosY;
     Gegner[I-X].breite:=Gegner[Gegneranzahl].breite;
     Gegner[I-X].hoehe:=Gegner[Gegneranzahl].hoehe;
     Gegner[I-X].Farbe:=Gegner[Gegneranzahl].Farbe;
     Gegner[I-X].Maxzeit:=Gegner[Gegneranzahl].Maxzeit;
     Gegner[I-X].Alter:=Gegner[Gegneranzahl].Alter;
     [...............]
    End;
    X:=X+1;
    Gegneranzahl:=Gegneranzahl-1;
   End;
  End;

In einigen Tutorials hab ich "Swap Values" kennengelernt, damit könnte man das ganze sicher etwas vereinfachen; ich konnte aber nichts dazu finden, was hieran falsch sein könnte. Hat jemand vielleicht eine Idee ?

Alternativ: Könnte ich nicht theoretisch auch einfach den letzten mit demjenigen, der gelöscht werden soll Tauschen (es sei den selbiger ist der letzte) und dann den letzten löschen?

Danke schoneinmal!

[Bjoerk]

Ist das ein statisches array?

[Bummi]

Das und die Sortierung dürfte der Grund sein warum meist Listen bevorzugt werden.
Du könntest mehrfach 1 löschen oder umkopieren in ein initial leeres Array, wenn die Reihenfolge egal ist kannst Du auch wie von Dir bereits vorgeschlagen eine Lückenliste erstellen,auffüllen,löschen

[Popov]

@VkPenguin

Nur mal so, du kannst das auch so in einem Rutsch übergeben:

Delphi-Quellcode:

Gegner[I-X] := Gegner[Gegneranzahl];

Macht alles etwas übersichtlicher.

Und hier: http://www.delphipraxis.net/166529-f...heinander.html

Da ging es um Objekte, aber auch da wird Array von unnötigen Datensätzen befreit.

[VkPenguin]

Hallo, danke für eure Hilfe..

@ Bjoerk: Ja, ist es, bisher zumindest, später werde ich das aus Performancegründen vielleicht ändern.
@ Popov: Ah, das macht das ganze zumindest schon mal einfacher, Dankeschön für den Tipp.
@ Bummi: Da hast du wahrscheinlich recht. Ist es denn schwierig mein Programm auf die Verwendung von Listen umzubauen?

Kennt jemand zufällig ein gutes Tutorial, wie man Listen verwendet? Ansonsten werde ich mich mal umschauen..

[Breager]

Zitat:

Zitat von VkPenguin

Ist es denn schwierig mein Programm auf die Verwendung von Listen umzubauen?

Nein. Listen sind zudem viel schneller und komfortabler als dynamische Arrays. Du musst nur darauf achten, den reservierten Speicher wieder freizugeben, ansonsten entsteht ein Speicherleck.

Hier ein einfaches Beispiel:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  PGegnerRecord = ^TGegnerRecord;
  TGegnerRecord = record
   Name:AnsiString;
   PosX:Integer;
   PosY:Integer;
   {...}
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

  Gegnerliste:TList;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
 Gegnerliste:=TList.Create;
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
Var i:Integer;
Begin
 For i:=Gegnerliste.Count-1 downto 0 do   //Löschen von Einträgen
    Dispose(PGegnerRecord(Gegnerliste.Items[i]));  //Speicher wieder freigeben!

 Gegnerliste.Free;
end;

procedure TForm1.Button1Click(Sender: TObject);
Var GegnerRec:PGegnerRecord;
    index:Integer;
begin
 New(GegnerRec);  //Speicher reservieren
 Gegnerliste.Add(GegnerRec);
 index:=Gegnerliste.Count;
 GegnerRec.Name:='Gegner'+IntToStr(index);
 GegnerRec.PosX:=index;
 GegnerRec.PosY:=30;
end;

procedure TForm1.Button2Click(Sender: TObject);
Var i:Integer;
begin
 For i:=0 to Gegnerliste.Count-1 do
     ShowMessage(TGegnerRecord(Gegnerliste[i]^).Name);
end;

[himitsu]

Zitat:

Zitat von Breager (Beitrag 1154663)

Nein. Listen sind zudem viel schneller und komfortabler als dynamische Arrays. Du musst nur darauf achten, den reservierten Speicher wieder freizugeben, ansonsten entsteht ein Speicherleck.

Schneller nicht. Ordentlioch implementiert ist Beides etwa gleich schnell.

Aber Komfortabler auf jedenfall.

Nja, es wäre ja zu praktisch, wenn die Fragesteller ihre Delphi-Version mal verrraten würden. :wall:
Ab Delphi 2009 könnte man z.B. den Generics und einer generischen TList den Komfort nochmal wesentlich erhöhen.

Und was die Speicherlecks angeht:
Eine TObjectList, bzw. einer generischen TObjektList und mit OwnsObjects=True, würde man nochmal etweas mehr Sicherheit und Kompfort rausholen.

[DeddyH]

Zitat:

Zitat von himitsu (Beitrag 1154671)

Eine TObjectList, bzw. einer generischen TObjektList und mit OwnsObjects=True, würde man nochmal etweas mehr Sicherheit und Kompfort rausholen.

Dazu müsste man aus den Records aber erst Klassen machen ;)

[Blup]

Zum ursprünglichen Problem:

Delphi-Quellcode:

for i := Gegneranzahl downto 1 do
begin
  if not Gegner[i].alive then
  Begin
    if i < Gegneranzahl then
      Gegner[I] := Gegner[Gegneranzahl];
 
    Dec(Gegneranzahl);
  end;
end;

Die Umstellung von Records und Arrays auf Objekte und Objektlisten scheint hier sinnvoll. Der Aufwand dürfte sich in Grenzen halten.
Die Alternative mit TList und Pointern zu arbeiten, erfordert mindestens den selben Aufwand und ist nicht so komfortabel.

[himitsu]

Zitat:

Zitat von DeddyH (Beitrag 1154693)

Dazu müsste man aus den Records aber erst Klassen machen ;)

Jupp.

Die generische TList ist leider nur für die haltung von statischen Records, deren Daten man nicht ändert, bzw. die man nur im ganzen ändert.
Das Ändern einzelner Werte eines Records ist nicht (sehr unpraktsich) änderbar.
Und da sich hier ja bestimmte mindestens Werte wie PosX und PosY ändern werden...

Ich hatte mir damit beholfen, daß ich die TList<> erweiterte und ein Items einführte, welches den Pointer auf den Record und nicht eine Kopie Records zurückliefert.