Makefile

@@ -28,8 +28,8 @@ obj/%.o:
 	@mkdir -p $(dir $@)
 	$(CXX) $(CXXFLAGS) -o $@ -c $<
 
-stickfosh: $(OBJFILES)
+main: $(OBJFILES)
-	$(CXX) $(CXXFLAGS) $(OBJFILES) $(LOADLIBES) $(LDLIBS) -o stickfosh -lsfml-graphics -lsfml-window -lsfml-system
+	$(CXX) $(CXXFLAGS) $(OBJFILES) $(LOADLIBES) $(LDLIBS) -o main -lsfml-graphics -lsfml-window -lsfml-system
 
 clean:
 	rm -rf obj/* $(DEPFILES) test_bin/

README.md

@@ -1,86 +1,3 @@
 # Stickfosh
 
-> [Stockfish](https://stockfishchess.org), but worse :)
+> Stockfish, but worse :)
-
-## Overview
-
-This project is a **Chess AI** built using the **Model-View-Controller (MVC)
-pattern**. It provides a modular framework for playing chess, allowing both
-**human vs AI** and **AI vs AI** matches. The AI has undergone several
-iterations, improving its decision-making capabilities through enhancements like
-**alpha-beta pruning**, **move ordering**, **iterative deepening**, and
-**transposition tables**.
-
-## Features
-
-- **MVC Architecture**: The project follows the MVC pattern for clean separation of concerns:
-  - **Model**: Handles chess rules, board state, and AI logic.
-  - **View**: GUI and NoOp (that shows nothing, but is useful for debugging the AIs) rendering options.
-  - **Controller**: Manages interactions between players and the game.
-- **Multiple AI Versions**: Several AI versions with increasing complexity have been implemented.
-- **AI vs AI Matches**: A dedicated mode to watch different AI versions compete.
-- **Human vs AI Mode**: Play against the AI using a graphical interface.
-- **FEN Support**: Load chess positions using FEN notation.
-- **Performance Testing (Perft)**: Built-in performance testing for move generation.
-
-## AI Iterations
-
-This project has undergone multiple AI improvements, including:
-
-1. **v0 Random AI**: Selects moves randomly.
-1. **v1 Pure Minimax**: Implements basic minimax search.
-1. **v2 Alpha-Beta Pruning**: Optimizes minimax with pruning.
-1. **v3 Move Ordering**: Prioritizes moves to improve search efficiency.
-1. **v4 Search Captures**: Enhances move ordering by focusing on captures.
-1. **v5 Better Endgame**: Introduces heuristics for endgame play.
-1. **v6 Iterative Deepening**: Dynamically adjusts search depth for better performance.
-1. **v7 Transposition Tables**: Caches board states to reduce redundant computations.
-
-## Installation & Usage
-
-### Prerequisites
-
-- C++ Compiler (C++17 or later)
-- `make`
-- SFML (for GUI rendering)
-
-### Build Instructions
-
-1. Clone the repository:
-   ```sh
-   git clone https://github.com/karma-riuk/stickfosh.git
-   cd stickfosh
-   ```
-1. Create a build directory and compile:
-   ```sh
-   make stickfosh
-   ```
-1. Run the program:
-   ```sh
-   ./stickfosh
-   ```
-
-## Running the Application
-
-Stickfosh provides multiple execution modes, selectable via command-line arguments:
-
-| Mode | Description | Example Command |
-|------|------------|----------------|
-| **Human vs AI** | Play against the AI | `./stickfosh --mode human_vs_ai` |
-| **AI vs AI** | Watch two AI versions compete | `./stickfosh --mode ai_vs_ai --ai1 v3_AB_ordering --ai2 v6_iterative_deepening` |
-| **Human vs Human** | Manually input moves for both sides | `./stickfosh --mode human_vs_human` |
-| **Perft Testing** | Performance test move generation | `./stickfosh --mode perft` |
-| **Custom FEN** | Start from a custom position | `./stickfosh --mode ai_vs_ai --fen "rnbqkb1r/pppppppp/8/8/8/8/PPPPPPPP/RNBQKB1R w KQkq - 0 1"` |
-
-## Video Demo
-
-<!-- [![AI vs AI Chess Match](https://img.youtube.com/vi/XXXXXXXXXX/0.jpg)](https://www.youtube.com/watch?v=XXXXXXXXXX) -->
-
-<!-- *Click the image above to watch a video of two AI versions competing!* -->
-
-## Future Improvements
-
-- Implement **opening book** for better early-game decisions.
-- Enhance **evaluation function** with more advanced heuristics.
-- Introduce **neural network-based AI** for machine-learning-driven play.
-- Introduce **Monte-Carlo Tree Search** for stochastic driven play.

src/main.cpp

@@ -9,73 +9,33 @@
 #include "view/view.hpp"
 
 #include <chrono>
-#include <iostream>
-#include <string>
-
-void print_usage() {
-    std::cout << "Usage: chess_ai [OPTIONS]\n";
-    std::cout << "Options:\n";
-    std::cout
-        << "  --mode <human_vs_ai|ai_vs_ai|human_vs_human|perft>  Choose the "
-           "game mode.\n";
-    std::cout << "  --ai1 <version>  Choose the first AI version (for ai_vs_ai "
-                 "mode).\n";
-    std::cout << "  --ai2 <version>  Choose the second AI version (for "
-                 "ai_vs_ai mode).\n";
-    std::cout << "  --fen <FEN_STRING>  Set a custom FEN position.\n";
-    std::cout << "  --help  Show this help message.\n";
-}
 
 int main(int argc, char* argv[]) {
-    std::string mode = "human_vs_ai";
+    // std::string pos =
-    std::string ai1_version = "v0_random";
+    //     "r2qkb1r/2p1pppp/p1n1b3/1p6/B2P4/2P1P3/P4PPP/R1BQK1NR w KQkq - 0 9 ";
-    std::string ai2_version = "v6_iterative_deepening";
+    // std::string pos = "8/6K1/5P2/8/1k6/8/8/8 w - - 0 1";
-    std::string fen =
-        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
-    for (int i = 1; i < argc; ++i) {
+    // pos for ai timing<
-        std::string arg = argv[i];
+    std::string pos =
-        if (arg == "--mode" && i + 1 < argc) {
+        "r3k2r/p1ppqpb1/Bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPB1PPP/R3K2R b KQkq - 0 3";
-            mode = argv[++i];
-        } else if (arg == "--ai1" && i + 1 < argc) {
-            ai1_version = argv[++i];
-        } else if (arg == "--ai2" && i + 1 < argc) {
-            ai2_version = argv[++i];
-        } else if (arg == "--fen" && i + 1 < argc) {
-            fen = argv[++i];
-        } else if (arg == "--help") {
-            print_usage();
-            return 0;
-        } else {
-            std::cerr << "Unknown option: " << arg << "\n";
-            print_usage();
-            return 1;
-        }
-    }
 
-    Board board = Board::setup_fen_position(fen);
+    Board b = Board::setup_fen_position(pos);
-    GUI gui;
-    Controller* controller = nullptr;
 
-    if (mode == "human_vs_ai") {
+    ai::v0_random p1(true, std::chrono::milliseconds(1000));
-        ai::v6_iterative_deepening ai(false, std::chrono::milliseconds(2000));
+    // ai::v1_pure_minimax p2(false, std::chrono::milliseconds(20000));
-        controller = new HumanVsAIController(board, gui, ai);
+    // ai::v2_alpha_beta p2(false, std::chrono::milliseconds(20000));
-    } else if (mode == "ai_vs_ai") {
+    ai::v3_AB_ordering p2(false, std::chrono::milliseconds(20000));
-        ai::v0_random p1(true, std::chrono::milliseconds(1000));
+    // ai::v4_search_captures p2(false, std::chrono::milliseconds(20000));
-        ai::v6_iterative_deepening p2(false, std::chrono::milliseconds(2000));
-        controller = new AIvsAIController(board, gui, p1, p2);
-    } else if (mode == "human_vs_human") {
-        controller = new ManualController(board, gui);
-    } else if (mode == "perft") {
-        perft();
-        return 0;
-    } else {
-        std::cerr << "Invalid mode selected!\n";
-        print_usage();
-        return 1;
-    }
 
-    controller->start();
+    // GUI gui;
-    delete controller;
+    NoOpView gui;
+    AIvsAIController manual(b, gui, p1, p2);
+    // HumanVsAIController manual(b, gui, p2);
+
+    Controller& controller = manual;
+
+    controller.start();
+
+    // perft();
     return 0;
 }

src/model/ais/ai.cpp

@@ -4,10 +4,7 @@
 #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;
@@ -50,13 +47,6 @@ Move ai::AI::search(const Board& b) {
     // Ensure timer thread is also stopped
     timer_thread.join();
 
-    std::cout << "Took " << elapsed << " ms, " << "Looked at "
+    std::cout << "Took " << elapsed << " ms" << std::endl;
-              << 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,9 +20,8 @@ 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 {
@@ -30,7 +29,7 @@ namespace ai {
 
         Move _search(const Board&) override;
 
-        int _eval(const Board&) override {
+        int eval(const Board&) override {
             return 0;
         };
     };
@@ -42,63 +41,39 @@ 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)
-        virtual int _search(const Board&, int, int, int);
+        int _search(const Board&, int, int, int);
 
       public:
         v2_alpha_beta(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
 
-        virtual Move _search(const Board&) override;
+        Move _search(const Board&) override;
-        virtual int _eval(const Board&) override;
+        int eval(const Board&) override;
     };
 
     class v3_AB_ordering : public AI {
         // looks two moves ahead, with alpha-beta pruning, with move ordering
-        virtual int _ab_search(const Board&, int, int, int);
+        virtual int _search(const Board&, int, int, int);
 
       public:
         v3_AB_ordering(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
 
-        virtual Move _search(const Board&) override;
+        Move _search(const Board&) override;
-        virtual int _eval(const Board&) override;
+        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
-        virtual int _ab_search(const Board&, int, int, int) override;
+        int _search(const Board&, int, int, int) override;
-        virtual int _search_captures(const Board&, int, int);
+        int _search_captures(const Board&, int, int);
 
       public:
         v4_search_captures(bool w, std::chrono::milliseconds tt)
             : v3_AB_ordering(w, tt) {}
     };
-
-    class v5_better_endgame : public v4_search_captures {
-        // same as v4, but with a better evaluation function, that forces the
-        // king towards the corner of the board for endgames
-
-      public:
-        v5_better_endgame(bool w, std::chrono::milliseconds tt)
-            : v4_search_captures(w, tt) {}
-
-        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,7 +7,10 @@
 
 #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;
@@ -49,6 +52,7 @@ Move ai::v1_pure_minimax::_search(const Board& b) {
         }
     }
 #endif
+    std::cout << "Looked at " << position_counter << " positions" << std::endl;
     return best_move;
 }
 
@@ -74,7 +78,8 @@ int ai::v1_pure_minimax::_search(const Board& b, int depth) {
     return best_evaluation;
 }
 
-int ai::v1_pure_minimax::_eval(const Board& b) {
+int ai::v1_pure_minimax::eval(const Board& b) {
+    position_counter++;
     int white_eval = count_material(b, Colour::White);
     int black_eval = count_material(b, Colour::Black);
 

src/model/ais/v2_alpha_beta.cpp

@@ -7,7 +7,11 @@
 
 #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;
@@ -49,6 +53,7 @@ Move ai::v2_alpha_beta::_search(const Board& b) {
         }
     }
 #endif
+    std::cout << "Looked at " << position_counter << " positions" << std::endl;
     return best_move;
 }
 
@@ -74,7 +79,8 @@ 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) {
+int ai::v2_alpha_beta::eval(const Board& b) {
+    position_counter++;
     int white_eval = count_material(b, Colour::White);
     int black_eval = count_material(b, Colour::Black);
 

src/model/ais/v3_AB_ordering.cpp

@@ -8,14 +8,12 @@
 
 #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();
-    std::sort(moves.begin(), moves.end(), [&](Move& m1, Move& m2) {
-        int score = m1.score_guess(b) - m2.score_guess(b);
-        if (!am_white)
-            score *= -1;
-        return score < 0;
-    });
 
     Move best_move;
     int best_eval = -INFINITY;
@@ -27,11 +25,9 @@ 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(
+        futures.insert({move, pool.enqueue([&, tmp_board]() {
-            {move, pool.enqueue([&, tmp_board]() {
+                            return _search(tmp_board, 3, -INFINITY, INFINITY);
-                 return _ab_search(tmp_board, 3, -INFINITY, INFINITY);
+                        })});
-             })}
-        );
     }
 
     int counter = 0;
@@ -58,10 +54,11 @@ 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::_ab_search(
+int ai::v3_AB_ordering::_search(
     const Board& b, int depth, int alpha, int beta
 ) {
     if (depth == 0 || stop_computation)
@@ -75,16 +72,13 @@ int ai::v3_AB_ordering::_ab_search(
 
     std::vector<Move> moves = b.all_legal_moves();
     std::sort(moves.begin(), moves.end(), [&](Move& m1, Move& m2) {
-        int score = m1.score_guess(b) - m2.score_guess(b);
+        return m1.score_guess(b) > m2.score_guess(b);
-        if (!am_white)
-            score *= -1;
-        return score < 0;
     });
 
     Move best_move;
     for (const Move& move : moves) {
         Board tmp_board = b.make_move(move);
-        int tmp_eval = -_ab_search(tmp_board, depth - 1, -beta, -alpha);
+        int tmp_eval = -_search(tmp_board, depth - 1, -beta, -alpha);
         if (tmp_eval >= beta)
             return beta;
         alpha = std::max(alpha, tmp_eval);
@@ -92,7 +86,8 @@ int ai::v3_AB_ordering::_ab_search(
     return alpha;
 }
 
-int ai::v3_AB_ordering::_eval(const Board& b) {
+int ai::v3_AB_ordering::eval(const Board& b) {
+    position_counter++;
     int white_eval = count_material(b, Colour::White);
     int black_eval = count_material(b, Colour::Black);
 

src/model/ais/v4_search_captures.cpp

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

@@ -1,52 +0,0 @@
-#include "../pieces/piece.hpp"
-#include "../utils/utils.hpp"
-#include "ai.hpp"
-
-#include <algorithm>
-
-static int force_king_to_corner(
-    int8_t attacking_king, int8_t defending_king, float endgame_weight
-) {
-    int eval = 0;
-    Coords def_xy = Coords::from_index(defending_king);
-
-    Coords def_dist_to_center{
-        std::max(3 - def_xy.x, def_xy.x - 4),
-        std::max(3 - def_xy.y, def_xy.y - 4)
-    };
-    eval += def_dist_to_center.x + def_dist_to_center.y;
-
-    // make attacking king go closer to defending king to cut off escape routes
-    Coords attack_xy = Coords::from_index(attacking_king);
-    Coords dist_between_kings{
-        std::abs(attack_xy.x - def_xy.x),
-        std::abs(attack_xy.y - def_xy.y)
-    };
-    int distance = dist_between_kings.x + dist_between_kings.y;
-    eval += 14 - distance;
-
-    return (int) (eval * 10 * endgame_weight);
-}
-
-static float endgame_phase_weight(int material_count_no_pawns) {
-    static int endgame_material_start =
-        RookValue * 2 + BishopValue + KnightValue;
-
-    float multiplier = 1.f / endgame_material_start;
-    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);
-    Colour attacking_colour = b.white_to_play ? White : Black;
-    Colour defending_colour = b.white_to_play ? Black : White;
-    return old_eval
-         + force_king_to_corner(
-               b.get_king_of(attacking_colour),
-               b.get_king_of(defending_colour),
-               endgame_phase_weight(
-                   count_material(b, attacking_colour, false)
-                   + count_material(b, defending_colour, false)
-               )
-         );
-}

src/model/ais/v6_iterative_deepening.cpp

@@ -1,43 +0,0 @@
-#include "../pieces/piece.hpp"
-#include "../utils/threadpool.hpp"
-#include "../utils/utils.hpp"
-#include "ai.hpp"
-
-#include <map>
-
-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;
-    int depth;
-    for (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();
-    }
-
-    std::cout << "Went up until depth: " << depth << std::endl;
-    return best_move;
-}

src/model/board/board.hpp

@@ -8,6 +8,7 @@
 
 struct Board {
   private:
+    int8_t get_king_of(int8_t) const;
     bool _no_legal_moves_for(Colour) const;
     bool _is_check_for(Colour) const;
     bool nlm = false, check = false;
@@ -24,7 +25,6 @@ struct Board {
 
     static Board setup_fen_position(std::string fen);
 
-    int8_t get_king_of(int8_t) const;
     Board skip_turn() const;
     Board make_move(Move, bool = true) const;
     std::string to_fen() const;

src/model/utils/move.cpp

@@ -24,31 +24,3 @@ int Move::score_guess(const Board& b) const {
 
     return ret;
 }
-
-Move Move::from_string(std::string move) {
-    if (!(4 <= move.size() && move.size() <= 5))
-        throw std::invalid_argument("Move must be 4 or 5 characters long");
-    Move ret;
-    ret.source_square = Coords::from_algebraic(move.substr(0, 2)).to_index();
-    ret.target_square = Coords::from_algebraic(move.substr(2, 2)).to_index();
-    if (move.size() == 5)
-        switch (move[4]) {
-        case 'n':
-            ret.promoting_to = Knigt;
-            break;
-        case 'b':
-            ret.promoting_to = Bishop;
-            break;
-        case 'r':
-            ret.promoting_to = Rook;
-            break;
-        case 'q':
-            ret.promoting_to = Queen;
-            break;
-        default:
-            throw std::invalid_argument("Promotion piece must be one of 'nbrq'"
-            );
-        }
-    ret.target_square = Coords::from_algebraic(move.substr(2, 2)).to_index();
-    return ret;
-}

src/model/utils/move.hpp

@@ -15,8 +15,6 @@ struct Move {
 
     int score_guess(const Board&) const;
 
-    static Move from_string(std::string);
-
     std::string to_string() const {
         std::stringstream ss;
         ss << Coords::from_index(source_square)

src/model/utils/utils.cpp

@@ -26,13 +26,10 @@ int piece_value(Piece p) {
     }
 }
 
-int count_material(const Board& b, int8_t colour, bool count_pawns) {
+int count_material(const Board& b, int8_t colour) {
     int ret = 0;
-    for (int i = 0; i < 64; i++) {
+    for (int i = 0; i < 64; i++)
-        if (b.piece_at(i) == Pawn && !count_pawns)
-            continue;
         if (b.colour_at(i) == colour)
             ret += piece_value(b.piece_at(i));
-    }
     return ret;
 }

src/model/utils/utils.hpp

@@ -7,7 +7,7 @@
 #include <vector>
 
 std::vector<int8_t> to_target_square(std::vector<Move>);
-int count_material(const Board&, int8_t, bool = true);
+int count_material(const Board&, int8_t);
 int piece_value(Piece);
 
 const int INFINITY = std::numeric_limits<int>::max();

tests/move.cpp

@@ -1,13 +0,0 @@
-#include "../src/model/board/board.hpp"
-#include "lib.hpp"
-
-int main() {
-    std::string str_move = "a2a3";
-    ASSERT_EQUALS(str_move, Move::from_string(str_move).to_string());
-
-    str_move = "b2f4";
-    ASSERT_EQUALS(str_move, Move::from_string(str_move).to_string());
-
-    str_move = "a2a1r";
-    ASSERT_EQUALS(str_move, Move::from_string(str_move).to_string());
-}