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;                    

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:

Program Gol;
// Game of life als gol.dpr speichern
{$IFDEF FPC}
  {$Mode delphi}
{$ELSE}
  {$Apptype Console}
{$ENDIF}
uses
  sysutils,crt;

const
  colMax = 79;
  rowMax = 23;
//Feld um eine Zeile,Spalte  davor und dahinter erweitern,
//das laesst sich einfeacher bearbeiten, ohne Sonderregeln für den Rand
type
  tFeld = byte;
  tRow = array[0..colMax+1] of tFeld;//0..1 oder 0..3 /sum
  tprow = ^tRow;
  tBoard = array[0..rowMax+1] of tRow;
  tpBoard = ^tBoard;
  tpBoards = array[0..1] of tpBoard;
const
  dr = sizeOf(trow);
type
  tIntArr = array[0..2*dr+2] of tFeld;
  tpIntArr = ^tIntArr;

var
  aBoard,bBoard : tBoard;
  pBoards :tpBoards;
  gblAktBoard : integer;

  gblGenCount : integer;

function Survive(p: tpIntArr):byte;
//p zeigt auf aktuelles Board adresse [row-1,col-1]
const
  cSurvives : array[boolean,0..8] of integer=
              //0,1,2,3,4,5,6,7,8     Nachbarn
              ((0,0,0,1,0,0,0,0,0),   {alive =false}
               (0,0,1,1,0,0,0,0,0));  {alive =true}
var
  sum : integer;
begin
  // Zeile darueber
  // sum := byte(aBoard[row-1,col-1])+byte(aBoard[row-1,col])+byte(aBoard[row-1,col+1]);
  sum :=      integer(p[     0])+integer(p[    1]) +integer(p[     2]);
  sum := sum+ integer(p[  dr+0])                   +integer(p[  dr+2]);
  sum := sum +integer(p[2*dr+0])+integer(p[2*dr+1])+integer(p[2*dr+2]);

  survive := cSurvives[p[dr+1]<>0,sum];
end;

procedure Raender;
var
  p0 : tpIntArr;
  row: integer;
begin
  //Spalten ergaenzen
  p0 := @pBoards[gblAktBoard]^[1,0];
  For row := 1 to rowMax do
    begin
    p0^[0] := p0^[colMax];
    p0^[colmax+1] := p0^[1];
    p0 := Pointer(PtrUint(p0)+SizeOf(tRow));
    end;
  //oberste Zeile 1 nach unten rowMax+1 kopieren
  move(pBoards[gblAktBoard]^[1,0],pBoards[gblAktBoard]^[rowMax+1,0],sizeof(trow));
  //unterste Zeile rowMax nach oben 0 kopieren
  move(pBoards[gblAktBoard]^[rowMax,0],pBoards[gblAktBoard]^[0,0],sizeof(trow));
end;

procedure NextGen;
var
  p0,p1 : tpIntArr;
  col,row: integer;
begin
  Raender;
  For row := 1 to rowMax do
  begin
    p0 := @pBoards[gblAktBoard]^[row-1,0];
    p1 := @pBoards[1-gblAktBoard]^[row,0];
    For col := 1 to colMax do
      p1[col] := Survive(@p0[col-1]);
  end;
  //aBoard := bBoard;
  gblAktBoard :=1-gblAktBoard;
  inc(gblGenCount);
end;

procedure PrintGen;
const
  cChar: array[0..1] of char = (' ','#');
var
  p0 : tpIntArr;
  col,row: integer;
  s : string;
begin
  setlength(s,colmax);
  gotoxy(1,1);
  writeln(gblGenCount:10);
  For row := 1 to rowMax do
  begin
    p0 := @pBoards[gblAktBoard]^[row,0];;
    For col := 1 to colMax do
      s[col] := cChar[p0[col]];
    writeln(s);
  end;
end;

procedure Init;
var
  col,row : integer;
begin
  randseed := 1;
  clrscr;
  fillchar(aBoard,SizeOf(aBoard),#0);
  pBoards[0] := @aBoard;
  pBoards[1] := @bBoard;
  For row := 1 to rowMax do
    For col := 1 to colMax do
      aBoard[row,col]:= Byte(random>0.9);
  gblAktBoard := 0;
end;

var
  cnt : integer;
  T1,T0 :TDateTime;
begin
  Init;
  cnt := 100000;
  T0 := Time;
  repeat
    PrintGen;
    NextGen;
    dec(cnt);
  until (cnt <= 0) OR keypressed;
  // (Leerschleife also nur dec(cnt) etwa 24 ms ~ 840 CPU-Takte
  T1 := Time;
  Writeln((T1-t0)*86400*1000:0:3,' ms');
end.