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;