1:

Board.Canvas.Draw(imgStein.Left, imgStein.Top, imgStein.Picture.Graphic);                    

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

type TDirection = (dWaagerecht, dSenkrecht);
type TDominostein = record
  X, Y: Integer;
  Points: Integer;
  Direction: TDirection;
end;

{...}

var
  Dominos: array of TDominostein;
  //weitere Anweisungen                    

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:

type
  TDirection = (diVert, diHorz);
  TDomino = packed record
    //X-Koordinate des oberen/linken Steins
    // Y-Koodinate des oberen/linken Steins
    // |  PunktWert des oberen/linken Steins
    // |  |   PunktWert des unteren/rechten Steins
    X, Y, P1, P2: Integer;
    Dir: TDirection;
  end;
  TDominoArray = array of TDomino;

var
  DominoList: TDominoArray;

//berechnet den Abstand zwischen 2 Punkten
//@P1: Punkt 1;
//@P2: Punkt 2;
//@result: Abstand der Beiden Punkte;
function GetDist(P1, P2: TPoint): Integer;
begin
  result := Abs(P1.X-P2.X) + Abs(P1.Y-P2.Y);
end;

//Prüft ob ein Domino abgelegt werden kann oder nicht und
//legt ihn ggf in das Array
//@d: Domino der geprüft/abgelget werden soll;
//@result: TRUE wenn Stein abgelegt wurde, sonst FALSE;
function TForm1.CheckDomino(d: TDomino): Boolean;
var
//aktueller Domino der Liste
  d2: TDomino;
//Koordinaten des oberen/linken Teils des Domino
//|   Koordinaten des unteren/rechten Teils des Domino
//|   |   Koordinaten des oberen/linken Teils von d2
//|   |   |   Koordinaten des unteren/rechten Teils von d2
  P1, P2, P3, P4: TPoint;
//Schleifenariable
  i: Integer;
begin
  result := false;

  //die beiden Punkte des Domino ermitteln
  P1 := Point(d.X, d.Y);
  if d.Dir = diVert then begin
    P2 := Point(d.X + 1, d.Y);
  end else begin
    P2 := Point(d.X, d.Y + 1);
  end;

  for i := 0 to High(DominoList) do begin
    d2 := DominoList[i];
    //die beiden Punkte des Domino ermitteln
    P3 := Point(d.X, d.Y);
    if d.Dir = diVert then begin
      P4 := Point(d.X + 1, d.Y);
    end else begin
      P4 := Point(d.X, d.Y + 1);
    end;

    //Dominozahlen Prüfen
    //d oben/links MIT d2 oben/links
    if (GetDist(P1, P3) = 0) then exit; //Abstand ist 0, beide Steine liegen aufeinander
    if (GetDist(P1, P3) = 1) and (d.P1 <> d2.P1) then exit; //Abstand ist 1, aber Steine haben nicht den selben Wert
    //d oben/links MIT d2 unten/rechts
    if (GetDist(P1, P4) = 0) then exit;
    if (GetDist(P1, P4) = 1) and (d.P1 <> d2.P2) then exit;
    //d unten/rechts MIT d2 oben/links
    if (GetDist(P2, P3) = 0) then exit;
    if (GetDist(P2, P3) = 1) and (d.P1 <> d2.P1) then exit;
    //d unten/rechts MIT d2 unten/rechts
    if (GetDist(P2, P4) = 0) then exit;
    if (GetDist(P2, P4) = 1) and (d.P1 <> d2.P2) then exit;
  end;
  //Wenn hier noch nicht beendet, dann passt der Stein
  //also Stein in die Liste eintragen
  SetLength(DominoList, Length(DominoList) + 1); //Array um 1 Element erweitern
  DominoList[High(DominoList)] := d; //Stein in Letztes Element eintragen
 
  result := true
end;                    

1:

  if not CheckDomino(aValue) then Caption := Caption+'NO!';                    

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

procedure TForm1.imgSteinClick(Sender: TObject);
var
  aValue: TDomino;
begin
 if isClick then  //OnClick nicht nach Verschieben+Maustaste loslassen auslösen
 begin
  aValue.X := Left;
  aValue.X := Top;
  aValue.P1 := 4;
  aValue.P2 := 2;
  aValue.Dir := diVert;

  if not CheckDomino(aValue) then caption := caption+'NO!'//
  else
  with (Sender as TImage) do
  begin
   Board.Canvas.Draw(Left, Top, Picture.Graphic);
   Picture.Bitmap := nil;
  end;
 end;

 isClick := True;
end;                    

1:
2:

  aValue.X := Left div 32;
  aValue.Y := Top div 32                    

1:
2:

iP1 := 3;
iP2 := 6;                    

1:
2:

iP1 := 6;
iP2 := 3;                    

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:

procedure TForm1.imgSteinClick(Sender: TObject);
var
  aValue: TDomino;
begin
 if isClick then  {OnClick nicht nach Verschieben+Maustaste loslassen auslösen}
 begin
(*  aValue.X := Left;
  aValue.X := Top;
*)
  aValue.X := (Sender as TImage).Left div 38;
  aValue.Y := (Sender as TImage).Top div 38;
  aValue.P1 := iP1;//3;
  aValue.P2 := iP2;//6;
  aValue.Dir := diVert;

  if not CheckDomino(aValue) then caption := caption+'NO!'//
  else
  with (Sender as TImage) do
  begin
   Board.Canvas.Draw(Left, Top, Picture.Graphic);
//   Picture.Bitmap := nil;
  end;
 end;

 isClick := True;
end;                    

1:
2:
3:
4:
5:

var
  Form1: TForm1;
  isClick: Boolean;
  iP1, iP2: Integer;
  DominoList: TDominoArray;                    

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

Punkt auf 0,0 setzen (oben links)
while not CheckDomino do
  drehe stein 
  wenn 4 mal gedreht wurde, dan...
    verschiebe Position um ein Feld nach rechts
    wenn Position auserhalb des spielfeldes, dann...
      setze X-Position auf 0
      setze Y-Position in die nächste Zeile                    

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:

var
  i, tmp: Integer;
begin
(*
Punkt auf 0,0 setzen (oben links)
while not CheckDomino do
  drehe stein
  wenn 4 mal gedreht wurde, dan...
    verschiebe Position um ein Feld nach rechts
    wenn Position auserhalb des spielfeldes, dann...
      setze X-Position auf 0
      setze Y-Position in die nächste Zeile
*)

 Domino.X := 0;
 Domino.Y := 0;
 while not CheckDomino(Domino) do
 begin
 //drehe stein
  for i := 0 to 3 do
  begin
    if Domino.Dir = diVert then begin
      tmp       := Domino.P1;
      Domino.P1 := Domino.P2;
      Domino.P2 := tmp;
      Domino.Dir := diHorz;
    end else Domino.Dir := diVert;
  end;

  //wenn 4 mal gedreht wurde, dan...
  //verschiebe Position um ein Feld nach rechts
  Inc(Domino.X);

  //wenn Position auserhalb des spielfeldes, dann...
  if Domino.X > Board.Width then
  begin
   Domino.X := 0;  //setze X-Position auf 0
   Inc(Domino.Y);  //setze Y-Position in die nächste Zeile
  end;
 end;

 //Und zeichne das Ganze!
 Board.Canvas.Draw(Domino.X * iStoneWidth, Domino.Y * iStoneWidth, imgStein.Picture.Graphic);
end;
 iStoneWidth, imgStein.Picture.Graphic);
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:

//So: -----------------------------------------------------------------
 Domino.X := 0;
 Domino.Y := 0;

 repeat
  for i := 0 to 3 do
  begin
    if Domino.Dir = diVert then begin
      tmp       := Domino.P1;
      Domino.P1 := Domino.P2;
      Domino.P2 := tmp;
      Domino.Dir := diHorz;
    end else Domino.Dir := diVert;
  end;

  //wenn 4 mal gedreht wurde, dan...
  //verschiebe Position um ein Feld nach rechts
  Inc(Domino.X);

  //wenn Position auserhalb des spielfeldes, dann...
  if Domino.X > Board.Width then
  begin
   Domino.X := 0;  //setze X-Position auf 0
   Inc(Domino.Y);  //setze Y-Position in die nächste Zeile
  end;

 until (CheckDomino(Domino)) or (Domino.Y > Board.Height);



//Oder so: -----------------------------------------------------------------
 Domino.X := 0;
 Domino.Y := 0;

 while not CheckDomino(Domino) do
 begin
 //drehe stein
  for i := 0 to 3 do
  begin
    if Domino.Dir = diVert then begin
      tmp       := Domino.P1;
      Domino.P1 := Domino.P2;
      Domino.P2 := tmp;
      Domino.Dir := diHorz;
    end else Domino.Dir := diVert;
  end;

  //wenn 4 mal gedreht wurde, dan...
  //verschiebe Position um ein Feld nach rechts
  Inc(Domino.X);

  //wenn Position auserhalb des spielfeldes, dann...
  if Domino.X > Board.Width then
  begin
   Domino.X := 0;  //setze X-Position auf 0
   Inc(Domino.Y);  //setze Y-Position in die nächste Zeile
  end;
  if Domino.Y > Board.Height then break;
 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:

var
  i, n, t, tmp: Integer;
begin
(*
Punkt auf 0,0 setzen (oben links)
while not CheckDomino do
  drehe stein
  wenn 4 mal gedreht wurde, dan...
    verschiebe Position um ein Feld nach rechts
    wenn Position auserhalb des spielfeldes, dann...
      setze X-Position auf 0
      setze Y-Position in die nächste Zeile
*)

 Domino.X := 0;
 Domino.Y := 0;
 n := 0;
 while not CheckDomino(Domino) do
 begin
 //drehe stein
//  for i := 0 to 3 do
  begin
   Drehen90Grad(imgStein.Picture.Bitmap);
//   Inc(t);
    if Domino.Dir = diVert then begin
      tmp       := Domino.P1;
      Domino.P1 := Domino.P2;
      Domino.P2 := tmp;
      Domino.Dir := diHorz;
    end else Domino.Dir := diVert;
  end;

  Inc(n);

  if n = 3 then
  begin
  //wenn 4 mal gedreht wurde, dan...
  //verschiebe Position um ein Feld nach rechts
  Inc(Domino.X);
  n := 0;
//  t := 0;
  end;

  //wenn Position auserhalb des spielfeldes, dann...
  if Domino.X > Board.Width then
  begin
   Domino.X := 0;  //setze X-Position auf 0
   Inc(Domino.Y);  //setze Y-Position in die nächste Zeile
  end;
  if Domino.Y > Board.Height then break;
 end;

 //Und zeichne das Ganze!
// for i := 0 to t do Drehen90Grad(imgStein.Picture.Bitmap);
 Board.Canvas.Draw(Domino.X * iStoneWidth, Domino.Y * iStoneWidth, imgStein.Picture.Graphic);
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:

 while not CheckDomino(Domino) do
 begin
 //drehe stein
  if Domino.Dir = diVert then begin
     tmp       := Domino.P1;
     Domino.P1 := Domino.P2;
     Domino.P2 := tmp;
     Domino.Dir := diHorz;
   end else
   begin
    Domino.Dir := diVert;
    Inc(h);  //Zähler für horizontal
   end;

  {Zähler für Drehen erhöhen}
  Inc(n);

  if n = 3 then
  begin
   //wenn 4 mal gedreht wurde, dan...
   //verschiebe Position um ein Feld nach rechts
   Inc(Domino.X);
   n := 0;
  end;

  //wenn Position auserhalb des spielfeldes, dann...
  if Domino.X  >= Board.Width then
  begin
   Domino.X := 0;  //setze X-Position auf 0
   Inc(Domino.Y);  //setze Y-Position in die nächste Zeile
  end;
  if Domino.Y >= Board.Height then break;
 end;


 //Und zeichne das Ganze!
 {Den Stein 1x drehen, wenn er horizontal abgelegt werden soll}
 if Domino.Dir = diHorz then Drehen90Grad(imgStein.Picture.Bitmap);
 {Den Stein noch 3x drehen, wenn der Zähler h eine ungerade Zahl ist, dadurch}
 {wird er so gedreht, dass die Punktezahl auf der richtigen Seite ist.}
 if Odd(h) then
 begin
  Drehen90Grad(imgStein.Picture.Bitmap);
  Drehen90Grad(imgStein.Picture.Bitmap);
 end;

 {Den Stein zeichen}
 Board.Canvas.Draw(Domino.X * iStoneWidth, Domino.Y * iStoneWidth, imgStein.Picture.Graphic);

 {Den Stein (imgStein) ggf. wieder vertikal stellen}
 if Domino.Dir = diHorz then Drehen90Grad(imgStein.Picture.Bitmap);                    

1:
2:

  SetLength(DominoList, Length(DominoList) + 1); //Array um 1 Element erweitern
  DominoList[High(DominoList)] := d; //Stein in Letztes Element eintragen                    

1:
2:
3:

 i := -1;
 while i = -1 do
  i := Random(High(DominoPossiblePos));  //alles, was nicht -1 ist, ist eine Position                    

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

procedure TForm1.CheckDominos(d: TDomino);
var
  x, y: Integer;
begin
 for x := 0 to Board.Width do
  for y := 0 to Board.Height do
   if CheckDomino(d) then
    memo1.Lines.Add('A');  //natürlich nur zum Testen!
end;                    

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

var Domino: TDomino;
für alle X-Positionen mache...
  X-Position von Domino ändern
  für alle Y-Positionen mache... 
    Y-Position von Domino ändern
    für alle drehungen mache...
      wenn CheckDomino(Domin) dann...
        AddPosiblePos(Domino)
      drehe Domino                    

1:
2:
3:

Domino = suche zufälliges Domino aus der Liste der möglichen Positionen
PlaceDomino(Domino)
Zeichne das Feld neu                    

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:

procedure TForm1.FindAllPlaces(d: TDomino);
var
{aktueller Domino der Liste}
  d2: TDomino;
  {Koordinaten des oberen/linken Teils des Domino
  |   Koordinaten des unteren/rechten Teils des Domino
  |   |   Koordinaten des oberen/linken Teils von d2
  |   |   |   Koordinaten des unteren/rechten Teils von d2}
  P1, P2, P3, P4: TPoint;
  {Schleifenariable}
  i: Integer;

  {zum prüfen ob der Stein mind. 1 Feld von einem anderen entfernt ist
  bzw. ob der Stein an einem an einem anderen anliegt}
  contact: Boolean;

  {berechnet den Abstand zwischen 2 Punkten
  @P1: Punkt 1;
  @P2: Punkt 2;
  @result: Abstand der Beiden Punkte;}
  function GetDist(P1, P2: TPoint): Integer;
  begin
    result := Abs(P1.X-P2.X) + Abs(P1.Y-P2.Y);
  end;

begin
  contact := false;

  {die beiden Punkte des Domino ermitteln}
  P1 := Point(d.X, d.Y);
  if d.Dir = diHorz then begin
    P2 := Point(d.X + 1, d.Y);
  end else begin
    P2 := Point(d.X, d.Y + 1);
  end;

  for i := 0 to High(AllPlacesList) do begin
    d2 := AllPlacesList[i];
    {die beiden Punkte des Domino ermitteln}
    P3 := Point(d2.X, d2.Y);
    if d2.Dir = diHorz then begin
      P4 := Point(d2.X + 1, d2.Y);
    end else begin
      P4 := Point(d2.X, d2.Y + 1);
    end;

    {Dominozahlen Prüfen
    d oben/links MIT d2 oben/links}
    if (GetDist(P1, P3) = 0) then exit; {Abstand ist 0, beide Steine liegen aufeinander}
    if (GetDist(P1, P3) = 1) then begin  {Abstand ist 1, aber Steine haben nicht den selben Wert}
      Contact := true;
      if (d.P1 <> d2.P1) then exit;
    end;
    {d oben/links MIT d2 unten/rechts}
    if (GetDist(P1, P4) = 0) then exit;
    if (GetDist(P1, P4) = 1) then begin
      Contact := true;
      if (d.P1 <> d2.P2) then exit;
    end;
    {d unten/rechts MIT d2 oben/links}
    if (GetDist(P2, P3) = 0) then exit;
    if (GetDist(P2, P3) = 1) then begin
      Contact := true;
      if (d.P2 <> d2.P1) then exit;
    end;
    {d unten/rechts MIT d2 unten/rechts}
    if (GetDist(P2, P4) = 0) then exit;
    if (GetDist(P2, P4) = 1) then begin
      Contact := true;
      if (d.P2 <> d2.P2) then exit;
    end;
  end;
  if not contact and (Length(AllPlacesList) > 0) then exit; {wenn Stein nicht an anderen Steinen anliegt und nicht der 1. Stein ist}

  {Wenn hier noch nicht beendet, dann passt der Stein
  also Stein in die Liste eintragen}
 SetLength(AllPlacesList, Length(AllPlacesList) + 1); {Array um 1 Element erweitern}
 AllPlacesList[High(AllPlacesList)] := d; {Stein in Letztes Element eintragen}
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:

procedure TForm1.Button1Click(Sender: TObject);  //Button1 ist nur für Testzwecke da!
var
  x, y, n, h, tmp: Integer;
  aBitmap: TBitmap;
begin
 iTalon := 0;

 aBitmap := TBitmap.Create;

 try
  aBitmap.Assign(imgStein.Picture.Bitmap);

  Domino.X := 0;
  Domino.Y := 0;
  n := 0;
  h := 0;

  for x := 0 to Board.Width do
   for y := 0 to Board.Height do
  begin
   FindAllPlaces(Domino);  //Finde alle möglichen Positionen zum Ablegen des Steins

   {Drehe Stein}
   if Domino.Dir = diVert then begin
      tmp       := Domino.P1;
      Domino.P1 := Domino.P2;
      Domino.P2 := tmp;
      Domino.Dir := diHorz;
    end else
    begin
     Domino.Dir := diVert;
     Inc(h);
    end;

   {Zähler für Drehen erhöhen}
   Inc(n);

   if n = 3 then
   begin
    {Wenn 4x gedreht wurde, dann}
    {verschiebe Position um ein Feld nach rechts}
    Inc(Domino.X);
    n := 0;
   end;

//Braucht man doch hier nicht???
(*
   {Wenn Position auserhalb des spielfeldes, dann...}
   if Domino.X  >= Board.Width then
   begin
    Domino.X := 0;  {Setze X-Position auf 0}
    Inc(Domino.Y);  {Setze Y-Position in die nächste Zeile}
   end;
   if Domino.Y >= Board.Height then
   begin
    break;
   end;
*)
  end;  {end von "for x := 0 to Board.Width do [...]"}

  {Und zeichne das Ganze!}
  {Den Stein 1x drehen, wenn er horizontal abgelegt werden soll}
  if Domino.Dir = diHorz then Drehen90Grad(aBitmap);//imgStein.Picture.Bitmap);
  {Den Stein noch 3x drehen, wenn der Zähler h eine ungerade Zahl ist, dadurch}
  {wird er so gedreht, dass die Punktezahl auf der richtigen Seite ist.}
  if Odd(h) then
  begin
   Drehen90Grad(aBitmap);
   Drehen90Grad(aBitmap);
  end;

  Domino := AllPlacesList[Random(High(AllPlacesList))];
  {Den Stein zeichen}
  Board.Canvas.Draw(Domino.X * iStoneWidth, Domino.Y * iStoneWidth, aBitmap);

 finally
  aBitmap.Free;
 end;
end;                    

1:
2:
3:
4:
5:

procedure TForm1.PlaceDomino(d: TDomino);
begin
 SetLength(DominoList, Length(DominoList) + 1); {Array um 1 Element erweitern}
 DominoList[High(DominoList)] := d; {Stein in Letztes Element eintragen}
end;                    

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

   if Domino.Dir = diVert then begin
      tmp       := Domino.P1;
      Domino.P1 := Domino.P2;
      Domino.P2 := tmp;
      Domino.Dir := diHorz;
    end else
      Domino.Dir := diVert;                    

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:

var
  DominoList, DominoPossibleList: TDominoArray;
//...

//Funktion, die prüft, ob ein Stein da abgelegt werden kann oder nicht
function TForm1.Check_if_DominoPossible(d: TDomino): Boolean;
var
{aktueller Domino der Liste}
  d2: TDomino;
  {Koordinaten des oberen/linken Teils des Domino
  |   Koordinaten des unteren/rechten Teils des Domino
  |   |   Koordinaten des oberen/linken Teils von d2
  |   |   |   Koordinaten des unteren/rechten Teils von d2}
  P1, P2, P3, P4: TPoint;
  {Schleifenariable}
  i: Integer;

  {zum prüfen ob der Stein mind. 1 Feld von einem anderen entfernt ist
  bzw. ob der Stein an einem an einem anderen anliegt}
  contact: Boolean;

  {berechnet den Abstand zwischen 2 Punkten
  @P1: Punkt 1;
  @P2: Punkt 2;
  @result: Abstand der Beiden Punkte;}
  function GetDist(P1, P2: TPoint): Integer;
  begin
    result := Abs(P1.X-P2.X) + Abs(P1.Y-P2.Y);
  end;


begin  {Check_if_DominoPossible}
  result := false;
  contact := false;

  {die beiden Punkte des Domino ermitteln}
  P1 := Point(d.X, d.Y);
  if d.Dir = diHorz then begin
    P2 := Point(d.X + 1, d.Y);
  end else begin
    P2 := Point(d.X, d.Y + 1);
  end;

  for i := 0 to High(DominoList) do begin
    d2 := DominoList[i];
    {die beiden Punkte des Domino ermitteln}
    P3 := Point(d2.X, d2.Y);
    if d2.Dir = diHorz then begin
      P4 := Point(d2.X + 1, d2.Y);
    end else begin
      P4 := Point(d2.X, d2.Y + 1);
    end;

    {Dominozahlen Prüfen
    d oben/links MIT d2 oben/links}
    if (GetDist(P1, P3) = 0) then exit; {Abstand ist 0, beide Steine liegen aufeinander}
    if (GetDist(P1, P3) = 1) then begin  {Abstand ist 1, aber Steine haben nicht den selben Wert}
      Contact := true;
      if (d.P1 <> d2.P1) then exit;
    end;
    {d oben/links MIT d2 unten/rechts}
    if (GetDist(P1, P4) = 0) then exit;
    if (GetDist(P1, P4) = 1) then begin
      Contact := true;
      if (d.P1 <> d2.P2) then exit;
    end;
    {d unten/rechts MIT d2 oben/links}
    if (GetDist(P2, P3) = 0) then exit;
    if (GetDist(P2, P3) = 1) then begin
      Contact := true;
      if (d.P2 <> d2.P1) then exit;
    end;
    {d unten/rechts MIT d2 unten/rechts}
    if (GetDist(P2, P4) = 0) then exit;
    if (GetDist(P2, P4) = 1) then begin
      Contact := true;
      if (d.P2 <> d2.P2) then exit;
    end;
  end;
  if not contact and (Length(DominoList) > 0) then exit; {wenn Stein nicht an anderen Steinen anliegt und nicht der 1. Stein ist}

  {Stein könnte abgelegt werden}
  result := True;
end;

//Prozedur, die das Array mit den möglichen Positionen neu füllt (Bsp.: FindAllPosiblePlaces)
procedure TForm1.FindAllPosiblePlaces;
begin
//Hier Check_if_DominoPossible aufrufen? Wie?
end;


//Da bin ich völlig ratlos:
//Prozedur, die das Domino in der Liste der Möglichen Positionen ablegt (Bsp.: AddToPosiblePlaces)


//Prozedur, die einen Domino ablegt (Bsp.: PlaceDomino)
procedure TForm1.PlacePossibleDomino(d: TDomino);
begin
 SetLength(DominoPossibleList, Length(DominoPossibleList) + 1); {Array um 1 Element erweitern}
 DominoPossibleList[High(DominoPossibleList)] := d; {Stein in Letztes Element eintragen}
end;

//Prozedur, die das Domino (ohne Image) dreht (Bsp.: RotateDomino)
procedure TForm1.RotateDomino(var d: TDomino);
var
  tmp: Integer;
begin
 with d do
  if Dir = diVert then
  begin
   tmp := P1;
   P1  := P2;
   P2  := tmp;
   Dir := diHorz;
  end
  else
   Dir := diVert;
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:

var
  DominoList, DominoPossibleList: TDominoArray;
//...

{Prüfen, ob ein Stein da abgelegt werden kann oder nicht}
procedure TForm1.FindAllPossiblePlaces(d: TDomino);
var
{aktueller Domino der Liste}
  d2: TDomino;
  {Koordinaten des oberen/linken Teils des Domino
  |   Koordinaten des unteren/rechten Teils des Domino
  |   |   Koordinaten des oberen/linken Teils von d2
  |   |   |   Koordinaten des unteren/rechten Teils von d2}
  P1, P2, P3, P4: TPoint;
  {Schleifenariable}
  i: Integer;

  {zum prüfen ob der Stein mind. 1 Feld von einem anderen entfernt ist
  bzw. ob der Stein an einem an einem anderen anliegt}
  contact: Boolean;

  {berechnet den Abstand zwischen 2 Punkten
  @P1: Punkt 1;
  @P2: Punkt 2;
  @result: Abstand der Beiden Punkte;}
  function GetDist(P1, P2: TPoint): Integer;
  begin
    result := Abs(P1.X-P2.X) + Abs(P1.Y-P2.Y);
  end;

begin  {FindAllPossiblePlaces}
  contact := false;

  {die beiden Punkte des Domino ermitteln}
  P1 := Point(d.X, d.Y);
  if d.Dir = diHorz then begin
    P2 := Point(d.X + 1, d.Y);
  end else begin
    P2 := Point(d.X, d.Y + 1);
  end;

  for i := 0 to High(DominoList) do begin
    d2 := DominoList[i];
    {die beiden Punkte des Domino ermitteln}
    P3 := Point(d2.X, d2.Y);
    if d2.Dir = diHorz then begin
      P4 := Point(d2.X + 1, d2.Y);
    end else begin
      P4 := Point(d2.X, d2.Y + 1);
    end;

    {Dominozahlen Prüfen
    d oben/links MIT d2 oben/links}
    if (GetDist(P1, P3) = 0) then exit; {Abstand ist 0, beide Steine liegen aufeinander}
    if (GetDist(P1, P3) = 1) then begin  {Abstand ist 1, aber Steine haben nicht den selben Wert}
      Contact := true;
      if (d.P1 <> d2.P1) then exit;
    end;
    {d oben/links MIT d2 unten/rechts}
    if (GetDist(P1, P4) = 0) then exit;
    if (GetDist(P1, P4) = 1) then begin
      Contact := true;
      if (d.P1 <> d2.P2) then exit;
    end;
    {d unten/rechts MIT d2 oben/links}
    if (GetDist(P2, P3) = 0) then exit;
    if (GetDist(P2, P3) = 1) then begin
      Contact := true;
      if (d.P2 <> d2.P1) then exit;
    end;
    {d unten/rechts MIT d2 unten/rechts}
    if (GetDist(P2, P4) = 0) then exit;
    if (GetDist(P2, P4) = 1) then begin
      Contact := true;
      if (d.P2 <> d2.P2) then exit;
    end;
  end;
  if not contact and (Length(DominoList) > 0) then exit; {wenn Stein nicht an anderen Steinen anliegt und nicht der 1. Stein ist}

 {Wenn hier noch nicht beendet, dann passt der Stein, also Stein ins Array eintragen}
 SetLength(DominoPossibleList, Length(DominoPossibleList) + 1); {Array um 1 Element erweitern}
 DominoPossibleList[High(DominoPossibleList)] := d; {Stein in Letztes Element eintragen}
end;


//Vorläufig wird das Spielen des Programms noch manuell ausgelöst,
//ich wollte sehen, ob alles klappt wie erwartet!
procedure TForm1.Button1Click(Sender: TObject);
var
  x, y, n, h: Integer;
  aBitmap: TBitmap;
begin
 aBitmap := TBitmap.Create;

 try
  aBitmap.Assign(imgStein.Picture.Bitmap);

  Domino.X := 0;
  Domino.Y := 0;
  Domino.Rotate := 0;
  n := 0;
  h := 0;

(*
für alle X-Positionen mache...
  X-Position von Domino ändern
  für alle Y-Positionen mache...
    Y-Position von Domino ändern
    für alle drehungen mache...
      wenn CheckDomino(Domin) dann...
        AddPosiblePos(Domino)
      drehe Domino
*)

 SetLength(DominoPossibleList, 0);

 {Gesamtes Spielfeld durchgehen}
 for x := 0 to Board.Width do
  for y := 0 to Board.Height do
 begin
   FindAllPossiblePlaces(Domino);  {Alle Möglichkeiten zum Ablegen ermitteln}

   RotateDomino(Domino);

   Inc(h);
   Domino.Rotate := h;


   {Zähler für Drehen erhöhen}
   Inc(n);

   if n = 3 then
   begin
    {Wenn 4x gedreht wurde, dann}
    {verschiebe Position um ein Feld nach rechts}
    Inc(Domino.X);
    n := 0;
   end;

   {Wenn Position auserhalb des spielfeldes, dann...}
   if Domino.X  >= Board.Width then
   begin
    Domino.X := 0;  {Setze X-Position auf 0}
    Inc(Domino.Y);  {Setze Y-Position in die nächste Zeile}
   end;

   if Domino.Y >= Board.Height then
    break;
 end;  {end von "for x := 0 to Board.Width do [...]"}

caption:=inttostr(High(DominoPossibleList));//

  {Es wurde kein passender Platz zum Ablegen gefuden}
  if High(DominoPossibleList) < 0 then exit;

  {"Zufälligen" Domino auswaählen}
  Domino := DominoPossibleList[Random(High(DominoPossibleList))];

  {Den Domino in die richtige Position drehen}
  if (Domino.Rotate <> 4) then
   for n := 0 to Domino.Rotate-1 do Drehen90Grad(aBitmap);

  {Trägt den Domino ins Array DominoList ein}
  CheckDomino(Domino);

  {Den Stein zeichen}
  DrawStone(aBitmap);

 finally
  aBitmap.Free;
 end;
end;                    

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

function TForm1.CheckDomino(d: TDomino): Boolean;
begin
//...

 if d.Dir = diVert then
 begin
  if d.X*iStoneWidth+iStoneHeight > Board.Width then exit;//##
  if d.Y*iStoneWidth+iStoneHeight+iStoneWidth > Board.Height then exit;//##
 end
 else
 begin
  if d.X*iStoneWidth+iStoneHeight+iStoneWidth > Board.Width then exit;//##
  if d.Y*iStoneWidth+iStoneHeight > Board.Height then exit;//##
 end;

  {Wenn hier noch nicht beendet, dann passt der Stein, also Stein ins Array eintragen}
  SetLength(DominoList, Length(DominoList) + 1); {Array um 1 Element erweitern}
  DominoList[High(DominoList)] := d; {Stein in Letztes Element eintragen}

  result := True;                    

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

   if d.X >= Board.Width then
   begin
    d.X := 0;  {Setze X-Position auf 0}
    Inc(d.Y);  {Setze Y-Position in die nächste Zeile}
   end;

   if d.Y >= Board.Height then
    break;                    

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:

function TForm1.FindAllPossiblePlaces(d: TDomino): Integer;
var
  x, y, n, h: Integer;
begin
 d.X := 0;
 d.Y := 0;
 d.Rotate := 0;
 n := 0;
 h := 0;
 SetLength(DominoPossibleList, 0);

 {Gesamtes Spielfeld durchgehen}
 for x := 0 to Board.Width do
  for y := 0 to Board.Height do
 begin
   //AddToPossiblePlaces ist wie CheckDomino, nur befüllt es ein anderes Array: DominoPossibleList
   AddToPossiblePlaces(d);  {Alle Möglichkeiten zum Ablegen ermitteln}

   RotateDomino(d);

   Inc(h);
   d.Rotate := h;

   {Zähler für Drehen erhöhen}
   Inc(n);

   if n = 3 then
   begin
    {Wenn 4x gedreht wurde, dann}
    {verschiebe Position um ein Feld nach rechts}
    Inc(d.X);
    n := 0;
   end;

   {Wenn Position auserhalb des spielfeldes, dann...}
   if d.X >= Board.Width then
   begin
    d.X := 0;  {Setze X-Position auf 0}
    Inc(d.Y);  {Setze Y-Position in die nächste Zeile}
   end;

   if d.Y >= Board.Height then
    break;
 end;  {end von "for x := 0 to Board.Width do [...]"}

 Result := High(DominoPossibleList);
end;                    

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

for x := 0 to (Board.Width div 38)-1 do begin //X-Koordinaten des Rasters durchzählen
  for y := 0 to (Board.Height div 38)-1 do begin //Y-Koordinaten des Rasters durchzählen
    d.X := 38 * x; //Position festlegen  
    d.Y := 38 * y; 
    for n := 0 to 3 do begin //Drehungen durchzählen
      d.Rotate := n; //Zähler speicher um später zu wissen, wie oft das Bild gedreht werden muss
      AddToPossiblePlaces(d); //Domino in Array schreiben, wenn Platz passen sollte
      RotateDomino(d); //drehen ohne Bild zu drehen
    end;
  end;
end;                    

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

 for x := 0 to Board.Width do
  for y := 0 to Board.Height do
 begin
  if (d.X*38 < Board.Width-38) and (d.Y*38 < Board.Height-38) then
   AddToPossiblePlaces(d);  {Alle Möglichkeiten zum Ablegen ermitteln}

//...

   {Wenn Position auserhalb des spielfeldes, dann...}
   if d.X >= Board.Width-1 then
   begin
    d.X := 0;  {Setze X-Position auf 0}
    Inc(d.Y);  {Setze Y-Position in die nächste Zeile}
   end;

   if d.Y >= Board.Height-1 then
    break;                    

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

für alle verbleibenden Steine, mache...
  wenn Stein abgelegt werden kann (CheckDomino, ohne ablegen!), dann...
    erhöhe Zähler um 1

wenn Zähler gleich null, dann...
  Textausgabe: "Kein Stein kann mehr abgelegt werden"
  Spielende                    

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

var
  i, n: Integer;
  bmp: TBitmap;
begin
 bmp := TBitmap.Create;

 for i := 0 to High(DominoList) do
 begin
  Domino := DominoList[i];

  ImageList1.GetBitmap(0, bmp);  //hier wird statt 0 der Index-Zähler eingesetzt

  for n := 0 to Domino.Rotate do
   Drehen90Grad(bmp);

  DrawStone(bmp);
 end;

 bmp.Free;
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:

function TForm1.FindAllPossiblePlaces(d: TDomino): Integer;
var
  x, y, n, h: Integer;
begin
 d.X := 0;
 d.Y := 0;
 d.Rotate := 0;
 n := 0;
 h := 0;
 SetLength(DominoPossibleList, 0);

 {Gesamtes Spielfeld durchgehen}
 for x := 0 to iBoardWidth do
  for y := 0 to iBoardHeight do
 begin
//So legt das Programm rechts und unten einfach weiter an
//  if (d.X*iStoneWidth < iBoardWidth) and
//     (d.Y*iStoneWidth < iBoardHeight) then

//So werden rechts und unten passende Steine nicht erkannt, offenbar aber
//nur dann, wenn der Stein, an den angelegt werden soll, waagrecht liegt!??
  if (d.X*iStoneWidth < iBoardWidth-iStoneWidth) and
     (d.Y*iStoneWidth < iBoardHeight-iStoneWidth) then
   AddToPossiblePlaces(d);  {Alle Möglichkeiten zum Ablegen ermitteln}

   RotateDomino(d);

   {4x Drehen bedeutet, die Ausgangsposition ist wieder erreicht}
   if h >= 4 then h := 0; {und h muss nicht weiter erhöht werden}

   Inc(h);
   d.Rotate := h;

   {Zähler für Drehen erhöhen}
   Inc(n);

   if n = 3 then
   begin
    {Wenn 4x gedreht wurde, dann}
    {verschiebe Position um ein Feld nach rechts}
    Inc(d.X);
    n := 0;
   end;

   {Wenn X-Position ausserhalb des Spielfeldes, dann...}
   if d.X >= iBoardWidth-1 then
   begin
    d.X := 0;  {... setze X-Position auf 0,}
    Inc(d.Y);  {setze Y-Position in die nächste Zeile}
   end;

   {Wenn Y-Position ausserhalb des Spielfeldes, dann abbrechen}
   if d.Y >= iBoardHeight-1 then
    break;
 end;  {end von "for x := 0 to iBoardWidth do [...]"}

 Result := High(DominoPossibleList);
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:

function TForm1.FindAllPossiblePlaces(d: TDomino): Integer;
var
  x, y, n, h: Integer;
  b: Boolean;
begin
 d.X := 0;
 d.Y := 0;
 d.Rotate := 0;
 n := 0;
 h := 0;
 SetLength(DominoPossibleList, 0);

 {Gesamtes Spielfeld durchgehen}
 for x := 0 to iBoardWidth do
  for y := 0 to iBoardHeight do
 begin
  if (d.X*iStoneWidth < iBoardWidth) and
     (d.Y*iStoneWidth < iBoardHeight) then
  begin
   b := True;

   // !
   if (d.X*iStoneWidth+iStoneWidth = iBoardWidth) and (d.Dir = diHorz) then
    b := False;

   // !
   if (d.Y*iStoneWidth+iStoneWidth = iBoardHeight) and (d.Dir = diVert) then
    b := False;

   if b then  // !
    AddToPossiblePlaces(d);  {Alle Möglichkeiten zum Ablegen ermitteln}
  end;

  RotateDomino(d);

  //...                    

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:

function TForm1.FindAllPossiblePlaces(d: TDomino): Integer;
var
  x, y, n, h: Integer;
  b: Boolean;
begin
 d.X := 0;
 d.Y := 0;
 d.Rotate := 0;
 n := 0;
 h := 0;
 SetLength(DominoPossibleList, 0);

 {Gesamtes Spielfeld durchgehen}
 for x := 0 to iBoardWidth do
  for y := 0 to iBoardHeight do
 begin
//Was stimmt hier nicht?
  if (d.X*iStoneWidth <= iBoardWidth-iStoneWidth) and
     (d.Y*iStoneWidth <= iBoardHeight-iStoneWidth) then
  begin
   b := False;
(*
//Was stimmt hier ...
   if (d.Dir = diHorz) and (d.X*iStoneWidth+iStoneWidth+iStoneWidth < 684) then
    b := True;
//... und hier nicht?
   if (d.Dir = diVert) and (d.Y*iStoneWidth+iStoneHeight+iStoneHeight < 642) then
    b := True;
*)

//Code vereinfacht, das Problem bleibt aber bestehen - es findet nicht alle möglichen Plätze!
   if (d.Dir = diHorz) then
    if (d.X < 16) and (d.Y < 14) then b := True;
//wenn hier ein else steht, werden nur die waagrechten Plätze gefunden, aber da nicht alle!
   if (d.Dir = diVert) then
    if (d.X < 17) and (d.Y < 13) then b := True;

   if b then AddToPossiblePlaces(d);  {Alle Möglichkeiten zum Ablegen ermitteln}
  end;


//Dass der Fehler ab hier irgendwo liegt, schliesse ich aus!
  RotateDomino(d);

  {4x Drehen bedeutet, die Ausgangsposition ist wieder erreicht}
  if h >= 4 then h := 0; {und h muss nicht weiter erhöht werden}

  Inc(h);
  d.Rotate := h;

  {Zähler für Drehen erhöhen}
  Inc(n);

  if n = 3 then
  begin
   {Wenn 4x gedreht wurde, dann}
   {verschiebe Position um ein Feld nach rechts}
   Inc(d.X);
   n := 0;
  end;

  {Wenn X-Position ausserhalb des Spielfeldes, dann...}
  if d.X >= iBoardWidth-1 then
  begin
   d.X := 0;  {... setze X-Position auf 0,}
   Inc(d.Y);  {setze Y-Position in die nächste Zeile}
  end;

   {Wenn Y-Position ausserhalb des Spielfeldes, dann abbrechen}
  if d.Y >= iBoardHeight-1 then
   break;
 end;  {end von "for x := 0 to iBoardWidth do [...]"}

 Result := High(DominoPossibleList);
end;