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:

unit UObjklSpielQuadrat;

interface
uses extctrls,graphics;
Type TSpielQuadrat = class(TObject)
  private
    besetzt : Boolean;     //Gibt an, ob das SpielQuadrat besetzt ist
    x,y:Integer;           //Linke obere Ecke des Quadrates
    Breite:Integer;        //Länge bzw. Breite des Quadrates
    farbe:LongWord;        //Farbe des Quadrates
  public
    Constructor Erzeugen(px,py,pl:Integer);
        //Erzeugt ein nicht besetztes, graues Quadrat mit dem
        //Eckpunkt (px,py) und der Breite pl.
    Procedure Zeichnen(img:TImage);
        //Zeichnet ein erzeugtes Quadrat im Image img.
    Procedure Belegen;
        //Besetzt das Quadrat. Bei einem anschließenden Zeichnen
        //ist das Quadrat rot.
    Procedure Befreien;
        //Befreit das Quadrat. Bei einem anschließenden Zeichnen
        //ist das Quadrat grau.
    Property IstBelegt:Boolean read besetzt;
        //Liefert TRUE wenn das Quadrat besetzt ist.
  end;
implementation
  Constructor TSpielQuadrat.Erzeugen(px,py,pl:Integer);
    Begin
      besetzt:= false;
      x:=px;y:=py;Breite:=pl;
      farbe:=clgray;
    End;
  Procedure TSpielQuadrat.Zeichnen(img:TImage);
    Begin
      with img.canvas do
        begin
          brush.color := farbe;
          rectangle(x,y,x+Breite,y+Breite);
        end;
    End;
  Procedure TSpielQuadrat.Belegen;
    Begin
      besetzt := True;
      farbe:=clred;
    End;
  Procedure TSpielQuadrat.Befreien;
    Begin
      besetzt := False;
      farbe := clgray;
    End;

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:

unit UObjklSpielfeld;

interface
uses uobjklSpielQuadrat,classes,extctrls;

Type TSpielFeld = class(TObject)
  private
    x,y : Integer;        //Linke obere Ecke des Spielfeldes
    qBreite : Integer;    //Länge u. Breite eines Quadrates
    qAnzahl : Integer;    //Anzahl der Quadrate
    liste : TList;        //Liste aller Spielquadrate von oben links bis unten rechts
  public
    Constructor Erzeugen(img:TImage;px,py,pAnzahl:Integer);
    Procedure Zeichnen(img:TImage);
         //Zeichnet das vollständige Spielfeld
    Procedure SetzeZufallsgeneration;
         //Setzt eine Zufallsgeneration auf das Spielfeld
    Procedure NaechsteGeneration(sf:TSpielfeld);
         //Berechnet die nächste Generation
    Procedure Belege(pi:Integer);
         //Besetzt das Quadrat mit index pi
    Procedure Befreie(pi:Integer);
         //Befreit das Quadrat mit index pi
    Function IstBesetzt(pi:Integer):Boolean;
        //Gibt an, ob das Quadrat mit index pi besetzt ist
    Function AnzahlDerNachbarn(pi:Integer):Integer;
        //Berechnet die Anzahl der Nachbarn zum Quadrat mit index pi
    Function QuadratNummer(px,py:Integer):Integer;
        //Berechnet den index aus den image - Koordinaten
    Function Spalte(pi:Integer):Integer;
        //Berechnet aus dem Quadratindex die SpielfeldSpalte
    Function Zeile (pi:Integer):Integer;
        //Berechnet aus dem Quadratindex die SpielfeldZeile
    Function QuadratIndex(pZeile,pSpalte:Integer):Integer;
        //Berechnet aus SpielfeldZeile und SpielfeldSpalte
        //den QuadratIndex in der QuadratListe des Spielfeldes
    Function AnzahlIndividuen:Integer;
        //Berechnet die Anzahl der besetzten Quadrate
  end;
implementation

Constructor TSpielFeld.Erzeugen(img:TImage;px,py,pAnzahl:Integer);
VAR i,j:Integer;
    q:TSpielQuadrat;
  Begin
    x:=px; y:=py; qAnzahl := pAnzahl;
    qBreite := img.Height div round(sqrt(qAnzahl));
    liste := TList.Create;
    For i:=1 to round(sqrt(qAnzahl)) do
      FOR j:=1 to round(sqrt(qAnzahl)) do
      Begin
        q:=TSpielQuadrat.Erzeugen(x+(j-1)*qBreite,y+(i-1)*qBreite,qBreite);
        liste.Add(q);
      End;
  End;
Procedure TSpielFeld.zeichnen(img:TImage);
  VAR i:Integer;
      q:TSpielQuadrat;
  Begin
    For i:=0 to qAnzahl-1 do
      Begin
        q:=liste.items[i];
        q.zeichnen(img)
      End;
  End;

Procedure TSpielfeld.SetzeZufallsgeneration;
VAR i:Integer;
  Begin
    Randomize;
    For i:=0 to qAnzahl-1 do
      if Random(3) = 0 Then Belege(i);
  End;

Procedure TSpielfeld.NaechsteGeneration(sf:TSpielfeld);
var i:Integer;
  Begin
    For i:=0 to liste.count-1 do
      begin
        if sf.IstBesetzt(i) and
           ((sf.AnzahlDerNachbarn(i)=2) or (sf.AnzahlderNachbarn(i)=3))
          then belege(i);
        if not sf.IstBesetzt(i) and (sf.AnzahlderNachbarn(i)=3)
          then belege(i);
      end;
  End;

Procedure TSpielFeld.Belege(pi:Integer);
VAR q:TSpielQuadrat;
  Begin
    q:=liste.items[pi];
    q.Belegen;
  End;

Procedure TSpielFeld.Befreie(pi:Integer);
VAR q:TSpielQuadrat;
  Begin
    q:=liste.items[pi];
    q.Befreien;
  End;

Function TSpielfeld.IstBesetzt(pi:Integer):Boolean;
VAR q:TSpielQuadrat;
  Begin
    q:=liste.items[pi];
    IstBesetzt:=q.IstBelegt;
  End;

Function TSpielfeld.AnzahlDerNachbarn(pi:Integer):Integer;
VAR a,b,i,j,qi,BelegtAnzahl:Integer;
    q:TSpielQuadrat;
  Begin
    BelegtAnzahl:=0;
    a:=zeile(pi);b:=spalte(pi);
    For i:= a-1 to a+1 do
      For j:= b-1 to b+1 do
        if (i>0) and (i<=round(sqrt(qAnzahl)))and (j>0)
            and (j<=round(sqrt(qAnzahl)))and ((i<>a) or (j<>b))
             Then
              Begin
                qi:=QuadratIndex(i,j);
                q:=liste.items[qi];
                if q.Istbelegt Then inc(BelegtAnzahl);
              End;
    result:=BelegtAnzahl;
  End;

Function TSpielfeld.QuadratNummer(px,py:Integer):Integer;
VAR anzZeilen,anzSpalten:Integer;
  Begin
    anzZeilen:=(py DiV qBreite)+1;
    anzSpalten:=(px DIV qBreite)+1;
    result := (anzZeilen-1)*round(sqrt(qAnzahl))+anzSpalten -1;
  End;

Function TSpielfeld.Spalte(pi:Integer):Integer;
  Begin
    result:=pi mod round(sqrt(qAnzahl))+1;
  End;

Function TSpielFeld.Zeile (pi:Integer):Integer;
  Begin
    result:=pi div round(sqrt(qAnzahl))+1
  End;

Function TSPielfeld.QuadratIndex(pZeile,pSpalte:Integer):Integer;
  Begin
    result:=(pZeile-1)*round(sqrt(qAnzahl))+pSpalte-1;
  End;

Function TSpielfeld.AnzahlIndividuen:Integer;
VAR q:TSpielQuadrat;
    i,anz:Integer;
  Begin
    anz:=0;
    For i:=0 to qAnzahl-1 do
      Begin
        q:=liste.items[i];
        if q.IstBelegt Then inc(anz);
      End;
    result:=anz;
  End;
end.					

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

procedure TForm1.Image2MouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
sf2.Belege(sf2.QuadratNummer(x,y));
sf2.Zeichnen(image1);
if sf1.IstBesetzt(sf1.QuadratNummer(x,y))
then sf2.Befreie(sf2.QuadratNummer(x,y));