1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

0 00000 0

0 abcde 0
0 abcde 0
0 abcde 0
0 yxcvz 0

0 00000 0
wird zu
z yxcvz y

e abcde a
e abcde a
e abcde a
z yxcvz y

e abcde a					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

// statt ..
public
  Spielfeld: Array[0..15, 0..15] of Boolean;

// mit Properties ..
private
  function GetSpielfeldAt(x,y: Integer): Boolean;
  procedure SetSpielfeldAt(x,y: Integer; Value: Boolean);
private
  FSpielfeld: Array[0..15, 0..15] of Boolean;
public
  Property Spielfeld[x,y: Integer]: Boolean read GetSpieldeldAt write SetSpielfeldAt;

// und weiter unten ..

function GetSpielfeldAt(x,y: Integer): Boolean;
begin
  x := x mod Length(Spielfeld);
  y := y mod Length(Spielfeld[x]);
  result := FSpielfeld[x,y];
end;

procedure SetSpielfeldAt(x,y: Integer; Value: Boolean);
begin
  x := x mod Length(Spielfeld);
  y := y mod Length(Spielfeld[x]);
  FSpielfeld[x,y] := Value;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

function TSpielfeld.ErmittleNachbarn(x, y: Integer): Byte;
var Anzahl : Byte;
    xa, xe, ya, ye : Integer;
begin
  // Array geht von 1..100, 1..100
  Anzahl:=0;
  xa:=x-1;   // eine Spalte links
  xe:=x+1;   // eine Spalte rechts
  ya:=y-1;   // eine Zeile hoch
  ye:=y+1;   // eine Zeile runter
  if xa=0    // links von 1 geht zum rechten Rand
    then xa:=100
    else if xe>100 // rechts von 100 geht zum linken Rand
      then xe:=1;
  if ya=0
    then ya:=100
    else if ye>100
      then ye:=1;
  Anzahl:=Anzahl+EArray[xa, ya]; // Feld links darüber
  Anzahl:=Anzahl+EArray[x,  ya]; // Feld direkt darüber
  Anzahl:=Anzahl+EArray[xe, ya]; // Feld rechts darüber

  Anzahl:=Anzahl+EArray[xa, y ]; // Feld links daneben
  Anzahl:=Anzahl+EArray[xe, y ]; // Feld rechts daneben

  Anzahl:=Anzahl+EArray[xa, ye]; // Feld links darunter
  Anzahl:=Anzahl+EArray[x,  ye]; // Feld direkt darunter
  Anzahl:=Anzahl+EArray[xe, ye]; // Feld rechts darunter
  result:=Anzahl;
end;					

1:
2:
3:
4:
5:
6:
7:

  for x := -1 to 97 do
    for y := -1 to 97 do
    begin
      if (aBoard[-1, y].clCell = clLivingCell) then
        atmpBoard[96, y].clCell := clLivingCell;
      //...
    end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

for i := 0 to 15 do begin
  for j := 0 to 15 do
    Propagate(i,j);
end;

// ..

procedure Propagate(x,y: Integer);
begin
  // hier Aktion für diese Zelle einfügen,
  // in neues Array kopieren,
  // oder was sonst noch passieren muss.
  // zum Beispiel:
  if Spielfeld[x + 1, y + 1] = foo then
    bar;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

for i := 0 to 15 do begin
  for j := 0 to 15 do
    Propagate(i,j);
end;

// ..

procedure Propagate(x,y: Integer);
begin
  if Spielfeld[  (x + 1) mod 16, (y + 1) mod 16  ] = foo then
    bar;
end;					

1:
2:
3:
4:
5:
6:
7:

 0   mod 16 =  0
11   mod 16 = 11
15   mod 16 = 15
16   mod 16 =  0 (rechts vom rechten Rand ist linker Rand)
(-1) mod 16 = 15 (links vom linken Rand is rechter Rand)          <- Das müsstest du mal testen, ich habe gerade kein Delphi da. Es gibt Programmiersprachen, die hier -1 ausgeben, das ist mathematisch falsch und wäre hier fatal
17   mod 16 =  2
46   mod 16 = 14					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

type
  TMapData = array of array of TMapCellClass;

type
  TMapClass=class(TObject)
  private
    // Anderes Zeug
    FColCount : TIntegerStreamClass;
    FRowCount : TIntegerStreamClass;
    FCells : TMapData;
    function GetCells(X, Y: integer): TMapCellClass;
    procedure SetCells(X, Y: integer; const Value: TMapCellClass);
    // Noch mehr Zeug
  public 
     property Cells[X,Y:integer]:TMapCellClass read GetCells write SetCells;
  end;

function TMapClass.GetCells(X, Y: integer): TMapCellClass;
begin
Result := FCells[X mod FColCount.Data,Y mod FRowCount.Data];
end;

procedure TMapClass.SetCells(X, Y: integer; const Value: TMapCellClass);
begin
FCells[X mod FColCount.Data,Y mod FRowCount.Data] := Value;
end;					

1:
2:

if X < 0 then X := FColcount+X;    // Addieren weil der Wert ja schon negativ ist :)
if Y < 0 then Y := FRowcount+Y;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:

procedure TForm1.Timer1Timer(Sender: TObject);
var
  i, n, x, y: Integer;
  b: Boolean;
  atmpBoard: array [-1..97, -1..97] of record
    X, Y: Integer;
    clCell: TColor;
  end;
begin
  {Automatischer Abbruch, wenn MaxInt erreicht ist}
  if iGeneration = MaxInt then
  begin
    Button4Click(Sender);
    exit;
  end;

  Inc(iGeneration);
  Label1.Caption := IntToStr(iGeneration)+'. Generation';

  {Temporäres Array mit toten Zellen füllen}
  for x := -1 to 97 do
    for y := -1 to 97 do
    begin
      atmpBoard[x, y].clCell := clDeathCell;
    end;

  for x := 0 to 96 do
    for y := 0 to 96 do
    begin
      if (x-1 = -2) or (y-1 = -2) or (x+1 = 97) or (y+1 = 97) then
        atmpBoard[x, y].clCell := clDeathCell
      else
      begin  
        {Eine tote Zelle mit genau drei lebenden Nachbarn
         wird in der Folgegeneration neu geboren.}
        if (aBoard[x, y].clCell = clDeathCell) then
        begin
          i := 0;
          if (aBoard[x-1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y-1].clCell = clLivingCell) then Inc(i);

          if i = 3 then
          begin
            atmpBoard[x, y].clCell := clLivingCell;
          end
          else
          begin
            atmpBoard[x, y].clCell := clDeathCell;
           end;
        end;

        {Lebende Zellen mit weniger als zwei lebenden Nachbarn
         sterben in der Folgegeneration an Einsamkeit.}
        if (aBoard[x, y].clCell = clLivingCell) then
        begin
          i := 8;
          if (aBoard[x-1, y].clCell = clDeathCell) then Dec(i);
          if (aBoard[x+1, y].clCell = clDeathCell) then Dec(i);
          if (aBoard[x, y-1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x, y+1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x-1, y-1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x+1, y+1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x-1, y+1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x+1, y-1].clCell = clDeathCell) then Dec(i);

          if i < 2 then
          begin
            atmpBoard[x, y].clCell := clDeathCell;
          end
          else
          begin
            atmpBoard[x, y].clCell := clLivingCell;
          end;

          {Eine lebende Zelle mit zwei oder drei lebenden
           Nachbarn bleibt in der Folgegeneration am Leben}
          i := 0;
          if (aBoard[x-1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y-1].clCell = clLivingCell) then Inc(i);

          if (i = 2) or (i = 3) then
          begin
            atmpBoard[x, y].clCell := clLivingCell;
          end
          else
          {Lebende Zellen mit mehr als drei lebenden Nachbarn
           sterben in der Folgegeneration an Überbevölkerung.}
          if i > 3 then
          begin
            atmpBoard[x, y].clCell := clDeathCell;
          end;
        end;
      end;  {else}
    end;  {for}


  {Die Ränder (-1 und 97) sind immer tote Zellen}
  for x := -1 to 97 do
    for y := -1 to 97 do
    begin
      if (x = -2) or (y = -2) or (x = 97) or (y = 97) then
        atmpBoard[x, y].clCell := clDeathCell;
    end;

  b := False;


  {Prüfen, ob es noch sich bewegende Zellen gibt oder ob die Welt erstarrt ist}
  i := 0;
  for x := 0 to 96 do
    for y := 0 to 96 do
    begin
      if atmpBoard[x, y].clCell = aBoard[x, y].clCell then
        Inc(i);
    end;

    if i = 9409 then
    begin
      Label1.Caption := 'Nach der '+IntToStr(iGeneration)+'. Generation erstarrt';
      iGeneration := 0;
      Timer1.Enabled := False;
      Button3.Enabled := False;
      Button4.Caption := '&Löschen';
    end;


  {Nach aBoard zurückschreiben, ...}
  n := 0;
  for x := -1 to 97 do
    for y := -1 to 97 do
    begin
      if atmpBoard[x, y].clCell = clDeathCell then
        aBoard[x, y].clCell := clDeathCell
      else
      begin
        aBoard[x, y].clCell := clLivingCell;
        b := True;
        Inc(n);  {... lebende Zellen zählen ...}
      end;
    end;
  Label2.Caption := IntToStr(n)+' lebende Zellen';

  {... und schiesslich zeichnen}
  DrawBoard(False);


  if not b then
  begin
    Label1.Caption := 'Nach der '+IntToStr(iGeneration)+'. Generation ausgestorben';
    iGeneration := 0;
    Timer1.Enabled := False;
    Button3.Enabled := False;
    Button4.Caption := '&Löschen';
  end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:

procedure TForm1.Timer1Timer(Sender: TObject);
var
  i, n, x, y: Integer;
  b: Boolean;
  atmpBoard: array [-1..97, -1..97] of record  // hier: Array verkleinern, Rand wegschmeißen
    X, Y: Integer;
    clCell: TColor;
  end;
begin
  {Automatischer Abbruch, wenn MaxInt erreicht ist}
  if iGeneration = MaxInt then
  begin
    Button4Click(Sender);
    exit;
  end;

  Inc(iGeneration);
  Label1.Caption := IntToStr(iGeneration)+'. Generation';

  {Temporäres Array mit toten Zellen füllen}
  for x := -1 to 97 do    // hier: Array wurde verkleinert, 
    for y := -1 to 97 do  // Schleifen anpassen
    begin
      atmpBoard[x, y].clCell := clDeathCell;
    end;

  for x := 0 to 96 do    // das ist die Schleife,
    for y := 0 to 96 do  // die in meinem letzten Post erwähnt war


    // überall, wo in dieser Schleife auf aBoard[] oder atmpBoard[] zugegriffen wird,
    // sollten die Koordinaten vorher mod 97 gerechnet werden
    // der Kürper dieser Schleife wäre in meinem Beispiel die Prozedur Propegate


    begin
//      if (x-1 = -2) or (y-1 = -2) or (x+1 = 97) or (y+1 = 97) then
//        // das heißt also x=-1 oder y=-1 oder x=96 oder y=96
//        atmpBoard[x, y].clCell := clDeathCell  // die ersten beiden Bedingungen treten nie ein..
//                                               // da x=0..96, -1 wird nie erreicht.
//                                               // Die 97 sollte wohl eine 98 sein?
//                                               // kann jedenfalls komplett raus, da kein Rand mehr vorhanden
//                                               // alle Zellen gehören zum Inneren des Feldes
//      else
//      begin  
        {Eine tote Zelle mit genau drei lebenden Nachbarn
         wird in der Folgegeneration neu geboren.}
        if (aBoard[x, y].clCell = clDeathCell) then
        begin
          i := 0;
          if (aBoard[x-1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y-1].clCell = clLivingCell) then Inc(i);

          if i = 3 then
          begin
            atmpBoard[x, y].clCell := clLivingCell;
          end
          else
          begin
            atmpBoard[x, y].clCell := clDeathCell;
           end;
        end;

        {Lebende Zellen mit weniger als zwei lebenden Nachbarn
         sterben in der Folgegeneration an Einsamkeit.}
        if (aBoard[x, y].clCell = clLivingCell) then
        begin
          i := 8;
          if (aBoard[x-1, y].clCell = clDeathCell) then Dec(i);
          if (aBoard[x+1, y].clCell = clDeathCell) then Dec(i);
          if (aBoard[x, y-1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x, y+1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x-1, y-1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x+1, y+1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x-1, y+1].clCell = clDeathCell) then Dec(i);
          if (aBoard[x+1, y-1].clCell = clDeathCell) then Dec(i);

          if i < 2 then
          begin
            atmpBoard[x, y].clCell := clDeathCell;
          end
          else
          begin
            atmpBoard[x, y].clCell := clLivingCell;
          end;

          {Eine lebende Zelle mit zwei oder drei lebenden
           Nachbarn bleibt in der Folgegeneration am Leben}
          i := 0;
          if (aBoard[x-1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y-1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x-1, y+1].clCell = clLivingCell) then Inc(i);
          if (aBoard[x+1, y-1].clCell = clLivingCell) then Inc(i);

          if (i = 2) or (i = 3) then
          begin
            atmpBoard[x, y].clCell := clLivingCell;
          end
          else
          {Lebende Zellen mit mehr als drei lebenden Nachbarn
           sterben in der Folgegeneration an Überbevölkerung.}
          if i > 3 then
          begin
            atmpBoard[x, y].clCell := clDeathCell;
          end;
        end;
//      end;  {else}
    end;  {for}


  {Die Ränder (-1 und 97) sind immer tote Zellen}
  for x := -1 to 97 do
    for y := -1 to 97 do
    begin
      if (x = -2) or (y = -2) or (x = 97) or (y = 97) then
        atmpBoard[x, y].clCell := clDeathCell;
    end;

  b := False;


  {Prüfen, ob es noch sich bewegende Zellen gibt oder ob die Welt erstarrt ist}
  i := 0;
  for x := 0 to 96 do
    for y := 0 to 96 do
    begin
      if atmpBoard[x, y].clCell = aBoard[x, y].clCell then
        Inc(i);
    end;

    if i = 9409 then
    begin
      Label1.Caption := 'Nach der '+IntToStr(iGeneration)+'. Generation erstarrt';
      iGeneration := 0;
      Timer1.Enabled := False;
      Button3.Enabled := False;
      Button4.Caption := '&Löschen';
    end;


  {Nach aBoard zurückschreiben, ...}
  n := 0;
  for x := -1 to 97 do
    for y := -1 to 97 do
    begin
      if atmpBoard[x, y].clCell = clDeathCell then
        aBoard[x, y].clCell := clDeathCell
      else
      begin
        aBoard[x, y].clCell := clLivingCell;
        b := True;
        Inc(n);  {... lebende Zellen zählen ...}
      end;
    end;
  Label2.Caption := IntToStr(n)+' lebende Zellen';

  {... und schiesslich zeichnen}
  DrawBoard(False);


  if not b then
  begin
    Label1.Caption := 'Nach der '+IntToStr(iGeneration)+'. Generation ausgestorben';
    iGeneration := 0;
    Timer1.Enabled := False;
    Button3.Enabled := False;
    Button4.Caption := '&Löschen';
  end;