AI with alpha beta pruning + iterative deepening added

Author: gkcs

src/main/java/Engine.java

@@ -1,26 +1,24 @@
+import commons.Color;
 import game.Board;
 import game.Move;
 
-import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.stream.Collectors;
 
 public class Engine {
+    public static int nodesEvaluated;
 
     public int countAllMoves(final Board board, final int depth) {
         return countAllMoves(board, depth, 1000);
     }
 
     public int countAllMoves(final Board board, final int depth, final int printAt) {
         final List<Move> legalMoves = board.getLegalMoves();
-//        if (board.fenRepresentation().equals("8/2p5/K2p4/1P4kr/1R6/6p1/4P3/8 w - -")) {
-//            System.out.println("HERE");
-//            System.out.println(board);
-//            System.out.println(Arrays.deepToString(board.canCastle));
-//            System.out.println(legalMoves.stream().map(Move::toString).collect(Collectors.joining("\n")));
-//            final List<Move> legalMovezzz = board.getLegalMoves();
-//            System.out.println(legalMovezzz);
-//        }
         if (legalMoves.isEmpty()) {
             return 0;
         }
@@ -31,20 +29,160 @@ public int countAllMoves(final Board board, final int depth, final int printAt)
             final Board copy = board.copy();
             copy.makeMove(move);
             final int countAllMoves = countAllMoves(copy, depth - 1, printAt);
-            if (depth == printAt) {// && board.fenRepresentation().equals("8/8/2pp4/1P4kr/K4pP1/8/4P3/1R6 b - -")) {
+            if (depth == printAt) {
                 System.out.println(getString(move) + ": " + countAllMoves + " " + move +
-//                         Arrays.deepToString(copy.canCastle) + " \n" + copy.getKing(Color.BLACK).getMoveList(copy) + " \n" +
                         " " + copy.fenRepresentation());
             }
             return countAllMoves;
         }).sum();
     }
 
+    public Evaluation minMax(final Board board, final int depth, final int printAt) {
+        final List<Move> legalMoves = board.getLegalMoves();
+        nodesEvaluated++;
+        if (legalMoves.isEmpty() || depth == 0) {
+            return new Evaluation(null, -board.evaluation(legalMoves.size()));
+        }
+        Evaluation bestMove = null;
+        for (Move move : legalMoves) {
+            final Board copy = board.copy();
+            copy.makeMove(move);
+            final Evaluation eval = minMax(copy, depth - 1, printAt);
+            if (depth == printAt) {
+                System.out.println(getString(move) + ": " + eval.getScore() + " " + move +
+                        " " + copy.fenRepresentation());
+            }
+            if (bestMove == null || bestMove.getScore() > -eval.getScore()) {
+                bestMove = new Evaluation(move, -eval.getScore());
+                if (bestMove.getScore() < 0 && bestMove.getScore() + Integer.MAX_VALUE < 0.0001) {
+                    return bestMove;
+                }
+            }
+        }
+        return bestMove;
+    }
+
+    public OutCome alphaBeta(final Board board, final int depth, double alpha, double beta, final int printAt) {
+        final List<Move> legalMoves = board.getLegalMoves();
+        nodesEvaluated++;
+        if (legalMoves.isEmpty() || depth == 0) {
+            return new OutCome(board, null, -board.evaluation(legalMoves.size()));
+        }
+        final List<OutCome> outComes = legalMoves.stream().map(move -> {
+            final Board changedBoard = board.copy();
+            changedBoard.makeMove(move);
+            return new OutCome(changedBoard, move, changedBoard.evaluation());
+        }).sorted(Comparator.comparingDouble(outCome -> -outCome.getScore())).collect(Collectors.toList());
+        OutCome bestMove = null;
+        for (final OutCome outCome : outComes) {
+            final OutCome eval = alphaBeta(outCome.getBoard(), depth - 1, alpha, beta, printAt);
+            if (depth == printAt) {
+                System.out.println(getString(outCome.getMove()) + ": " + eval.getScore() + " " + outCome +
+                        " " + outCome.getBoard().fenRepresentation());
+            }
+            if (bestMove == null || bestMove.getScore() > -eval.getScore()) {
+                bestMove = new OutCome(board, outCome.getMove(), -eval.getScore());
+                if (bestMove.getScore() < 0 && bestMove.getScore() + Integer.MAX_VALUE < 0.0001) {
+                    return bestMove;
+                }
+            }
+            if (board.playerToMove.equals(Color.WHITE)) {
+                if (alpha < -bestMove.getScore()) {
+                    alpha = -bestMove.getScore();
+                }
+            } else {
+                if (beta > bestMove.getScore()) {
+                    beta = bestMove.getScore();
+                }
+            }
+            if (alpha > beta) {
+                break;
+            }
+        }
+        return bestMove;
+    }
+
+    public OutCome iterativeDeepening(final Board board, final long time) {
+        final long start = System.currentTimeMillis();
+        int depth = 1;
+        OutCome evaluation = alphaBeta(board, depth, Integer.MIN_VALUE, Integer.MAX_VALUE, 1000);
+        while (System.currentTimeMillis() - start < time * 1000 && Math.abs(evaluation.getScore()) - Integer.MAX_VALUE < 0.0001) {
+            depth++;
+            System.out.println("DEPTH: " + depth + " EVAL: " + evaluation + " TIME: " + ((System.currentTimeMillis() - start) / 1000));
+            try {
+                int finalDepth = depth;
+                evaluation = CompletableFuture.supplyAsync(() -> alphaBeta(board, finalDepth, Integer.MIN_VALUE, Integer.MAX_VALUE, 1000)).get(time * 1000 - (System.currentTimeMillis() - start), TimeUnit.MILLISECONDS);
+            } catch (InterruptedException | ExecutionException | TimeoutException e) {
+                System.out.println("TIMEOUT: " + depth);
+                break;
+            }
+        }
+        return evaluation;
+    }
+
     private String getString(Move move) {
         return move.piece.position.notation() + move.target.notation();
     }
 }
 
+class Evaluation {
+    private final Move move;
+    private final double score;
+
+    public Evaluation(Move move, double score) {
+        this.move = move;
+        this.score = score;
+    }
+
+    public double getScore() {
+        return score;
+    }
+
+    public Move getMove() {
+        return move;
+    }
+
+    @Override
+    public String toString() {
+        return "{" +
+                "move=" + move +
+                ", score=" + score +
+                '}';
+    }
+}
+
+class OutCome {
+    private final Board board;
+    private final Move move;
+    private final double score;
+
+    public OutCome(Board board, Move move, double score) {
+        this.move = move;
+        this.score = score;
+        this.board = board;
+    }
+
+    public double getScore() {
+        return score;
+    }
+
+    public Move getMove() {
+        return move;
+    }
+
+    public Board getBoard() {
+        return board;
+    }
+
+    @Override
+    public String toString() {
+        return "{" +
+                "board=\n" + board +
+                ", move=" + move +
+                ", score=" + score +
+                '}';
+    }
+}
 /*
 
 

src/main/java/game/Board.java

@@ -639,10 +639,14 @@ public Board copy() {
         return board;
     }
 
+    public double evaluation() {
+        return evaluation(getLegalMoves().size());
+    }
+
     //todo: idea: Should we compare a list of positions and choose the best? We do not evaluate positions in isolation,
     // but rather rank them by comparing the top 20 positions possible
-    public int evaluation() {
-        if (getLegalMoves().size() == 0) {
+    public double evaluation(int availableMoves) {
+        if (availableMoves == 0) {
             if (inCheck) {
                 return Integer.MIN_VALUE;
             } else {
@@ -652,12 +656,12 @@ public int evaluation() {
         if (isDraw()) {
             return 0;
         }
-        return heuristic();
+        return heuristic() + availableMoves / 100.0;
     }
 
     private int heuristic() {
-        return playerPieces.get(Color.WHITE).stream().mapToInt(piece -> approxValue.get(piece.pieceType)).sum()
-                - playerPieces.get(Color.BLACK).stream().mapToInt(piece -> approxValue.get(piece.pieceType)).sum();
+        return playerPieces.get(playerToMove).stream().mapToInt(piece -> approxValue.get(piece.pieceType)).sum()
+                - playerPieces.get(Color.opponent(playerToMove)).stream().mapToInt(piece -> approxValue.get(piece.pieceType)).sum();
     }
 
     public boolean isDraw() {

src/test/java/BoardTest.java

@@ -43,7 +43,7 @@ public void captureAndReturnCheck() {
         System.out.println(board.getLegalMoves());
         Assert.assertEquals(6, board.getLegalMoves().size());
         Assert.assertFalse(board.isDraw());
-        Assert.assertEquals(-2, board.evaluation());
+        Assert.assertEquals(-2, board.evaluation(board.getLegalMoves().size()));
         board.makeMove(board.getLegalMoves().stream().filter(c -> c.captureMove).findAny().get());
         System.out.println(board);
         System.out.println(board.getLegalMoves());
@@ -64,7 +64,7 @@ public void checkMate() {
         System.out.println(board);
         System.out.println(board.getLegalMoves());
         Assert.assertTrue(board.getLegalMoves().isEmpty());
-        Assert.assertEquals(Integer.MIN_VALUE, board.evaluation());
+        Assert.assertEquals(Integer.MIN_VALUE, board.evaluation(board.getLegalMoves().size()));
     }
 
     @Test
@@ -77,7 +77,7 @@ public void staleMate() {
         System.out.println(board);
         System.out.println(board.getLegalMoves());
         Assert.assertTrue(board.getLegalMoves().isEmpty());
-        Assert.assertEquals(0, board.evaluation());
+        Assert.assertEquals(0, board.evaluation(board.getLegalMoves().size()));
     }
 
     @Test
@@ -91,7 +91,7 @@ public void checkMateIn1() {
         System.out.println(board);
         System.out.println(board.getLegalMoves());
         Assert.assertEquals(21, board.getLegalMoves().size());
-        Assert.assertEquals(-1, board.evaluation());
+        Assert.assertEquals(-1, board.evaluation(board.getLegalMoves().size()));
     }
 
     @Test(expected = NoSuchElementException.class)

src/test/java/IntenseTest.java

@@ -17,6 +17,28 @@ public void countMovesAtPosition4() {
         Assert.assertEquals(706045033, engine.countAllMoves(board, 6));
     }
 
+    @Test
+    public void countMovesAtPosition4MinMax() {
+        Board board = Board.getBoard("r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1");
+        board.inCheck = true;
+        System.out.println(board);
+        Engine engine = new Engine();
+        Engine.nodesEvaluated = 0;
+        final Evaluation evaluation = engine.minMax(board, 4, 4);
+        System.out.println(evaluation + " \nNODES: " + Engine.nodesEvaluated);
+    }
+
+    @Test
+    public void countMovesAtPosition4AlphaBeta() {
+        Board board = Board.getBoard("r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1");
+        board.inCheck = true;
+        System.out.println(board);
+        Engine engine = new Engine();
+        Engine.nodesEvaluated = 0;
+        final OutCome evaluation = engine.alphaBeta(board, 4, Integer.MIN_VALUE, Integer.MAX_VALUE, 4);
+        System.out.println(evaluation + " \nNODES: " + Engine.nodesEvaluated);
+    }
+
     @Test
     public void countMovesAtPosition5() {
         Board board = Board.getBoard("rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8");