generalized the position counter

thinking time runs out

src/main.cpp

@@ -27,7 +27,8 @@ int main(int argc, char* argv[]) {
     // ai::v2_alpha_beta p2(false, std::chrono::milliseconds(20000));
     // ai::v3_AB_ordering p2(false, std::chrono::milliseconds(20000));
     // ai::v4_search_captures p2(false, std::chrono::milliseconds(20000));
-    ai::v5_better_endgame p2(false, std::chrono::milliseconds(20000));
+    // ai::v5_better_endgame p2(false, std::chrono::milliseconds(20000));
+    ai::v6_iterative_deepening p2(false, std::chrono::milliseconds(2000));
 
     GUI gui;
     // NoOpView gui;

src/model/ais/ai.cpp

@@ -4,7 +4,10 @@
 #include <ostream>
 #include <thread>
 
+static long int position_counter = 0;
+
 Move ai::AI::search(const Board& b) {
+    position_counter = 0;
     Move result;
 
     std::condition_variable cv;
@@ -47,6 +50,13 @@ Move ai::AI::search(const Board& b) {
     // Ensure timer thread is also stopped
     timer_thread.join();
 
-    std::cout << "Took " << elapsed << " ms" << std::endl;
+    std::cout << "Took " << elapsed << " ms, " << "Looked at "
+              << position_counter << " positions" << std::endl;
     return result;
 }
+
+int ai::AI::eval(const Board& b) {
+    int ret = _eval(b);
+    position_counter++;
+    return ret;
+}

src/model/ais/ai.hpp

@@ -20,8 +20,9 @@ namespace ai {
         std::atomic<bool> stop_computation = false;
 
         Move search(const Board& b);
+        int eval(const Board&);
 
-        virtual int eval(const Board&) = 0;
+        virtual int _eval(const Board&) = 0;
     };
 
     struct v0_random : public AI {
@@ -29,7 +30,7 @@ namespace ai {
 
         Move _search(const Board&) override;
 
-        int eval(const Board&) override {
+        int _eval(const Board&) override {
             return 0;
         };
     };
@@ -41,36 +42,37 @@ namespace ai {
         v1_pure_minimax(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
 
         Move _search(const Board&) override;
-        int eval(const Board&) override;
+        int _eval(const Board&) override;
     };
 
     class v2_alpha_beta : public AI {
         // looks two moves ahead, with alpha-beta pruning (no move ordering)
-        int _search(const Board&, int, int, int);
+        virtual int _search(const Board&, int, int, int);
 
       public:
         v2_alpha_beta(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
 
-        Move _search(const Board&) override;
-        int eval(const Board&) override;
+        virtual Move _search(const Board&) override;
+        virtual int _eval(const Board&) override;
     };
 
     class v3_AB_ordering : public AI {
         // looks two moves ahead, with alpha-beta pruning, with move ordering
-        virtual int _search(const Board&, int, int, int);
+        virtual int _ab_search(const Board&, int, int, int);
 
       public:
         v3_AB_ordering(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
 
-        Move _search(const Board&) override;
-        int eval(const Board&) override;
+        virtual Move _search(const Board&) override;
+        virtual int _eval(const Board&) override;
     };
 
     class v4_search_captures : public v3_AB_ordering {
+      protected:
         // same as v3, but looking at only at captures when leaf is reached,
         // until no captures are left
-        int _search(const Board&, int, int, int) override;
-        int _search_captures(const Board&, int, int);
+        virtual int _ab_search(const Board&, int, int, int) override;
+        virtual int _search_captures(const Board&, int, int);
 
       public:
         v4_search_captures(bool w, std::chrono::milliseconds tt)
@@ -85,6 +87,18 @@ namespace ai {
         v5_better_endgame(bool w, std::chrono::milliseconds tt)
             : v4_search_captures(w, tt) {}
 
-        int eval(const Board&) override;
+        virtual int _eval(const Board&) override;
+    };
+
+    class v6_iterative_deepening : public v5_better_endgame {
+        // same as v5, but instead of just looking 2 moves ahead, it does
+        // iterative depening until and keeps on searching until the thinking
+        // time runs out
+
+      public:
+        v6_iterative_deepening(bool w, std::chrono::milliseconds tt)
+            : v5_better_endgame(w, tt) {}
+
+        virtual Move _search(const Board&) override;
     };
 } // namespace ai

src/model/ais/v1_pure_minimax.cpp

@@ -7,10 +7,7 @@
 
 #define MULTITHREADED 1
 
-static int position_counter = 0;
-
 Move ai::v1_pure_minimax::_search(const Board& b) {
-    position_counter = 0;
     std::vector<Move> moves = b.all_legal_moves();
 
     Move best_move;
@@ -52,7 +49,6 @@ Move ai::v1_pure_minimax::_search(const Board& b) {
         }
     }
 #endif
-    std::cout << "Looked at " << position_counter << " positions" << std::endl;
     return best_move;
 }
 
@@ -78,8 +74,7 @@ int ai::v1_pure_minimax::_search(const Board& b, int depth) {
     return best_evaluation;
 }
 
-int ai::v1_pure_minimax::eval(const Board& b) {
-    position_counter++;
+int ai::v1_pure_minimax::_eval(const Board& b) {
     int white_eval = count_material(b, Colour::White);
     int black_eval = count_material(b, Colour::Black);
 

src/model/ais/v2_alpha_beta.cpp

@@ -7,11 +7,7 @@
 
 #define MULTITHREADED 1
 
-
-static int position_counter = 0;
-
 Move ai::v2_alpha_beta::_search(const Board& b) {
-    position_counter = 0;
     std::vector<Move> moves = b.all_legal_moves();
 
     Move best_move;
@@ -53,7 +49,6 @@ Move ai::v2_alpha_beta::_search(const Board& b) {
         }
     }
 #endif
-    std::cout << "Looked at " << position_counter << " positions" << std::endl;
     return best_move;
 }
 
@@ -79,8 +74,7 @@ int ai::v2_alpha_beta::_search(const Board& b, int depth, int alpha, int beta) {
     return alpha;
 }
 
-int ai::v2_alpha_beta::eval(const Board& b) {
-    position_counter++;
+int ai::v2_alpha_beta::_eval(const Board& b) {
     int white_eval = count_material(b, Colour::White);
     int black_eval = count_material(b, Colour::Black);
 

src/model/ais/v3_AB_ordering.cpp

@@ -8,11 +8,7 @@
 
 #define MULTITHREADED 1
 
-
-static int position_counter;
-
 Move ai::v3_AB_ordering::_search(const Board& b) {
-    position_counter = 0;
     std::vector<Move> moves = b.all_legal_moves();
 
     Move best_move;
@@ -25,9 +21,11 @@ Move ai::v3_AB_ordering::_search(const Board& b) {
     std::map<Move, std::future<int>> futures;
     for (const Move& move : moves) {
         Board tmp_board = b.make_move(move);
-        futures.insert({move, pool.enqueue([&, tmp_board]() {
-                            return _search(tmp_board, 3, -INFINITY, INFINITY);
-                        })});
+        futures.insert(
+            {move, pool.enqueue([&, tmp_board]() {
+                 return _ab_search(tmp_board, 3, -INFINITY, INFINITY);
+             })}
+        );
     }
 
     int counter = 0;
@@ -54,11 +52,10 @@ Move ai::v3_AB_ordering::_search(const Board& b) {
         }
     }
 #endif
-    std::cout << "Looked at " << position_counter << " positions" << std::endl;
     return best_move;
 }
 
-int ai::v3_AB_ordering::_search(
+int ai::v3_AB_ordering::_ab_search(
     const Board& b, int depth, int alpha, int beta
 ) {
     if (depth == 0 || stop_computation)
@@ -78,7 +75,7 @@ int ai::v3_AB_ordering::_search(
     Move best_move;
     for (const Move& move : moves) {
         Board tmp_board = b.make_move(move);
-        int tmp_eval = -_search(tmp_board, depth - 1, -beta, -alpha);
+        int tmp_eval = -_ab_search(tmp_board, depth - 1, -beta, -alpha);
         if (tmp_eval >= beta)
             return beta;
         alpha = std::max(alpha, tmp_eval);
@@ -86,8 +83,7 @@ int ai::v3_AB_ordering::_search(
     return alpha;
 }
 
-int ai::v3_AB_ordering::eval(const Board& b) {
-    position_counter++;
+int ai::v3_AB_ordering::_eval(const Board& b) {
     int white_eval = count_material(b, Colour::White);
     int black_eval = count_material(b, Colour::Black);
 

src/model/ais/v4_search_captures.cpp

@@ -6,10 +6,7 @@
 
 #define MULTITHREADED 1
 
-
-static int position_counter;
-
-int ai::v4_search_captures::_search(
+int ai::v4_search_captures::_ab_search(
     const Board& b, int depth, int alpha, int beta
 ) {
     if (depth == 0 || stop_computation)
@@ -29,7 +26,7 @@ int ai::v4_search_captures::_search(
     Move best_move;
     for (const Move& move : moves) {
         Board tmp_board = b.make_move(move);
-        int tmp_eval = -_search(tmp_board, depth - 1, -beta, -alpha);
+        int tmp_eval = -_ab_search(tmp_board, depth - 1, -beta, -alpha);
         if (tmp_eval >= beta)
             return beta;
         alpha = std::max(alpha, tmp_eval);

src/model/ais/v5_better_endgames.cpp

@@ -36,8 +36,8 @@ static float endgame_phase_weight(int material_count_no_pawns) {
     return 1.f - std::min(1.f, material_count_no_pawns * multiplier);
 }
 
-int ai::v5_better_endgame::eval(const Board& b) {
-    int old_eval = v4_search_captures::eval(b);
+int ai::v5_better_endgame::_eval(const Board& b) {
+    int old_eval = v4_search_captures::_eval(b);
     Colour attacking_colour = b.white_to_play ? White : Black;
     Colour defending_colour = b.white_to_play ? Black : White;
     return old_eval

src/model/ais/v6_iterative_deepening.cpp

@@ -0,0 +1,42 @@
+#include "../pieces/piece.hpp"
+#include "../utils/threadpool.hpp"
+#include "../utils/utils.hpp"
+#include "ai.hpp"
+
+#include <map>
+
+static int position_counter = 0;
+
+Move ai::v6_iterative_deepening::_search(const Board& b) {
+    ThreadPool pool(std::thread::hardware_concurrency());
+    std::vector<Move> moves = b.all_legal_moves();
+
+    Move best_move;
+    int best_eval = -INFINITY;
+
+    std::map<Move, std::future<int>> futures;
+    for (int depth = 1; !stop_computation; depth++) {
+        for (const Move& move : moves) {
+            Board tmp_board = b.make_move(move);
+            futures.insert(
+                {move, pool.enqueue([&, tmp_board]() {
+                     return _ab_search(tmp_board, depth, -INFINITY, INFINITY);
+                 })}
+            );
+        }
+
+        int counter = 0;
+        for (auto& [move, future] : futures) {
+            int eval = future.get();
+            counter++;
+            if (!am_white)
+                eval *= -1;
+            if (eval > best_eval) {
+                best_eval = eval;
+                best_move = move;
+            }
+        }
+        futures.clear();
+    }
+    return best_move;
+}