Game of Life (Gol)

[Online-Skater]

Hi leutz

Das Spiel habe ich fertig aufgrund einer Schulaufgabe.
hier der link Gol

wenn ihr es runtergeladen habt seht eure CPU-Auslastung an

Das Problem ist die Abfrage der Nachbarn da alles z.B. 100 ms 4 Schleifen durchlaufen werden.
Ich bin noch anfänger und habe von einer zelle alle 8 Zellen nach leben abgefragt und dies ist Zeitaufwändig vorallem vershclingt es Rechenleistung...

Hat einer einen Vorschlag die Nachbarn günstiger zu zählen ?
Ich hab gelesen das man nur die drei rechten nachbarn zählen muss da der rest bekannt sei usw. aber da sehe ich nicht durch.

Vielleicht weis ja einer von euch wie man dies beheben könnte.

procedure Nachbarn(x,y:integer);
begin
  // oben links
  if (x-1 >= 0) and (y-1 > 0) then
    if life[x-1,y-1] = true then nachb := nachb + 1;
  // oben
  if (y-1 >= 0) then
    if life[x,y-1] = true then nachb := nachb + 1;
  // oben rechts
  if (x+1 < 74) and (y-1 >= 0) then
    if life[x+1,y-1] = true then nachb := nachb + 1;
  // rechts
  if (x+1 < 74) then
    if life[x+1,y] = true then nachb := nachb + 1;
  // rechts unten
  if (x+1 < 74) and (y+1 < 74) then
    if life[x+1,y+1] = true then nachb := nachb + 1;
  // unten
  if (y+1 < 74) then
    if life[x,y+1] = true then nachb := nachb + 1;
  // unten links
  if (x-1 >= 0) and (y+1 < 74) then
    if life[x-1,y+1] = true then nachb := nachb + 1;
  // links
  if (x-1 >= 0) then
    if life[x-1,y] = true then nachb := nachb + 1;

  anzahl[x,y] := nachb;

// Nachbarzählung
for i:= 0 to 74 do
 for j:= 0 to 74 do
  begin
    Nachbarn(i,j);
    nachb := 0;
  end;

 

[Gawayn]

Nachdem ich mir deinen Code angesehen habe, würde ich folgendes sagen:

Du scheinst ja ein Array so auswerten zu wollen, dass eine Zelle dieses Arrays die acht umgebenden Zellen eines zweiten, gleichgroßen Arrays an der gleichen Stelle beeinflusst, indem es sie um den Wert 1 erhöht. Dein Array ist 75x75 Zellen groß; für jeden Schleifendurchlauf werden 8 Vergleiche und maximal 8 Inkrementierungen angestellt, das sind insgesamt 45.000 Vergleiche plus maximal 45.000 Inkrementierungen.

Spontan wäre meine naheliegendste Idee, die ganze Mehrarbeit zu lassen, indem du nur 75x75 Vergleiche (=5625) anstellst, also für jeden Schleifendurchlauf nur einen. Du läufst also in einer Schleife durch das life-Array und bei jedem True-Ergebnis erhöhst du die acht korrespondierenden Zellen des anzahl-Arrays. Somit hast du nur 75x75 Vergleiche plus maximal 45.000 Inkrementierungen. Zur Verdeutlichung habe ich diese Idee kurz in ein kleines Progrämmchen gepackt:

program Beispiel ;

const
  _X = 75 ;
  _Y = 75 ;

var
  life: array[0.._X-1,0.._Y-1] of Boolean ;
  anzahl: array[-1.._X,-1.._Y] of Byte ;
  x,y: Byte ;

begin
  FillChar( life, SizeOf( life ), 0 ) ;
  .
  .
  .
    FillChar( anzahl, SizeOf( anzahl ), 0 ) ;

    for y:=0 to _Y-1 do
    begin
      for x:=0 to _X-1 do
      begin
        if( life[x,y] ) then
        begin
          Inc( anzahl[x-1,y-1] ) ;
          Inc( anzahl[x  ,y-1] ) ;
          Inc( anzahl[x+1,y-1] ) ;

          Inc( anzahl[x-1,y  ] ) ;
          Inc( anzahl[x+1,y  ] ) ;

          Inc( anzahl[x-1,y+1] ) ;
          Inc( anzahl[x  ,y+1] ) ;
          Inc( anzahl[x+1,y+1] ) ;
        end ;
      end ;
    end ;
  .
  .
  .
end.

Allerdings frage ich mich, ob das tatsächlich so viel ausmacht?

-Gawayn

 

[Online-Skater]

Also ich habs hinbekommen die CPU - Auslastung beträgt nun ziwschen 0-10% je nach Größe
und es lag nicht an der Nachbarzählung trotzdem danke für deine Mitarbeit

for i:= 0 to 74 do
 for j:= 0 to 74 do
 begin
   if (not life[i,j]) and (anzahl[i,j] = 3) then
   begin
      Feld.Cells[i,j] := '.';
      life[i,j] := true;
      AnzNeu := AnzNeu + 1;
   end;
   if (life[i,j]) and ((anzahl[i,j] < 2) or (anzahl[i,j] > 3)) then
   begin
      Feld.Cells[i,j] := '';
      life[i,j] := false;
   end;
 end;

Problem war bei den GOL-Regeln ich habe jeweils abgefragt ob sie leben bei der einen und ob sie tot sind bei der anderen das brachte den Performancegewinn, keine Ahnung warum bin zufällig drangestoßen, naja jetzt is wundabaaaaa ;-]