1:
2:
3:
4:

for x := 0 to ...
  for y := 0 to ...
  begin
    if aBoard[x, y] = ...					

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

const
//Hat2Oder3Nachbarn arbeitet immer mit aBoard entweder 0 oder 1

for x := 0 to ...
  for y := 0 to ...
    bBoard[x, y] = Hat2oder3Nachbarn(x, y); 
//Kopieren
  aBoard := bBoard;					

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

const
  xMax = 10;
  yMax = 10
//Feld um eine Zeile,Spalte  dovor und dahinter erweitern, das lässt sich einfeacher bearbeiten, 
//ohne Sonderregeln für den Rand
type
  tboard = array[0..yMax+1,0..xMax+1] of boolean;//0..1;

var
  aBoard,bBoard : tboard;

...					

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:

Program Gol;
// Game of life als "Gol.dpr" speichern
{$Apptype Console}
uses
  crt;

const
  colMax = 62;
  rowMax = 14;
//Feld um eine Zeile,Spalte  davor und dahinter erweitern,
//das laesst sich einfacher bearbeiten, ohne Sonderregeln für den Rand
type
  tboard = array[0..rowMax+1,0..colMax+1] of byte;//0..1;
  tTripel = array[0..2] of Byte;
  tpTripel = ^tTripel;
var
  aBoard,bBoard : tboard;
  gblGenCount : integer;

function Survive(col,row:integer):byte;
var
  sum: integer;
  pTrip:tpTripel;
  alive :boolean;
begin
  dec(col);// Eine Spalte zurueck -1,0,1 -> 0,1,2
  // Nachbarn zaehlen
  // Zeile darueber
//  sum := aBoard[row-1,col-1]+aBoard[row-1,col]+aBoard[row-1,col+1];
  pTrip := @aBoard[row-1,col];
  sum :=     pTrip^[0]+pTrip^[1]+pTrip^[2];
  // Zeile
  pTrip := @aBoard[row,col];
  alive := pTrip^[1]<>0;
  sum := sum+pTrip^[0]+         +pTrip^[2];
  // Zeile darunter
  pTrip := @aBoard[row+1,col];
  sum := sum+pTrip^[0]+pTrip^[1]+pTrip^[2];
   
  IF sum = 3 then
    survive := 1
  else
  Begin
    IF alive AND (sum = 2)  then
      survive := 1
    else
     survive := 0;
  end;
end;

procedure NextGen;
var
  col,row: integer;
begin
  For row := 1 to rowMax do
    For col := 1 to colMax do
      bBoard[row,col] := Survive(col,row);
  aBoard := bBoard;
  inc(gblGenCount);
end;

procedure PrintGen;
const
  cChar: array[0..1] of char = (' ','#');
var
  col,row: integer;
begin
  gotoxy(1,1);
  writeln(gblGenCount:10);
  For row := 1 to rowMax do
  begin
    For col := 1 to colMax do
      write(cChar[aBoard[row,col]]);
    writeln;
  end;
end;

var
  col,row : integer;
begin
  randomize;
  clrscr;
  fillchar(aBoard,SizeOf(aBoard),#0);

  For row := 1 to rowMax do
    For col := 1 to colMax do
      aBoard[row,col]:= Byte(random>0.5);
  repeat
    PrintGen;
    NextGen; 
    delay(100);
  until keypressed;
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:

//atmpBoard ist das Änderungsarray, aBoard das Lesearray
for x := ...
  for y := ...
   atmpBoard[x, y].Cell := aBoard[x, y].Cell;

//Nun die Schleife:
procedure TForm1.Timer1Timer(Sender: TObject);
var
  x, y: Integer;
begin
  for x := ...
    for y := ...
    begin
      if (atmpBoard[x, y].clCell = clDeathCell) then {mach was den Regeln entspr.};
      if (atmpBoard[x, y].clCell = clLivingCell) then {mach was den Regeln entspr.};
    end;

  //Nun das Änderungsfeld ins "richtige" zurückschreiben
  for x := ...
    for y := ...
     aBoard[x, y].Cell := atmpBoard[x, y].Cell;

  //Und nun noch zeichnen
  DrawBoard;
end;