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:

function TSpielfeld.alphaBeta(tiefe,alpha,beta:integer;Farbe:TSpielsteinfarbe):integer;
var
  a,i,wert:integer;
  Zugliste:TMovelist;
begin
  a := endposition; // endposition gibts an, ob das Spiel schon zu Ende ist.
  if a = 1 then Result :=  10000 else // Hier hätte Weiss gewonnen
  if a = 2 then Result := -10000 else // und hier Schwarz
  if (tiefe=0) then Result := evaluate(Farbe) else // Rekursionsanker : Am Ende der 
  begin                                            // Baumstruktur wird ausgewertet. 
    Zugliste:=generateMoves(Farbe); // Züge erstellen
    for a:=1 to 32 do if Zugliste[a] <> nil then // Züge einzeln durchgehen
    begin
      doMove(Zugliste[a]);  // Zug ausführen
      wert := -alphaBeta(tiefe-1,-beta,-alpha,switchcolor(Farbe)); // resultierende Brettstellung auswerten
      undoMove(Zugliste[a]); // Zug zurücknehmen
      if wert >= beta  then  // Beta-Abbruch: Wenn der Zug "zu gut" ist, wird der Gegner 
      begin                  //               es gar nicht erst so weit kommen lassen
        Result:= beta;
        for i:=1 to 32 do FreeandNil(Zugliste[i]);
        exit;
      end;
      if wert > alpha then alpha :=wert; // Ist der Zug besser als der bisher beste, nehmen wir ihn.
    end;
    Result := alpha;  
    for i:=1 to 32 do FreeandNil(Zugliste[i]); 
  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:

function TSpielfeld.getBestMove(Tiefe:integer;Farbe:TSpielsteinfarbe;movelistImage:TImage):TMove;
var
  a,alpha,beta,wert,auswahl:integer;
  Zugliste:TMoveList;
  Intliste:TIntlist;
begin
  alpha := -20000;
  beta  :=  20000;
  auswahl := 0;
  for a:=1 to 32 do Intliste[a]:=0;
  Zugliste := generateMoves(Farbe);
  for a:=1 to 32 do if Zugliste[a] <> nil then
  begin
    doMove(Zugliste[a]);
    if Farbe = Weiss   then wert :=   alphaBeta(Tiefe,alpha,beta,Schwarz)
                       else wert :=  -alphaBeta(Tiefe,alpha,beta,Weiss);
    undoMove(Zugliste[a]);
    Intliste[a] := wert;
    if wert >= beta  then
    begin
      Result := Zugliste[a];
      if movelistImage <> nil then movelistZeichnen(Zugliste,Intliste,movelistImage);
      exit;
    end;
    if wert > alpha then begin alpha :=wert; auswahl:=a; end;
  end;
  if auswahl = 0 then Result := TMove.create(1,1,1,1)
                 else Result := Zugliste[auswahl];
  if movelistImage <> nil then movelistZeichnen(Zugliste,Intliste,movelistImage);
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:

Type
  TMove = record
    mPlayer,                    // Welcher Stein ist auf dem Feld
      mPrev: TPlayer;           // Welcher Stein war vorher drauf (beim Zurücknehmen des Zuges)
    mFrom, mTo: TPoint;         // Zug geht von mFrom nach mTo
    mScore: Integer;            // Bewertung des Zuges hoher Wert = gut
  end;

Function AlphaBeta(Level: Integer; aPlayer, aOpponent: TPlayer; Var aBoard: TBoard; Var aBestMove: TMove; Alpha, Beta: Integer; aPatt: Boolean): Integer;
Var
  aMoves: TMoveList;
  I, N, S: Integer;

Begin
  Result := sPassScore;
  aBestMove.mPlayer := plEmpty;
// CreateAllMoves erzeugt eine Liste aller möglichen Züge und bewertet sie.
  CreateAllMoves(aPlayer, aOpponent, aBoard, aMoves, N); 
// Sortieren, damit gute Zuge zuerst ausgeführt werden und somit A/B schneller greift
// Die Liste wird anhand der Zugbewertung sortiert. Die sollte rudimentär (also schnell) 
// sein und eben z.B. Gewinnzüge mit hohen Werten belegen
  if level>0 Then
    SortMoveList(aBoard, aMoves, Level,aPlayer, aOpponent); 
  If aMoves.Count = 0 Then                                    // Keine Züge vorhanden
    If aPatt Then                         // Wenn der Aufrufer auch nicht konnte, ... 
      Result := 0                                              // ... ist es ein Patt
    Else                    // ... ansonsten den Gegner ziehen lassen mit 'aPatt=True'
      Result := -AlphaBeta(Level, aOpponent, aPlayer, aBoard, M, -beta, -alpha, True)
  Else Begin
    inc(iTotal);
    For i := 0 To aMoves.Count - 1 Do Begin       // Nacheinander alle Züge ausführen
      MakeMove(aBoard, aMoves[i]);
      if (Level = 0) or (amoves[i].mScore >= sWinScore) then // Bei Zugtiefe 0 nehmen
        S := aMoves[i].mScore         // wir die Zugbewertung, besser wäre jedoch die 
      Else                                         // ausführliche Stellungsbewertung
        S := -AlphaBeta(Level - 1, aOpponent, aPlayer, aBoard, M, -beta, -alpha, False);
      UndoMove(aBoard, aMoves[i]);                                // Zug zurücknehmen
      If (s >= beta) Then Begin                                   // Beta Optimierung 
        aBestMove := aMoves[i];                               // Besser geht es nicht
        Result := Beta;
        Exit;                        // Also abbruch, denn Weitersuchen bringt nichts
      End;
      If (S > alpha) Then Begin
        Alpha := S;
        aBestMove := aMoves[i];
      End
    End;
    Result := Alpha;
  End;
End;

// Mit dieser Funktion findet man den besten Zug 'aBestMove' des Spielers mit der Farbe 'aPlayer'
// Die Funktion soll bis zu einer Zugtiefe von aLevel rechnen. Es wird der 'Wert' des besten Zuges
// geliefert.
// Wenn aBestMove.mPlayer = plEmpty, dann konnte kein Zug gefunden werden
//
function FindBestMove(aLevel: Integer; aPlayer, aOpponent: TPlayer; var aBoard: TBoard; var aBestMove: TMove): Integer;
begin
  Result := AlphaBeta(aLevel, aPlayer, aOpponent, aBoard, aBestMove, -maxint, maxint);
end;					

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

...
    S := -AlphaBeta(Level - 1, aOpponent, aPlayer, aBoard, M, -beta, -alpha, False);
    UndoMove(aBoard, aMoves[i]);
    ...
    If (S > alpha) Then Begin
      Alpha := S;
      aBestMove := aMoves[i];
   End;
...					

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

...
    if Farbe = Weiss   then wert :=   alphaBeta(Tiefe,alpha,beta,Schwarz)
                       else wert :=  -alphaBeta(Tiefe,alpha,beta,Weiss);
...
    if wert > alpha then begin alpha :=wert; auswahl:=a; end;
...					

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

meins:
    wert := -alphaBeta(tiefe-1,-beta,-alpha,switchcolor(Farbe)); // resultierende Brettstellung auswerten
    undoMove(Zugliste[a]); // Zug zurücknehmen

deins:
    S := -AlphaBeta(Level - 1, aOpponent, aPlayer, aBoard, M, -beta, -alpha, False);
    UndoMove(aBoard, aMoves[i]);					

1:

Function ScoreBoard (aBoard : TBoard; aPlayer : TPlayer) : Integer;					

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:

function TSpielfeld.alphaBeta(tiefe,alpha,beta:integer;Farbe:TSpielsteinfarbe):integer;
var
  a,i,wert:integer;
  Zugliste:TMovelist;
begin
  a := endposition;
  if (a = 1) and (Farbe = Weiss)   then Result :=  10000 else //geändert
  if (a = 2) and (Farbe = Weiss)   then Result := -10000 else //geändert
  if (a = 1) and (Farbe = Schwarz) then Result := -10000 else //geändert
  if (a = 2) and (Farbe = Schwarz) then Result :=  10000 else //geändert
  if (tiefe=0) then Result := evaluate(Farbe) else  //evaluate geändert
  begin
    Zugliste:=generateMoves(Farbe);
    // Züge sortieren
    for a:=1 to 32 do if Zugliste[a] <> nil then
    begin
      doMove(Zugliste[a]);
      wert := -alphaBeta(tiefe-1,-beta,-alpha,switchcolor(Farbe));
      undoMove(Zugliste[a]);
      if wert >= beta  then
      begin
        Result:= beta;
        for i:=1 to 32 do FreeandNil(Zugliste[i]);
        exit;
      end;
      if wert > alpha then alpha :=wert;
    end;
    Result := alpha;
    for i:=1 to 32 do FreeandNil(Zugliste[i]);
  end;
end;

function TSpielfeld.getBestMove(Tiefe:integer;Farbe:TSpielsteinfarbe;movelistImage:TImage):TMove;
var
  a,alpha,beta,wert,auswahl:integer;
  Zugliste:TMoveList;
  Intliste:TIntlist;
begin
  alpha := -20000;
  beta  :=  20000;
  auswahl := 0;
  for a:=1 to 32 do Intliste[a]:=0;
  Zugliste := generateMoves(Farbe);
  for a:=1 to 32 do if Zugliste[a] <> nil then
  begin
    doMove(Zugliste[a]);
    wert :=  -alphaBeta(Tiefe,-beta,-alpha,switchcolor(Farbe)); //geändert
    undoMove(Zugliste[a]);
    Intliste[a] := wert;
    if wert >= beta  then
    begin
      Result := Zugliste[a];
      if movelistImage <> nil then movelistZeichnen(Zugliste,Intliste,movelistImage);
      exit;
    end;
    if wert > alpha then begin alpha :=wert; auswahl:=a; end;
  end;
  if auswahl = 0 then Result := TMove.create(1,1,1,1)
                 else Result := Zugliste[auswahl];
  if movelistImage <> nil then movelistZeichnen(Zugliste,Intliste,movelistImage);
end;