1:
2:
3:

if [...] then [...] else
 if then [...] else
  if then [...] //usw.?                    

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

FindeBestenZug (Spieler, Gegner, Brett, SpielTiefe, MaxTiefe, BesterZug) returns Integer;
Begin
  Foreach Move M of Player 'Spieler' do       // Für jeden möglichen Zug
     Board.DoMove(M);               // Führe ihn aus
     If SpielTiefe = MaxTiefe Then        // Max. Vorschautiefe erreicht?
        S := Board.BewerteStellung (Spieler); // Je höher S, desto besser für den 'Spieler'
     Else                                     // Ansonsten liefert dieser Aufruf ja den besten Zug des Gegners
        S := -FindeBestenZug (Gegner, Spieler, Brett, SpielTiefe + 1, MaxTiefe, DummyZug); // wir wollen den Zug,
     If S > MaxS Then       // auf den der Gegner die schlechteste Anwort parat hat, daher das '-FindeBesten....'
        MaxS := S
        BesterZug := M
     End;
     Board.UndoMove (M);  // Mache den Zug abschließend wieder rückgängig, denn wir probieren ja nur
End                    

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

Const
  nPlayerCount = 8;
Type
  TPlayer = (plHuman, plComputer); // Beim Schach sind das dann entsprechend mehr
  TBoard = Array [0..nPlayerCount -1, 0..nPlayerCount -1] of TPlayer;
  TChoord = Record  // Eine Position
    cRow, cCol : Integer 
  End; 
  TMove = Record // Ein Zug
    mPlayer : TPlayer;
    mFrom, mTo : TChoord;
  End;
  TMoveList = Array [0..2*nPlayerCount -1] Of TMove; // z.B. 8 Bauern, maximal 16 Zugmöglichkeiten                    

1:
2:
3:
4:

Procedure CreateAllMoves (aPlayer : TPlayer; aBoard : TBoard; Var aMoves : TMoveList; Var aMoveCount : Integer);
Begin
  ...
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:

FindeBestenZug (Spieler, Gegner, Brett, SpielTiefe, MaxTiefe, BesterZug, Patt) returns Integer;
Begin
  MovePossible := False;
  CreateAllMoves (Sieler, Brett, M, N);
  For i:=0 to N-1 do Begin
     MovePossible := True;
     Board.DoMove(M[i]);                      // Führe ihn aus
     If SpielTiefe = MaxTiefe Then            // Max. Vorschautiefe erreicht?
        S := Board.BewerteStellung (Spieler); // Je höher S, desto besser für den 'Spieler'
     Else                                     // Ansonsten liefert dieser Aufruf ja den besten Zug des Gegners
        S := -FindeBestenZug (Gegner, Spieler, Brett, SpielTiefe + 1, MaxTiefe, DummyZug, False); // wir wollen den Zug,
     If S > MaxS Then          // auf den der Gegner die schlechteste Anwort parat hat, daher das '-FindeBesten....'
        MaxS := S
        BesterZug := M
     End;
     Board.UndoMove (M[i]);    // Mache den Zug abschließend wieder rückgängig, denn wir probieren ja nur
  End

  if Not MovePossible Then // Spieler kann nicht ziehen
     If Patt Then          // der Vorherige auch nicht
        Result := Board.BewerteEndstellung (Spieler)      // Diese Funktion bewertet nicht die strategische 
     else                                                    // Stellung, sondern einfach, wer gewonnen hat
        Result := -FindeBestenZug (Gegner, Spieler, Brett, SpielTiefe + 1, MaxTiefe, DummyZug, True);
End                    

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

Procedure TMyForm.Showboard (aBoard : TBoard);
Var
  i,j : Integer;

Begin
  For i:=0 To 7 do
    For j:=0 to 7 do
      MyStringGrid.Cells[i,j] := aBoard[i,j];
End;                    

1:
2:
3:
4:
5:

procedure TForm1.StringGrid1SelectCell(Sender: TObject; ACol,
  ARow: Integer; var CanSelect: Boolean);
begin
 Zug(ACol, ARow);  //Zug ist eine Prozedur in Steuerung.pas
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:

//Unit Steuerung
var
  TBoard: Array [0..7, 0..7] of String[1];  //braucht nur 1 Zeichen fassen
[...]

//Unit Unit1
procedure TForm1.StringGrid1SelectCell(Sender: TObject; ACol,
  ARow: Integer; var CanSelect: Boolean);
var
  B, N: Byte;
begin
 {Erstmal alles ins Array laden}
 for B := 0 to StringGrid1.ColCount-1 do
 begin
  for N := 1 to StringGrid1.RowCount-1 do
   TBoard[B, N] := StringGrid1.Cells[B, N];
 end;

 {Prozedur Zug arbeitet mit dem Array, nicht mit dem StringGrid}
 Zug(ACol, ARow);

 {Die Ausgabe ins StringGrid zurückzeichnen}
 for B := 0 to 7 do
 begin
  for N := 1 to 7 do
   StringGrid1.Cells[B, N] := TBoard[B, N];
 end;                    

1:
2:
3:
4:
5:

const
  nPlayerCount = 8;

var
  TBoard: array [0..nPlayerCount-1, 0..nPlayerCount-1] of String[1];                    

1:

function Bewertung(Player: TPlayer): Integer;                    

1:

Bauern + Türme*3....                    

1:
2:
3:

 Result := gesamt + eigene + auf_GegnerGrund + auf_vor_GegnerGrund +
           mehr_Spieler + mehr_Computer + einfach_gedeckt +
           doppelt_gedeckt + blockiert + kann_schlagen;                    

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:

Function FindeBestenZug (Spieler, Gegner : TPlayer;  Brett : TBoard; SpielTiefe, MaxTiefe : Integer; 
  Var BesterZug : TMove; Patt : Boolean) : Integer;
Var
  MovePossible : Boolean;
  M : TMoveList;
  MaxS, S, N, i : Integer;
  DummyZug : TMove;

Begin
  MovePossible := False;
  CreateAllMoves (Spieler, Brett, M, N);      // M ist die Liste der Züge, N die Anzahl der möglichen Züge.
  For i:=0 to N-1 do Begin
     MovePossible := True;
     Board.DoMove(M[i]);                      // Führe ihn aus
     If SpielTiefe = MaxTiefe Then            // Max. Vorschautiefe erreicht?
        S := Board.BewerteStellung (Spieler); // Je höher S, desto besser für den 'Spieler'
     Else                                     // Ansonsten liefert dieser Aufruf ja den besten Zug des Gegners
        S := -FindeBestenZug (Gegner, Spieler, Brett, SpielTiefe + 1, MaxTiefe, DummyZug, False); // wir wollen den Zug,
     If S > MaxS Then          // auf den der Gegner die schlechteste Anwort parat hat, daher das '-FindeBesten....'
        MaxS := S
        BesterZug := M
     End;
     Board.UndoMove (M[i]);    // Mache den Zug abschließend wieder rückgängig, denn wir probieren ja nur
  End

  if Not MovePossible Then // Spieler kann nicht ziehen
     If Patt Then          // der Vorherige auch nicht
        Result := Board.BewerteEndstellung (Spieler)      // Diese Funktion bewertet nicht die strategische 
     else                                                    // Stellung, sondern einfach, wer gewonnen hat
        Result := -FindeBestenZug (Gegner, Spieler, Brett, SpielTiefe + 1, MaxTiefe, DummyZug, True);
End;                    

1:

S := FindeBestenZug (plHuman, plComputer, MyBoard, 0, MaxLevel, M, False);                    

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

procedure CreateMoveList(Player: TPlayer);
var
  B, N: Byte;
begin
 Form1.ListBox1.Clear;

 {Spieler, gerade nach oben ziehen}
 for B := 0 to nPlayerCount-1 do
 begin
  for N := 0 to nPlayerCount-1 do
   if (TBoard[B, N] = Human) and (TBoard[B, N-1] = '') then  //Feld oberhalb einer Figur ist frei
    Form1.ListBox1.Items.Add(IntToStr(B)+' '+IntToStr(N-1));
 end;
end;                    

1:
2:
3:
4:
5:

Type
  TPosition = Record
    pRow,
    pCol : Integer;
  End;                    

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

Type
  TMove = Record
    mFrom,
    mTo : TPosition;
    mCapture : Boolean; // True: auf mTo wird der Gegner weggefegt!
  End;                    

1:
2:

  
TMoveList = Array [0..ccMaxMoves] Of TMove;                    

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

Procedure DoMove (aBoard : TBoard; aPlayer : TPlayer; aMove : TMove);
Begin
  With aMove do Begin
    aBoard[mFrom.pRow, mFrom.pCol] := plEmpty; // von Start-pos wegnehmen
    aBoard[mTo.pRow, ,mTo.pCol] := aPlayer;   // und zur Ziel-pos bewegen
  End;                                 // was vorher dort war ist nun weg
End;

Procedure UndoMove  (aBoard : TBoard; aPlayer, aOpponent : TPlayer; aMove : TMove);
Begin
  With aMove do Begin
    aBoard[mFrom.pRow, mFrom.pCol] := aPlayer;  // Spieler wieder zurück
    If mCapture Then                   // Wenn der Zug ein Schlagzug war
      aBoard[mTo.pRow, ,mTo.pCol] := aOpponent  // Geschlagenen Stein
    Else
      aBoard[mTo.pRow, ,mTo.pCol] := plEmtpy;  // Sonst leeres Feld
  End;
End;                    

1:

Log(Format('L=%d, S=%d', [tbLevel.Position, l]));                    

1:

Log(Format('Rechentiefe=%d, Bester Zug=%d', [tbLevel.Position, l]));                    

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

    if l >= sWinScore then // Der Zug führt zum Gewinn (kann aber später sein)
      if GameOver then begin
        ShowMessage(szIWin);
        StartGame;
        Exit;
      end;                    

1:

if aBoard[r1, 7] = plEmpty then inc(v);                    

1:
2:
3:
4:

//von
procedure MakeComputerMove;
//in
procedure MakeComputerMove(Player1, Player2: TPlayer);                    

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

 while not SpielEnde do
 begin
  Level := 1;
  makeComputerMove(plHuman, plComputer);
  Level := 4;
  makeComputerMove(plComputer, plHuman);
 end;                    

1:
2:
3:
4:

Function Score(Const aBoard: TBoard; aPlayer, aOpponent: TPlayer): Integer;
  Function _Score(aPlayer, aOpponent: TPlayer): Integer;
//...
 If (aBoard[7, j] = plEmpty) and (aBoard[6, j] = aPlayer) Then inc(v);                    

1:
2:
3:

10292  // count
Siege alt =0,  neu =100
CoEffs =  6546  -17  -34  -62 -135   97 -336   43                    

1:
2:
3:

Const
  sWinScore = 1000000000;
  sPassScore = -sWinscore - 1;                    

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

Procedure SaveCoeffs (C : TCoeffArray);
var
  fn: string;
  s: TStringList;
  i: Integer;
begin
  fn := ExtractFilePath(ParamStr(0)) + 'Coeffs.TXT';  //User-DIR verwenden!
  s := TStringlist.create;
  try
    for i := 0 to Length(c)-1 do
     s.Add(IntToStr(c[i]));
    s.saveToFile (Fn);
  finally
    s.free;
  end;
end;                    

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

function Score(const aBoard: TBoard; aPlayer, aOpponent: TPlayer): Integer;
(******************************************************************************
 * Das ist das Herz der KI: Hier wird die Stellung bewertet.                  *
 * >0 bedeutet, gut für aPlayer, <0 bedeutet, schlecht für aPlayer            *
 *                                                                            *
 * Diese Funktion ist grauenhaft und zählt nur die Steine sowie ein wenig     *
 * Stellung (gedeckte Steine, Schlagmöglichkeiten). Ein 'Durchmarsch' eines   *
 * Spielers wird ignoriert, ebenso wie andere Stellungen. Ab einer Spieltiefe *
 * von 4 spielt es aber trotzdem ziemlich gut.                                *
 *                                                                            *
 * Je besser und genauer diese Funktion die Stellung wiederspiegelt, desto    *
 * stärker spielt das Programm.                                               *
 ******************************************************************************)
  function _Score(aPlayer, aOpponent: TPlayer): Integer;
  var                    

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

// Coeff[12]
          {Lücken in der Stellung erkennen}

//r ist die senkrechte, j die waagrechte Koordinate der aktuellen Position

          {Die nächsten 3 Felder links sind frei, dann folgt eine eigene Figur}
          if (aBoard[r, j-4] = aPlayer) then
           if (aBoard[r, j-1] = plEmpty) and
              (aBoard[r, j-2] = plEmpty) and
              (aBoard[r, j-3] = plEmpty) then
           inc(c);

          {Die nächsten 3 Felder rechts sind frei, dann folgt eine eigene Figur}
          if (aBoard[r, j+4] = aPlayer) then
           if (aBoard[r, j+1] = plEmpty) and
              (aBoard[r, j+2] = plEmpty) and
              (aBoard[r, j+3] = plEmpty) then
           inc(c);                    

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

var
  aBoard: TBoard;
  X1, Y1, X2, Y2: Byte;
  aPlayer: TPlayer;
begin
 for Y1 := 0 to 7 do
  for X1 := 0 to 7 do
  begin
   aPlayer := Board[Y1, X1];
   SetBoard(aBoard, aPlayer, X1, Y1);
  end;

//aBoard enthält jetzt die aktuelle Spielstellung. Wie geht's nun
//hier weiter, wenn ich das Spiel "umdrehen" will?
//aBoard ist das "temporäre" Brett, aus dem in Board umgekehrt geschrieben werden soll