updated the code of main

moves

.gitignore

@@ -171,4 +171,4 @@ cython_debug/
 .ruff_cache/
 
 # PyPI configuration file
-.pypirc
+.pypirc

cpp/.gitignore

@@ -0,0 +1,34 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.appobj/
+test_bin/
+main

cpp/Makefile

@@ -0,0 +1,58 @@
+CXXFLAGS += -O3 -Wall
+
+# Add .d to Make's recognized suffixes.
+SUFFIXES += .d
+
+#We don't need to clean up when we're making these targets
+NODEPS:=clean tags svn
+#Find all the C++ files in the src/ directory
+SOURCES:=$(shell find src/ -name "*.cpp")
+OBJFILES := $(patsubst src/%.cpp,obj/%.o,$(SOURCES))
+#These are the dependency files, which make will clean up after it creates them
+DEPFILES:=$(patsubst %.cpp,%.d,$(SOURCES))
+
+#Don't create dependencies when we're cleaning, for instance
+ifeq (0, $(words $(findstring $(MAKECMDGOALS), $(NODEPS))))
+	#Chances are, these files don't exist.  GMake will create them and
+	#clean up automatically afterwards
+	-include $(DEPFILES)
+endif
+
+#This is the rule for creating the dependency files
+src/%.d: src/%.cpp
+	$(CXX) $(CXXFLAGS) -MM -MT '$(patsubst src/%.cpp,obj/%.o,$<)' $< -MF $@
+
+#This rule does the compilation
+obj/%.o:
+	@mkdir -p $(dir $@)
+	$(CXX) $(CXXFLAGS) -o $@ -c $<
+
+main: $(OBJFILES)
+	$(CXX) $(LDFLAGS) $(OBJFILES) $(LOADLIBES) $(LDLIBS) -o main
+
+clean:
+	rm -rf obj/* $(DEPFILES) test_bin/
+
+
+# --- Test Support ---
+# Find all test source files in the tests directory
+TESTS := $(shell find tests -name "*.cpp")
+# Define corresponding test executable names, e.g. tests/foo.cpp -> test_bin/foo
+TEST_BIN := $(patsubst tests/%.cpp,test_bin/%,$(TESTS))
+LIBS := $(filter-out obj/main.o,$(OBJFILES))
+
+# Pattern rule: how to build a test executable from a test source file.
+# You can adjust CXXFLAGS or add include directories if needed.
+test_bin/%: tests/%.cpp $(LIBS)
+	@echo $(LIBS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CXXFLAGS) -o $@ $< $(LIBS)
+
+# The 'test' target builds all tests and then runs each one.
+.PHONY: test
+test: $(TEST_BIN)
+	@echo "Running all tests..."
+	@for t in $(TEST_BIN); do \
+	    echo "---- Running $$t ----"; \
+	    ./$$t || exit 1; \
+	done

cpp/src/ais/ai.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "../board.hpp"
+
+#include <string>
+
+#define DECLARE_AI(x)                                                          \
+    struct x : public AI {                                                     \
+        std::string search(std::string, int) override;                         \
+        int minimax(const Board&, int) override;                               \
+        int eval(const Board&) override;                                       \
+    };
+
+namespace ai {
+    struct AI {
+        virtual std::string search(std::string, int) = 0;
+        virtual int minimax(const Board&, int) = 0;
+        virtual int eval(const Board&) = 0;
+    };
+
+    DECLARE_AI(v0_random)
+    DECLARE_AI(v1_simple)
+} // namespace ai

cpp/src/ais/v0_random.cpp

@@ -0,0 +1,8 @@
+#include "ai.hpp"
+
+std::string ai::v1_simple::search(std::string pos, int depth) {
+    Board b = Board::setup_fen_position(pos);
+    std::vector<Move> moves = b.all_legal_moves();
+
+    return moves[rand() % moves.size()].to_string();
+}

cpp/src/ais/v1_simple.cpp

@@ -0,0 +1,97 @@
+#include "../pieces/piece.hpp"
+#include "../threadpool.hpp"
+#include "ai.hpp"
+
+#include <future>
+#include <map>
+
+static int INFINITY = std::numeric_limits<int>::max();
+
+std::string ai::v1_simple::search(std::string pos, int depth) {
+    Board b = Board::setup_fen_position(pos);
+
+    ThreadPool pool(std::thread::hardware_concurrency());
+
+    std::vector<Move> moves = b.all_legal_moves();
+    std::map<std::string, std::future<int>> futures;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        futures.insert(
+            {move.to_string(), pool.enqueue([this, tmp_board, depth]() {
+                 return minimax(tmp_board, depth - 1);
+             })}
+        );
+    }
+
+    std::string best_move;
+    int best_eval = -INFINITY;
+    for (auto& [move, future] : futures) {
+        int eval = future.get();
+        if (eval > best_eval) {
+            best_eval = eval;
+            best_move = move;
+        }
+    }
+
+    return best_move;
+}
+
+int ai::v1_simple::minimax(const Board& b, int depth) {
+    if (b.is_checkmate_for(b.white_to_play ? White : Black))
+        return -INFINITY;
+
+    if (depth == 0)
+        return eval(b);
+
+    std::vector<Move> moves = b.all_legal_moves();
+    int best_evaluation = 0;
+    Move best_move;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        int tmp_eval = -minimax(tmp_board, depth - 1);
+        best_evaluation = std::max(best_evaluation, tmp_eval);
+    }
+    return best_evaluation;
+}
+
+static int PawnValue = 100;
+static int KnightValue = 300;
+static int BishopValue = 320;
+static int RookValue = 500;
+static int QueenValue = 900;
+
+int count_material(const Board& b, int8_t colour) {
+    int ret = 0;
+    for (int i = 0; i < 64; i++) {
+        if (b.colour_at(i) == colour)
+            switch (b.squares[i] & 0b111) {
+            case Piece::Pawn:
+                ret += PawnValue;
+                break;
+            case Piece::Knigt:
+                ret += KnightValue;
+                break;
+            case Piece::Bishop:
+                ret += BishopValue;
+                break;
+            case Piece::Rook:
+                ret += RookValue;
+                break;
+            case Piece::Queen:
+                ret += QueenValue;
+                break;
+            }
+    }
+    return ret;
+}
+
+int ai::v1_simple::eval(const Board& b) {
+    int white_eval = count_material(b, Colour::White);
+    int black_eval = count_material(b, Colour::Black);
+
+    int evaluation = white_eval - black_eval;
+
+    int perspective = b.white_to_play ? 1 : -1;
+
+    return perspective * evaluation;
+}

cpp/src/board.cpp

@@ -0,0 +1,343 @@
+#include "board.hpp"
+
+#include "coords.hpp"
+#include "move.hpp"
+#include "pieces/piece.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <map>
+#include <stdexcept>
+
+Board Board::setup_fen_position(std::string fen) {
+    Board board;
+    std::map<char, Piece> c2p{
+        {'k', Piece::King},
+        {'p', Piece::Pawn},
+        {'n', Piece::Knigt},
+        {'b', Piece::Bishop},
+        {'r', Piece::Rook},
+        {'q', Piece::Queen},
+    };
+
+    // -- Pieces
+    std::string fen_board = fen.substr(0, fen.find(' '));
+    int rank = 7, file = 0;
+    for (char symbol : fen_board) {
+        if (symbol == '/') {
+            file = 0;
+            rank--;
+            continue;
+        }
+
+        if (std::isdigit(symbol))
+            file += symbol - '0';
+        else {
+            Colour colour =
+                std::isupper(symbol) ? Colour::White : Colour::Black;
+
+            Piece piece = c2p[std::tolower(symbol)];
+            board.squares[rank * 8 + file] = colour | piece;
+            file++;
+        }
+    }
+
+    // -- Active colour
+    int index = fen.find(' ');
+    index++;
+    board.white_to_play = fen[index] == 'w';
+
+    // Castling Rights
+    index += 2;
+    for (char symbol : fen.substr(index, fen.find(' ', index + 1))) {
+        index++;
+        if (symbol == ' ' || symbol == '-') {
+            if (symbol == '-')
+                index++;
+            break;
+        }
+
+        switch (symbol) {
+        case 'K':
+            board.w_castle_rights |= CastleSide::KingSide;
+            break;
+        case 'Q':
+            board.w_castle_rights |= CastleSide::QueenSide;
+            break;
+        case 'k':
+            board.b_castle_rights |= CastleSide::KingSide;
+            break;
+        case 'q':
+            board.b_castle_rights |= CastleSide::QueenSide;
+            break;
+        }
+    }
+
+    // -- En passant target
+    if (fen[index] != '-') {
+        Coords c = Coords::from_algebraic(fen.substr(index, 2));
+        index += 2;
+        board.en_passant_target = c.to_index();
+    } else {
+        index++;
+    }
+
+    // -- Half move clock
+    index = fen.find(' ', index) + 1;
+    board.n_half_moves =
+        std::stoi(fen.substr(index, fen.find(' ', index + 1) - index));
+
+    // -- Full move number
+    index = fen.find(' ', index) + 1;
+    board.n_full_moves = std::stoi(fen.substr(index));
+
+
+    return board;
+}
+
+std::string Board::to_fen() const {
+    std::map<int, char> p2c{
+        {Piece::King, 'k'},
+        {Piece::Pawn, 'p'},
+        {Piece::Knigt, 'n'},
+        {Piece::Bishop, 'b'},
+        {Piece::Rook, 'r'},
+        {Piece::Queen, 'q'},
+    };
+
+    std::string ret;
+    // -- Pieces
+    for (int rank = 7; rank >= 0; rank--) {
+        int empty_cell_counter = 0;
+        for (int file = 0; file < 8; file++) {
+            if (squares[rank * 8 + file] == Piece::None) {
+                empty_cell_counter++;
+                continue;
+            }
+
+            int full_piece = squares[rank * 8 + file];
+            char piece = p2c[full_piece & 0b111];
+            int8_t colour = colour_at({file, rank});
+
+            if (empty_cell_counter > 0) {
+                ret += std::to_string(empty_cell_counter);
+                empty_cell_counter = 0;
+            }
+            ret += colour == Colour::White ? std::toupper(piece) : piece;
+        }
+        if (empty_cell_counter > 0)
+            ret += std::to_string(empty_cell_counter);
+        if (rank > 0)
+            ret += "/";
+    }
+    ret += " ";
+
+    // -- Active colour
+    ret += white_to_play ? 'w' : 'b';
+    ret += " ";
+
+    // -- Castling Rights
+    if (w_castle_rights == CastleSide::NeitherSide
+        && b_castle_rights == CastleSide::NeitherSide)
+        ret += '-';
+    else {
+        if (w_castle_rights & CastleSide::KingSide)
+            ret += 'K';
+        if (w_castle_rights & CastleSide::QueenSide)
+            ret += 'Q';
+        if (b_castle_rights & CastleSide::KingSide)
+            ret += 'k';
+        if (b_castle_rights & CastleSide::QueenSide)
+            ret += 'q';
+    }
+    ret += ' ';
+
+    // -- En passant target
+    ret += en_passant_target == -1
+             ? "-"
+             : Coords::from_index(en_passant_target).to_algebraic();
+    ret += ' ';
+
+    // -- Half move clock
+    ret += std::to_string(n_half_moves);
+    ret += ' ';
+
+    // -- Full moves number
+    ret += std::to_string(n_full_moves);
+
+    return ret;
+}
+
+Board Board::make_move(Move move) const {
+    Board ret;
+    std::copy(
+        std::begin(this->squares),
+        std::end(this->squares),
+        std::begin(ret.squares)
+    );
+    ret.white_to_play = !this->white_to_play;
+
+    // -- Actually make the move
+    ret.squares[move.source_square] = Piece::None;
+    ret.squares[move.target_square] = this->squares[move.source_square];
+
+    // -- Handle en passant target being eaten
+    if (en_passant_target != -1
+        && (squares[move.source_square] & 0b111) == Piece::Pawn
+        && squares[move.target_square] == Piece::None)
+        ret.squares[move.target_square + (white_to_play ? -8 : 8)] =
+            Piece::None;
+
+    // -- Handle promotion
+    if (move.promoting_to != Piece::None)
+        ret.squares[move.target_square] = move.promoting_to;
+
+    // -- Set en passant target if need
+    if ((squares[move.source_square] & 0b111) == Piece::Pawn
+        && std::abs(move.target_square - move.source_square) == 16) {
+        if (white_to_play)
+            ret.en_passant_target = move.target_square - 8;
+        else
+            ret.en_passant_target = move.target_square + 8;
+    } else {
+        ret.en_passant_target = -1;
+    }
+
+    // -- Handle castling (just move the rook over)
+    Coords c = Coords::from_index(move.source_square);
+    if ((squares[move.source_square] & 0b111) == Piece::King) {
+        if (move.target_square - move.source_square == 2) { // king side castle
+            Coords rook_source{7, c.y};
+            int8_t old_rook = ret.squares[rook_source.to_index()];
+            ret.squares[rook_source.to_index()] = Piece::None;
+            Coords rook_dest{5, c.y};
+            ret.squares[rook_dest.to_index()] = old_rook;
+        } else if (move.target_square - move.source_square == -2) { // queen
+            Coords rook_source{0, c.y};
+            int8_t old_rook = ret.squares[rook_source.to_index()];
+            ret.squares[rook_source.to_index()] = Piece::None;
+            Coords rook_dest{3, c.y};
+            ret.squares[rook_dest.to_index()] = old_rook;
+        }
+    }
+
+    // -- Check for castling rights
+    ret.w_castle_rights = w_castle_rights;
+    ret.b_castle_rights = b_castle_rights;
+    bool is_capturing = squares[move.target_square] != Piece::None;
+    if (white_to_play) {
+        if ((squares[move.source_square] & 0b111) == King)
+            ret.w_castle_rights = NeitherSide;
+
+        if ((squares[move.source_square] & 0b111) == Rook) {
+            if (c.x == 0 && (ret.w_castle_rights & QueenSide))
+                ret.w_castle_rights &= ~(QueenSide);
+            if (c.x == 7 && (ret.w_castle_rights & KingSide))
+                ret.w_castle_rights &= ~(KingSide);
+        }
+
+        Coords target = Coords::from_index(move.target_square);
+        if (is_capturing && target.y == 7
+            && (squares[move.target_square] & 0b111) == Rook) {
+            if (target.x == 0 && (ret.b_castle_rights & QueenSide))
+                ret.b_castle_rights &= ~(QueenSide);
+            if (target.x == 7 && (ret.b_castle_rights & KingSide))
+                ret.b_castle_rights &= ~(KingSide);
+        }
+    } else {
+        if ((squares[move.source_square] & 0b111) == King)
+            ret.b_castle_rights = NeitherSide;
+
+        if ((squares[move.source_square] & 0b111) == Rook) {
+            if (c.x == 0 && (ret.b_castle_rights & QueenSide))
+                ret.b_castle_rights &= ~(QueenSide);
+            if (c.x == 7 && (ret.b_castle_rights & KingSide))
+                ret.b_castle_rights &= ~(KingSide);
+        }
+
+        Coords target = Coords::from_index(move.target_square);
+        if (is_capturing && target.y == 0
+            && (squares[move.target_square] & 0b111) == Rook) {
+            if (target.x == 0 && (ret.w_castle_rights & QueenSide))
+                ret.w_castle_rights &= ~(QueenSide);
+            if (target.x == 7 && (ret.w_castle_rights & KingSide))
+                ret.w_castle_rights &= ~(KingSide);
+        }
+    }
+
+    return ret;
+}
+
+int8_t Board::get_king_of(int8_t colour) const {
+    for (int i = 0; i < 64; i++)
+        if (squares[i] == (colour | Piece::King))
+            return i;
+    throw std::domain_error(
+        "Apparently there no kings of the such color in this board"
+    );
+}
+
+std::vector<int8_t> to_target_square(std::vector<Move> moves) {
+    std::vector<int8_t> ret;
+    for (Move move : moves)
+        ret.push_back(move.target_square);
+    return ret;
+}
+
+bool Board::is_check_for(int8_t colour) const {
+    int8_t king_idx = this->get_king_of(colour);
+    for (int i = 0; i < 64; i++) {
+        if (this->squares[i] == Piece::None || colour_at(i) == colour)
+            continue;
+        std::vector<int8_t> targets;
+        if ((squares[i] & 0b00111) == King) {
+            // special case for the king, because it creates infinite recursion
+            // (since he looks if he's walking into a check)
+            Coords king_pos = Coords::from_index(i);
+            for (int dx = -1; dx <= 1; dx++) {
+                for (int dy = -1; dy <= 1; dy++) {
+                    Coords c{king_pos.x + dx, king_pos.y + dy};
+                    if (c.is_within_bounds())
+                        targets.push_back(c.to_index());
+                }
+            }
+        } else {
+            std::vector<Move> moves = legal_moves(
+                this->squares[i],
+                *this,
+                Coords::from_index(i),
+                true
+            );
+            targets = to_target_square(moves);
+        }
+        if (std::find(targets.begin(), targets.end(), king_idx)
+            != targets.end())
+            return true;
+    }
+    return false;
+}
+
+bool Board::no_legal_moves_for(int8_t colour) const {
+    for (int i = 0; i < 64; i++) {
+        if (colour_at(i) == colour) {
+            std::vector<Move> moves =
+                legal_moves(squares[i], *this, Coords::from_index(i));
+            if (moves.size() > 0)
+                return false;
+        }
+    }
+    return true;
+}
+
+std::vector<Move> Board::all_legal_moves() const {
+    std::vector<Move> ret;
+    for (int i = 0; i < 64; i++) {
+        if ((colour_at(i) == White && white_to_play)
+            || (colour_at(i) == Black && !white_to_play)) {
+            std::vector<Move> moves =
+                legal_moves(squares[i], *this, Coords::from_index(i));
+            ret.insert(ret.end(), moves.begin(), moves.end());
+        }
+    }
+    return ret;
+}

cpp/src/board.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "coords.hpp"
+#include "move.hpp"
+#include "pieces/piece.hpp"
+
+#include <string>
+
+struct Board {
+  private:
+    int8_t get_king_of(int8_t) const;
+    bool no_legal_moves_for(int8_t) const;
+
+  public:
+    int8_t squares[64] = {Piece::None};
+    bool white_to_play = true;
+    int8_t w_castle_rights = CastleSide::NeitherSide;
+    int8_t b_castle_rights = CastleSide::NeitherSide;
+    int8_t en_passant_target = -1;
+    uint8_t n_half_moves = 0;
+    uint8_t n_full_moves = 0;
+
+    static Board setup_fen_position(std::string fen);
+
+    Board make_move(Move) const;
+    std::string to_fen() const;
+    bool is_check_for(int8_t) const;
+
+    std::vector<Move> all_legal_moves() const;
+
+    bool is_checkmate_for(int8_t colour) const {
+        return is_check_for(colour) && no_legal_moves_for(colour);
+    }
+
+    bool is_stalemate_for(int8_t colour) const {
+        return !is_check_for(colour) && no_legal_moves_for(colour);
+    }
+
+    bool is_terminal() const {
+        return is_checkmate_for(White) || is_checkmate_for(Black)
+            || is_stalemate_for(White) || is_stalemate_for(Black);
+    }
+
+    int8_t colour_at(int8_t idx) const {
+        return squares[idx] & 0b11000;
+    }
+
+    int8_t colour_at(Coords xy) const {
+        return colour_at(xy.to_index());
+    }
+};

cpp/src/castle_side.hpp

@@ -0,0 +1,7 @@
+#include <cstdint>
+
+enum CastleSide : int8_t {
+    NeitherSide = 0,
+    KingSide = 1,
+    QueenSide = 2,
+};

cpp/src/coords.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+static std::string _FILES = "abcdefgh";
+static std::string _RANKS = "12345678";
+
+struct Coords {
+    int x, y;
+
+    Coords(int x, int y): x(x), y(y) {}
+
+    int8_t to_index() const {
+        return this->y * 8 + this->x;
+    }
+
+    static Coords from_index(int idx) {
+        if (idx < 0 || idx > 63)
+            throw std::invalid_argument("The index is outside the board...");
+        return {idx % 8, idx / 8};
+    }
+
+    static Coords from_algebraic(std::string pos) {
+        if (pos.size() != 2)
+            throw std::invalid_argument(
+                "An algebraic coordinate should only have two characters"
+            );
+
+        size_t x = _FILES.find(pos[0]);
+        if (x == std::string::npos)
+            throw std::invalid_argument("The first character of the given "
+                                        "algebraic coordinate is invalid");
+
+        size_t y = _RANKS.find(pos[1]);
+        if (y == std::string::npos)
+            throw std::invalid_argument("The second character of the given "
+                                        "algebraic coordinate is invalid");
+
+        return Coords{(int) x, (int) y};
+    }
+
+    std::string to_algebraic() const {
+        std::string ret;
+        if (x > 7 || y > 7)
+            throw std::invalid_argument(
+                "Can't give the algebraic vesion of an invalid coord"
+            );
+        ret += _FILES[x];
+        ret += _RANKS[y];
+        return ret;
+    }
+
+    bool is_within_bounds() const {
+        return 0 <= x && x < 8 && 0 <= y && y < 8;
+    }
+};
+
+inline bool operator==(const Coords& a, const Coords& b) {
+    return a.x == b.x && a.y == b.y;
+}
+
+inline bool operator!=(const Coords& a, const Coords& b) {
+    return !(a == b);
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Coords& coords) {
+    os << coords.to_algebraic();
+    return os;
+}

cpp/src/main.cpp

@@ -0,0 +1,14 @@
+#include "ais/ai.hpp"
+
+#include <iostream>
+
+int main(int argc, char* argv[]) {
+    std::string pos =
+        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+
+    ai::v1_simple ai;
+
+    std::string move = ai.search(pos, 4);
+    std::cout << move << std::endl;
+    return 0;
+}

cpp/src/move.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "castle_side.hpp"
+#include "coords.hpp"
+#include "pieces/piece.hpp"
+
+#include <cstdint>
+#include <sstream>
+
+struct Move {
+    int8_t source_square;
+    int8_t target_square;
+
+    int8_t promoting_to = Piece::None;
+
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << Coords::from_index(source_square)
+           << Coords::from_index(target_square);
+        if (promoting_to != Piece::None) {
+            switch (promoting_to & 0b00111) {
+            case Queen:
+                ss << 'q';
+                break;
+            case Bishop:
+                ss << 'b';
+                break;
+            case Knigt:
+                ss << 'n';
+                break;
+            case Rook:
+                ss << 'r';
+                break;
+            default:
+                break;
+            }
+        }
+        return ss.str();
+    }
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Move& m) {
+    os << m.to_string();
+    return os;
+}

cpp/src/perft.cpp

@@ -0,0 +1,187 @@
+#include "perft.hpp"
+
+#include "board.hpp"
+#include "move.hpp"
+#include "threadpool.hpp"
+
+#include <chrono>
+#include <map>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+static std::string tick = "\033[92m✔️\033[0m";   // Green Tick;
+static std::string cross = "\033[91m❌\033[0m"; // Red Cross
+
+static std::map<std::string, std::map<int, int>> pos2expected{
+    // -- Position 1
+    {
+        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
+        {
+            {1, 20},     // 0
+            {2, 400},    // 1
+            {3, 8902},   // 38
+            {4, 197281}, // 971
+            // {5, 4865609}, // 23032
+        },
+    },
+
+    // -- Position 2
+    {
+        "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 2",
+        {
+            {1, 48},    // 0
+            {2, 2039},  // 16
+            {3, 97862}, // 602
+            // {4, 4085603}, // 26612
+        },
+    },
+
+    // -- Position 3
+    {
+        "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 3",
+        {
+            {1, 14},     // 0
+            {2, 191},    // 1
+            {3, 2812},   // 11
+            {4, 43238},  // 157
+            {5, 674624}, // 2199
+            // {6, 11030083},
+        },
+    },
+
+    // -- Position 4a
+    {
+        "r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 4",
+        {
+            {1, 6},      // 0
+            {2, 264},    // 1
+            {3, 9467},   // 69
+            {4, 422333}, // 3085
+            // {5, 15833292}, // 124452
+        },
+    },
+
+    // -- Position 4b
+    {
+        "r2q1rk1/pP1p2pp/Q4n2/bbp1p3/Np6/1B3NBn/pPPP1PPP/R3K2R b KQ - 0 5",
+        {
+            {1, 6},      // 0
+            {2, 264},    // 2
+            {3, 9467},   // 104
+            {4, 422333}, // 3742
+            // {5, 15833292}, // 136784
+        },
+    },
+
+    // -- Position 5
+    {
+        "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 6",
+        {
+            {1, 44},    // 0
+            {2, 1486},  // 12
+            {3, 62379}, // 357
+            // {4, 2103487}, // 13804
+            // {5, 89941194}, // 1230428
+        },
+    },
+
+    // -- Position 6
+    {
+        "r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 "
+        "7",
+        {
+            {1, 46},    // 0
+            {2, 2079},  // 16
+            {3, 89890}, // 602
+            // {4, 3894594}, // 26612
+            // {5, 164075551}, // 1230428
+        },
+    },
+};
+
+static std::stringstream res;
+
+int move_generation_test(
+    const Board& b, int depth, int max_depth, ThreadPool& pool
+) {
+    if (depth == max_depth) {
+        res.str("");
+        res.clear();
+    }
+
+    if (b.is_terminal())
+        return 0;
+    if (depth == 0)
+        return 1;
+
+    std::vector<Move> moves = b.all_legal_moves();
+    if (depth == 1)
+        return moves.size();
+
+    int num_pos = 0;
+
+    if (depth == max_depth) {
+        // Parallel execution at the top level
+        std::vector<std::future<int>> futures;
+        for (const Move& move : moves) {
+            Board tmp_board = b.make_move(move);
+            futures.push_back(pool.enqueue(
+                move_generation_test,
+                tmp_board,
+                depth - 1,
+                max_depth,
+                std::ref(pool)
+            ));
+        }
+
+        for (auto& future : futures)
+            num_pos += future.get(); // Retrieve the result of each task
+    } else {
+        // Regular sequential execution
+        for (const Move& move : moves) {
+            Board tmp_board = b.make_move(move);
+            int n = move_generation_test(tmp_board, depth - 1, max_depth, pool);
+            if (depth == max_depth)
+                res << move << ": " << n << std::endl;
+            num_pos += n;
+        }
+    }
+
+    return num_pos;
+}
+
+void perft() {
+    for (auto& [key, value] : pos2expected)
+        perft(key);
+}
+
+void perft(std::string pos) {
+    std::cout << pos << std::endl;
+    std::map<int, int> expected = pos2expected[pos];
+    Board b = Board::setup_fen_position(pos);
+    ThreadPool pool(std::thread::hardware_concurrency());
+
+    for (const auto& [depth, expected_n_moves] : expected) {
+        std::cout << "Depth: " << depth << " " << std::flush;
+        auto start = std::chrono::steady_clock::now();
+        int moves = move_generation_test(b, depth, depth, pool);
+        auto end = std::chrono::steady_clock::now();
+        auto elapsed =
+            std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
+                .count();
+
+        std::cout << "Results: " << moves << " ";
+        if (moves == expected_n_moves)
+            std::cout << tick << " ";
+        else
+            std::cout << cross << " (expected " << expected_n_moves << ") ";
+        std::cout << "positions Time: " << elapsed << " milliseconds"
+                  << std::endl;
+        if (moves != expected_n_moves) {
+            std::cout << std::endl << res.str();
+            exit(1);
+        }
+    }
+}

cpp/src/perft.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <string>
+
+void perft(std::string pos);
+void perft();

cpp/src/pieces/bishop.cpp

@@ -0,0 +1,23 @@
+#include "../board.hpp"
+#include "../coords.hpp"
+#include "../move.hpp"
+#include "piece.hpp"
+
+#include <vector>
+
+std::vector<Move> bishop_moves(const Board& b, const Coords xy) {
+    std::vector<Move> ret;
+    auto ne = look_direction(b, xy, 1, 1);
+    ret.insert(ret.end(), ne.begin(), ne.end());
+
+    auto se = look_direction(b, xy, 1, -1);
+    ret.insert(ret.end(), se.begin(), se.end());
+
+    auto sw = look_direction(b, xy, -1, -1);
+    ret.insert(ret.end(), sw.begin(), sw.end());
+
+    auto nw = look_direction(b, xy, -1, 1);
+    ret.insert(ret.end(), nw.begin(), nw.end());
+
+    return ret;
+}

cpp/src/pieces/king.cpp

@@ -0,0 +1,74 @@
+#include "../board.hpp"
+#include "../coords.hpp"
+#include "piece.hpp"
+
+static bool is_clear_king_side(const Board& b, const Coords xy) {
+    for (int dx = 1; dx < 3; dx++) {
+        Coords c{xy.x + dx, xy.y};
+        if (b.squares[c.to_index()] != Piece::None)
+            return false;
+
+        std::optional<Move> move = move_for_position(b, xy, c);
+        Board board_after_move = b.make_move(move.value());
+        if (board_after_move.is_check_for(b.colour_at(xy)))
+            return false;
+    }
+    return true;
+}
+
+static bool is_clear_queen_side(const Board& b, const Coords xy) {
+    for (int dx = 1; dx < 4; dx++) {
+        Coords c{xy.x - dx, xy.y};
+        if (b.squares[c.to_index()] != Piece::None)
+            return false;
+
+        std::optional<Move> move = move_for_position(b, xy, c);
+        Board board_after_move = b.make_move(move.value());
+        if (dx < 3 && board_after_move.is_check_for(b.colour_at(xy)))
+            return false;
+    }
+    return true;
+}
+
+std::vector<Move> king_moves(const Board& b, const Coords xy) {
+    std::vector<Move> ret;
+
+    // -- Regular moves
+    for (int dx = -1; dx <= 1; dx++) {
+        for (int dy = -1; dy <= 1; dy++) {
+            if (dx == 0 && dy == 0) // skip staying in the same position
+                continue;
+            Coords c{xy.x + dx, xy.y + dy};
+            std::optional<Move> move = move_for_position(b, xy, c);
+            if (move.has_value())
+                ret.push_back(move.value());
+        }
+    }
+
+    if (b.is_check_for(b.colour_at(xy)))
+        return keep_only_blocking(ret, b);
+
+    // -- Castles
+    int8_t castling_rights = b.colour_at(xy) == Colour::White
+                               ? b.w_castle_rights
+                               : b.b_castle_rights;
+
+    if (castling_rights == CastleSide::NeitherSide)
+        return ret;
+
+    if (castling_rights & CastleSide::KingSide && is_clear_king_side(b, xy)) {
+        ret.push_back(Move{
+            xy.to_index(),
+            Coords{6, xy.y}.to_index(),
+        });
+    }
+
+    if (castling_rights & CastleSide::QueenSide && is_clear_queen_side(b, xy)) {
+        ret.push_back(Move{
+            xy.to_index(),
+            Coords{2, xy.y}.to_index(),
+        });
+    }
+
+    return ret;
+}

cpp/src/pieces/knight.cpp

@@ -0,0 +1,28 @@
+#include "../board.hpp"
+#include "../coords.hpp"
+#include "../move.hpp"
+#include "piece.hpp"
+
+#include <vector>
+
+std::vector<Move> knight_moves(const Board& b, const Coords xy) {
+    std::vector<Move> ret;
+    std::vector<std::pair<int, int>> moves = {
+        {+2, +1},
+        {+1, +2}, // north east
+        {+2, -1},
+        {+1, -2}, // south east
+        {-2, -1},
+        {-1, -2}, // south west
+        {-2, +1},
+        {-1, +2} // north west
+    };
+
+    for (const auto& [dx, dy] : moves) {
+        std::optional<Move> move =
+            move_for_position(b, xy, Coords{xy.x + dx, xy.y + dy});
+        if (move.has_value())
+            ret.push_back(move.value());
+    }
+    return ret;
+}

cpp/src/pieces/pawn.cpp

@@ -0,0 +1,84 @@
+#include "../board.hpp"
+#include "../coords.hpp"
+#include "../move.hpp"
+#include "piece.hpp"
+
+std::vector<Move> pawn_moves(const Board& b, const Coords xy) {
+    std::vector<Move> ret{};
+    int8_t my_colour = b.colour_at(xy);
+
+    // -- Capture to the left
+    if (xy.x > 0) {
+        int dy = my_colour == Colour::White ? 1 : -1;
+        Coords left{xy.x - 1, xy.y + dy};
+        int8_t capturable_piece = b.squares[left.to_index()];
+        if (capturable_piece != 0) {
+            if (my_colour != b.colour_at(left))
+                if ((my_colour == White && left.y == 7)
+                    || (my_colour == Black && left.y == 0))
+
+                    for (auto piece : {Rook, Knigt, Bishop, Queen})
+                        ret.push_back(Move{
+                            xy.to_index(),
+                            left.to_index(),
+                            .promoting_to = (int8_t) (my_colour | piece)
+                        });
+                else
+                    ret.push_back(Move{xy.to_index(), left.to_index()});
+        }
+    }
+
+    // -- Capture to the right
+    if (xy.x < 7) {
+        int dy = my_colour == Colour::White ? 1 : -1;
+        Coords right{xy.x + 1, xy.y + dy};
+        int8_t capturable_piece = b.squares[right.to_index()];
+        if (capturable_piece != 0) {
+            if (my_colour != b.colour_at(right))
+                if ((my_colour == White && right.y == 7)
+                    || (my_colour == Black && right.y == 0))
+
+                    for (auto piece : {Rook, Knigt, Bishop, Queen})
+                        ret.push_back(Move{
+                            xy.to_index(),
+                            right.to_index(),
+                            .promoting_to = (int8_t) (my_colour | piece)
+                        });
+                else
+                    ret.push_back(Move{xy.to_index(), right.to_index()});
+        }
+    }
+
+    // -- Capture en passant
+    if (b.en_passant_target != -1) {
+        Coords c = Coords::from_index(b.en_passant_target);
+        int dy = my_colour == Colour::White ? 1 : -1;
+        if (c.y == xy.y + dy && (c.x == xy.x - 1 || c.x == xy.x + 1))
+            ret.push_back(Move{xy.to_index(), c.to_index()});
+    }
+
+    // -- Normal move + promotion
+    bool is_on_starting_rank =
+        my_colour == Colour::White ? xy.y == 1 : xy.y == 6;
+    int max_dy = is_on_starting_rank ? 3 : 2;
+    for (int dy = 1; dy < max_dy; dy++) {
+        int actual_dy = my_colour == Colour::White ? dy : -dy;
+        Coords new_xy{xy.x, xy.y + actual_dy};
+        if (b.squares[new_xy.to_index()] != Piece::None)
+            break;
+        if (new_xy.y == 7 || new_xy.y == 0)
+            for (auto piece : {Rook, Knigt, Bishop, Queen})
+                ret.push_back(Move{
+                    xy.to_index(),
+                    new_xy.to_index(),
+                    .promoting_to = (int8_t) (my_colour | piece)
+                });
+        else
+            ret.push_back(Move{
+                xy.to_index(),
+                new_xy.to_index(),
+            });
+    }
+
+    return ret;
+}

cpp/src/pieces/piece.cpp

@@ -0,0 +1,81 @@
+#include "piece.hpp"
+
+#include "../board.hpp"
+#include "../coords.hpp"
+
+std::vector<Move>
+keep_only_blocking(const std::vector<Move> candidates, const Board& board) {
+    if (candidates.size() == 0)
+        return {};
+
+    int8_t my_colour = board.colour_at(candidates[0].source_square);
+    std::vector<Move> ret;
+    for (Move move : candidates) {
+        Board board_after_move = board.make_move(move);
+        if (!board_after_move.is_check_for(my_colour))
+            ret.push_back(move);
+    }
+    return ret;
+}
+
+std::vector<Move>
+legal_moves(int8_t p, const Board& b, const Coords xy, bool looking_for_check) {
+    std::vector<Move> ret;
+    int8_t simple_piece = p & 0b00111;
+    switch (simple_piece) {
+    case Piece::Pawn:
+        ret = pawn_moves(b, xy);
+        break;
+    case Piece::Bishop:
+        ret = bishop_moves(b, xy);
+        break;
+    case Piece::Rook:
+        ret = rook_moves(b, xy);
+        break;
+    case Piece::Knigt:
+        ret = knight_moves(b, xy);
+        break;
+    case Piece::Queen:
+        ret = queen_moves(b, xy);
+        break;
+    case Piece::King:
+        ret = king_moves(b, xy);
+        break;
+    default:
+        break;
+    }
+
+    if (!looking_for_check)
+        return keep_only_blocking(ret, b);
+
+    return ret;
+}
+
+std::optional<Move>
+move_for_position(const Board& board, const Coords source, const Coords dest) {
+    if (!dest.is_within_bounds()
+        || board.colour_at(source) == board.colour_at(dest))
+        return {};
+
+    return Move{source.to_index(), dest.to_index()};
+}
+
+std::vector<Move>
+look_direction(const Board& board, const Coords xy, int mult_dx, int mult_dy) {
+    std::vector<Move> ret;
+    for (int d = 1; d < 8; d++) {
+        int dx = mult_dx * d;
+        int dy = mult_dy * d;
+
+        Coords target{xy.x + dx, xy.y + dy};
+        std::optional<Move> move = move_for_position(board, xy, target);
+        if (move.has_value()) {
+            ret.push_back(move.value());
+            if (board.squares[target.to_index()] != Piece::None)
+                break;
+        } else {
+            break;
+        }
+    }
+    return ret;
+}

cpp/src/pieces/piece.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <ostream>
+#include <vector>
+
+enum Piece : int8_t {
+    None = 0,
+    Rook = 1,
+    Knigt = 2,
+    Bishop = 3,
+    Queen = 4,
+    King = 5,
+    Pawn = 6,
+};
+
+enum Colour : int8_t {
+    White = 8,
+    Black = 16,
+};
+
+inline std::ostream& operator<<(std::ostream& os, const int8_t& i) {
+    os << std::to_string(i);
+    return os;
+}
+
+class Board;
+struct Coords;
+struct Move;
+
+std::vector<Move> legal_moves(int8_t, const Board&, const Coords, bool = false);
+std::vector<Move> keep_only_blocking(const std::vector<Move>, const Board&);
+std::optional<Move> move_for_position(const Board&, const Coords, const Coords);
+std::vector<Move> look_direction(const Board&, const Coords, int, int);
+
+std::vector<Move> pawn_moves(const Board&, const Coords);
+std::vector<Move> rook_moves(const Board&, const Coords);
+std::vector<Move> knight_moves(const Board&, const Coords);
+std::vector<Move> bishop_moves(const Board&, const Coords);
+std::vector<Move> queen_moves(const Board&, const Coords);
+std::vector<Move> king_moves(const Board&, const Coords);

cpp/src/pieces/queen.cpp

@@ -0,0 +1,35 @@
+#include "../board.hpp"
+#include "../coords.hpp"
+#include "../move.hpp"
+#include "piece.hpp"
+
+#include <vector>
+
+std::vector<Move> queen_moves(const Board& b, const Coords xy) {
+    std::vector<Move> ret;
+    auto e = look_direction(b, xy, 1, 0);
+    ret.insert(ret.end(), e.begin(), e.end());
+
+    auto s = look_direction(b, xy, 0, -1);
+    ret.insert(ret.end(), s.begin(), s.end());
+
+    auto w = look_direction(b, xy, -1, 0);
+    ret.insert(ret.end(), w.begin(), w.end());
+
+    auto n = look_direction(b, xy, 0, 1);
+    ret.insert(ret.end(), n.begin(), n.end());
+
+    auto ne = look_direction(b, xy, 1, 1);
+    ret.insert(ret.end(), ne.begin(), ne.end());
+
+    auto se = look_direction(b, xy, 1, -1);
+    ret.insert(ret.end(), se.begin(), se.end());
+
+    auto sw = look_direction(b, xy, -1, -1);
+    ret.insert(ret.end(), sw.begin(), sw.end());
+
+    auto nw = look_direction(b, xy, -1, 1);
+    ret.insert(ret.end(), nw.begin(), nw.end());
+
+    return ret;
+}

cpp/src/pieces/rook.cpp

@@ -0,0 +1,23 @@
+#include "../board.hpp"
+#include "../coords.hpp"
+#include "../move.hpp"
+#include "piece.hpp"
+
+#include <vector>
+
+std::vector<Move> rook_moves(const Board& b, const Coords xy) {
+    std::vector<Move> ret;
+    auto e = look_direction(b, xy, 1, 0);
+    ret.insert(ret.end(), e.begin(), e.end());
+
+    auto s = look_direction(b, xy, 0, -1);
+    ret.insert(ret.end(), s.begin(), s.end());
+
+    auto w = look_direction(b, xy, -1, 0);
+    ret.insert(ret.end(), w.begin(), w.end());
+
+    auto n = look_direction(b, xy, 0, 1);
+    ret.insert(ret.end(), n.begin(), n.end());
+
+    return ret;
+}

cpp/src/threadpool.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <iostream>
+#include <queue>
+#include <thread>
+#include <vector>
+
+class ThreadPool {
+  public:
+    ThreadPool(size_t numThreads) {
+        for (size_t i = 0; i < numThreads; ++i) {
+            workers.emplace_back([this] {
+                while (true) {
+                    std::function<void()> task;
+                    {
+                        std::unique_lock<std::mutex> lock(queueMutex);
+                        condition.wait(lock, [this] {
+                            return stop || !tasks.empty();
+                        });
+                        if (stop && tasks.empty())
+                            return;
+                        task = std::move(tasks.front());
+                        tasks.pop();
+                    }
+                    task();
+                }
+            });
+        }
+    }
+
+    template <class F, class... Args>
+    auto enqueue(F&& f, Args&&... args)
+        -> std::future<typename std::invoke_result<F, Args...>::type> {
+        using return_type = typename std::invoke_result<F, Args...>::type;
+
+        auto task = std::make_shared<std::packaged_task<return_type()>>(
+            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
+        );
+
+        std::future<return_type> res = task->get_future();
+        {
+            std::unique_lock<std::mutex> lock(queueMutex);
+            tasks.emplace([task]() { (*task)(); });
+        }
+        condition.notify_one();
+        return res;
+    }
+
+    void waitAll() {
+        std::unique_lock<std::mutex> lock(queueMutex);
+        condition.wait(lock, [this] { return tasks.empty(); });
+    }
+
+    ~ThreadPool() {
+        {
+            std::unique_lock<std::mutex> lock(queueMutex);
+            stop = true;
+        }
+        condition.notify_all();
+        for (std::thread& worker : workers)
+            worker.join();
+    }
+
+  private:
+    std::vector<std::thread> workers;
+    std::queue<std::function<void()>> tasks;
+    std::mutex queueMutex;
+    std::condition_variable condition;
+    bool stop = false;
+};

cpp/tests/fen.cpp

@@ -0,0 +1,23 @@
+#include "../src/board.hpp"
+#include "lib.hpp"
+
+int main() {
+    std::string pos =
+        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+    ASSERT_EQUALS(pos, Board::setup_fen_position(pos).to_fen());
+
+    pos = "r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1 b Qk - 0 1";
+    ASSERT_EQUALS(pos, Board::setup_fen_position(pos).to_fen());
+
+    pos = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1";
+    ASSERT_EQUALS(pos, Board::setup_fen_position(pos).to_fen());
+
+    pos = "4k2r/6r1/8/8/8/8/3R4/R3K3 w Qk - 0 1";
+    ASSERT_EQUALS(pos, Board::setup_fen_position(pos).to_fen());
+
+    pos = "8/8/8/4p1K1/2k1P3/8/8/8 b - - 0 1";
+    ASSERT_EQUALS(pos, Board::setup_fen_position(pos).to_fen());
+
+    pos = "8/5k2/3p4/1p1Pp2p/pP2Pp1P/P4P1K/8/8 b - - 99 50";
+    ASSERT_EQUALS(pos, Board::setup_fen_position(pos).to_fen());
+}

cpp/tests/lib.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <iostream>
+
+#define ASSERT_EQUALS(x, y)                                                    \
+    {                                                                          \
+        auto expected = x;                                                     \
+        auto actual = y;                                                       \
+        if (expected != actual) {                                              \
+            std::cerr << "Expected: " << std::endl                             \
+                      << '\t' << expected << std::endl                         \
+                      << "Got: " << std::endl                                  \
+                      << '\t' << actual << std::endl;                          \
+            exit(1);                                                           \
+        }                                                                      \
+    }

cpp/tests/positions.cpp

@@ -0,0 +1,20 @@
+#include "../src/coords.hpp"
+#include "lib.hpp"
+
+int main() {
+    ASSERT_EQUALS(Coords(0, 0).to_algebraic(), "a1");
+    ASSERT_EQUALS(Coords(1, 0).to_algebraic(), "b1");
+
+    ASSERT_EQUALS(Coords(2, 1).to_algebraic(), "c2");
+    ASSERT_EQUALS(Coords(4, 2).to_algebraic(), "e3");
+
+    ASSERT_EQUALS(Coords(7, 7).to_algebraic(), "h8");
+
+    ASSERT_EQUALS(Coords::from_algebraic("a1"), Coords(0, 0));
+    ASSERT_EQUALS(Coords::from_algebraic("b1"), Coords(1, 0));
+
+    ASSERT_EQUALS(Coords::from_algebraic("c2"), Coords(2, 1));
+    ASSERT_EQUALS(Coords::from_algebraic("e3"), Coords(4, 2));
+
+    ASSERT_EQUALS(Coords::from_algebraic("h8"), Coords(7, 7));
+}

python/src/ai/ai.py

@@ -0,0 +1,169 @@
+from collections import defaultdict
+import time
+
+from tqdm import tqdm
+from logic.board import INITIAL_BOARD, Board
+from logic.move import Move
+from logic.pieces.piece import Colour
+
+pos2expected = {
+    # -- Position 1
+    "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1": {
+        1: 20,
+        2: 400,
+        3: 8_902,
+        4: 197_281,
+    },
+
+    # -- Position 2
+    "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1": {
+        1: 48,
+        2: 2_039,
+        3: 97_862,
+        4: 4_085_603,
+    },
+
+    # -- Position 3
+    "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1": {
+        1: 14,
+        2: 191,
+        3: 2_812,
+        4: 43_238,
+        5: 674_624,
+    },
+
+    # -- Position 4
+    "r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1": {
+        1: 6,
+        2: 264,
+        3: 9467,
+        4: 422_333,
+    },
+
+    # -- Position 5
+    "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8": {
+        1: 44,
+        2: 1486,
+        3: 62379,
+        4: 2103487,
+    },
+
+    # -- Position 6
+    "r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 10": {
+        1: 46,
+        2: 2079,
+        3: 89890,
+        4: 3894594,
+    },
+}
+
+tick = "\033[92m✔️\033[0m"  # Green Tick
+cross = "\033[91m❌\033[0m"  # Red Cross
+
+res = defaultdict(lambda : 0)
+
+def peft(pos: str):
+    global res
+    expected = pos2expected[pos]
+    board = Board.setup_FEN_position(pos)
+    for depth in expected:
+        with tqdm(total=expected[depth], desc=f"Depth: {depth}") as bar:
+            start = time.process_time()
+            moves = move_generation_test(bar, board, depth, depth)
+            bar.close()
+            elapsed = time.process_time() - start
+            elapsed *= 1_000
+
+            print("Depth:", depth, end=" ")
+            print("Result:", moves, end=" ")
+            if moves == expected[depth]:
+                print(f"{tick}", end=" ")
+            else:
+                print(f"{cross} (expected {expected[depth]})", end=" ")
+            print("positions Time:", int(elapsed), "milliseconds")
+
+            if moves != expected[depth]:
+                print()
+                for key, value in res.items():
+                    print(f"{key}: {value}")
+
+
+
+def move_generation_test(bar, board: Board, depth: int, max_depth, first = None):
+    global res
+    if first is None:
+        res = defaultdict(lambda : 0)
+
+    if board.is_terminal():
+        # bar.update(1)
+        # res[first] += 1
+        return 0
+
+    if depth == 0:
+        res[first] += 1
+        bar.update(1)
+        return 1
+
+    moves = board.legal_moves()
+    if depth == 1:
+        res[first] += len(moves)
+        bar.update(len(moves))
+        return len(moves)
+
+    num_pos = 0
+    for move in moves:
+        tmp_board = board.make_move(move)
+        if first is None:
+            first = move.piece.pos.to_algebraic() + move.pos.to_algebraic()
+
+        if first == "f7h8":
+            print(tmp_board.legal_moves())
+        num_pos += move_generation_test(bar, tmp_board, depth - 1, max_depth, first = first)
+
+        if depth == max_depth:
+            first = None
+
+    return num_pos
+
+
+
+def play_game(board: Board, strategies: dict, verbose: bool = False) -> Board:
+    """Play a turn-taking game. `strategies` is a {player_name: function} dict,
+    where function(state) is used to get the player's move."""
+    state = board
+    move_counter = 1
+    while not (board.is_checkmate_for(board._turn) or board.is_stalemate_for(board._turn)):
+        player = board._turn
+        move = strategies[player](state)
+        state = board.make_move(move)
+        if verbose:
+            if player == Colour.WHITE:
+                print(str(move_counter) + ".", move, end=" ")
+            else:
+                print(move)
+
+    return state
+
+def minmax_search(state: Board) -> tuple[float, Move]:
+    """Search game tree to determine best move; return (value, move) pair."""
+    return _max_value(state) if state._turn == Colour.WHITE else _min_value(state)
+
+def _max_value(state: Board) -> tuple[float, Move]:
+    if state.is_terminal():
+        return state.utility(), None
+    v, move = -float("inf"), None
+    for a in state.legal_moves():
+        v2, _ = _min_value(state.make_move(a))
+        if v2 > v:
+            v, move = v2, a
+    return v, move
+
+def _min_value(state: Board) -> tuple[float, Move]:
+    if state.is_terminal():
+        return state.utility(), None
+    v, move = float("inf"), None
+    for a in state.legal_moves():
+        v2, _ = _min_value(state.make_move(a))
+        if v2 < v:
+            v, move = v2, a
+    return v, move

python/src/logic/board.py

@@ -15,9 +15,11 @@ class Board:
         self._white: dict[Position, Piece] = {}
         self._black: dict[Position, Piece] = {}
         self._turn = None
-        self._white_castling_write = set()
-        self._black_castling_write = set()
+        self._white_castling_rights = set()
+        self._black_castling_rights = set()
         self._en_passant_target = None
+        self._n_moves = 0
+        self._n_half_moves = 0
 
     @staticmethod
     def _piece_class_from_char(c: str) -> Type[Piece]:
@@ -83,22 +85,41 @@ class Board:
         for c in position[index:]:
             index += 1
             if c == "-" or c == " ":
+                if c == "-":
+                    index += 1
                 break
 
             sides = "kq"
             assert c in sides or c in sides.upper(), f"The FEN position is malformed, the castling rights should be either k or q (both either lower- or upper-case), instead is '{c}'"
             if c == "K":
-                ret._white_castling_write.add(CastleSide.King)
+                ret._white_castling_rights.add(CastleSide.King)
             if c == "Q":
-                ret._white_castling_write.add(CastleSide.Queen)
+                ret._white_castling_rights.add(CastleSide.Queen)
             if c == "k":
-                ret._black_castling_write.add(CastleSide.King)
+                ret._black_castling_rights.add(CastleSide.King)
             if c == "q":
-                ret._black_castling_write.add(CastleSide.Queen)
+                ret._black_castling_rights.add(CastleSide.Queen)
 
         # -- En passant target
         if position[index] != "-":
-            ret._en_passant_target = position[index:index+2]
+            pos = Position.from_algebraic(position[index:index+2]) 
+            index += 2
+            if pos.y == 2:
+                pos.y += 1
+                assert pos in ret._white, "En passant target is not in the position"
+                ret._en_passant_target = ret._white[pos]
+            elif pos.y == 5:
+                pos.y -= 1
+                assert pos in ret._black, "En passant target is not in the position"
+                ret._en_passant_target = ret._black[pos]
+            else:
+                raise ValueError("You can't have a en passant target that is not on the third or sixth rank")
+        else:
+            index += 1
+        index += 1
+
+        ret._n_half_moves = int(position[index:position.find(" ", index + 1)])
+        ret._n_moves = int(position[position.find(" ", index)+1:])
 
         return ret
 
@@ -152,8 +173,8 @@ class Board:
                 return False
         return True
 
-    def castling_writes_for(self, colour: Colour) -> set[CastleSide]:
-        return self._white_castling_write if colour == Colour.WHITE else self._black_castling_write
+    def castling_rights_for(self, colour: Colour) -> set[CastleSide]:
+        return self._white_castling_rights if colour == Colour.WHITE else self._black_castling_rights
 
     def make_move(self, move: Move) -> "Board":
         dest_piece = self.piece_at(move.pos.x, move.pos.y) 
@@ -161,15 +182,18 @@ class Board:
         if dest_piece:
             assert dest_piece.colour != move.piece.colour, "A piece cannot cannot eat another piece of the same colour"
 
+        # -- Copy current state
         ret = Board()
         ret._white = self._white.copy()
         ret._black = self._black.copy()
         ret._turn = Colour.WHITE if self._turn == Colour.BLACK else Colour.BLACK
-        ret._white_castling_write = self._white_castling_write.copy()
-        ret._black_castling_write = self._black_castling_write.copy()
-        ret._en_passant_target = self._en_passant_target
+        ret._white_castling_rights = self._white_castling_rights.copy()
+        ret._black_castling_rights = self._black_castling_rights.copy()
+
 
         piece = move.piece
+
+        # -- Actually make the move
         pieces_moving, other_pieces = (ret._white, ret._black) if piece.colour == Colour.WHITE else (ret._black, ret._white)
 
         del pieces_moving[piece.pos]
@@ -177,6 +201,29 @@ class Board:
         if move.pos in other_pieces:
             del other_pieces[move.pos]
 
+        if piece.colour == Colour.BLACK:
+            ret._n_moves = self._n_moves + 1
+
+        if move.is_capturing or type(piece) == Pawn:
+            ret._n_half_moves = 0
+        else:
+            ret._n_half_moves = self._n_half_moves + 1
+
+        if move.en_passant:
+            pos_to_remove = Position(move.pos.x, move.pos.y + (1 if self._turn == Colour.BLACK else -1))
+            del other_pieces[pos_to_remove]
+
+        if move.promotes_to is not None:
+            assert type(piece) == Pawn, "Trying to promote something that is not a pawn: not good!"
+            pieces_moving[move.pos] = move.promotes_to(move.pos, piece.colour)
+
+        # -- Set en passant target if needed
+        if move.becomes_en_passant_target:
+            ret._en_passant_target = pieces_moving[move.pos]
+        else:
+            ret._en_passant_target = None
+
+        # -- Handle castling (just move the rook over)
         if move.castle_side == CastleSide.King:
             rook_pos = Position(7, piece.pos.y)
             assert rook_pos in pieces_moving and type(pieces_moving[rook_pos]) == Rook, "Either rook is absent from the king side or you are trying to castle with something else than a rook..."
@@ -191,24 +238,123 @@ class Board:
             new_rook_pos = Position(3, piece.pos.y)
             pieces_moving[new_rook_pos] = Rook(new_rook_pos, piece.colour)
 
+        # -- Check for castling rights
         if piece.colour == Colour.WHITE:
             if type(piece) == King:
-                ret._white_castling_write = set()
+                ret._white_castling_rights = set()
 
             if type(piece) == Rook:
-                if piece.pos.x == 0 and CastleSide.Queen in ret._white_castling_write:
-                    ret._white_castling_write.remove(CastleSide.Queen)
-                elif piece.pos.x == 7 and CastleSide.King in ret._white_castling_write:
-                    ret._white_castling_write.remove(CastleSide.King)
+                if piece.pos.x == 0 and CastleSide.Queen in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.Queen)
+                elif piece.pos.x == 7 and CastleSide.King in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.King)
+
+            if move.is_capturing and move.pos.y == 7 and move.pos in self._black and type(self._black[move.pos]) == Rook:
+                if move.pos.x == 0 and CastleSide.Queen in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.Queen)
+                elif move.pos.x == 7 and CastleSide.King in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.King)
         else:
             if type(piece) == King:
-                ret._black_castling_write = set()
+                ret._black_castling_rights = set()
 
             if type(piece) == Rook:
-                if piece.pos.x == 0 and CastleSide.Queen in ret._black_castling_write:
-                    ret._black_castling_write.remove(CastleSide.Queen)
-                elif piece.pos.x == 7 and CastleSide.King in ret._black_castling_write:
-                    ret._black_castling_write.remove(CastleSide.King)
+                if piece.pos.x == 0 and CastleSide.Queen in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.Queen)
+                elif piece.pos.x == 7 and CastleSide.King in ret._black_castling_rights:
+                    ret._black_castling_rights.remove(CastleSide.King)
 
+            if move.is_capturing and move.pos.y == 0 and move.pos in self._white and type(self._white[move.pos]) == Rook:
+                if move.pos.x == 0 and CastleSide.Queen in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.Queen)
+                elif move.pos.x == 7 and CastleSide.King in ret._white_castling_rights:
+                    ret._white_castling_rights.remove(CastleSide.King)
 
         return ret
+
+    def to_fen_string(self):
+        ret = ""
+        for y in range(7, -1, -1):
+            empty_cell_counter = 0
+            for x in range(8):
+                pos = Position(x, y)
+
+                piece = None
+                if pos in self._white:
+                    piece = self._white[pos]
+                elif pos in self._black:
+                    piece = self._black[pos]
+
+                if piece is None:
+                    empty_cell_counter += 1
+                    continue
+
+                if empty_cell_counter > 0:
+                    ret += str(empty_cell_counter)
+                    empty_cell_counter = 0
+                letter = piece.letter()
+                ret += letter.lower() if piece.colour == Colour.BLACK else letter.upper()
+
+            if empty_cell_counter > 0:
+                ret += str(empty_cell_counter)
+
+            if y > 0:
+                ret += "/"
+        ret += " "
+
+        ret += "w" if self._turn == Colour.WHITE else "b"
+        ret += " "
+
+        if len(self._white_castling_rights) == 0 and len(self._black_castling_rights) == 0:
+            ret += "-"
+        else: 
+            if CastleSide.King in self._white_castling_rights:
+                ret += "K"
+            if CastleSide.Queen in self._white_castling_rights:
+                ret += "Q"
+
+            if CastleSide.King in self._black_castling_rights:
+                ret += "k"
+            if CastleSide.Queen in self._black_castling_rights:
+                ret += "q"
+        ret += " "
+
+        if self._en_passant_target is not None:
+            pos = Position(self._en_passant_target.pos.x, self._en_passant_target.pos.y)
+            pos.y += -1 if self._en_passant_target.colour == Colour.WHITE else 1
+            ret += pos.to_algebraic()
+        else:
+            ret += "-"
+        ret += " "
+
+        ret += str(self._n_half_moves)
+        ret += " "
+        ret += str(self._n_moves)
+
+        return ret
+
+
+    def legal_moves(self) -> list[Move]:
+        ret = []
+        pieces = self._white if self._turn == Colour.WHITE else self._black
+        for piece in pieces.values():
+            ret += piece.legal_moves(self)
+        return ret
+
+    def is_terminal(self) -> bool:
+        return self.is_stalemate_for(Colour.WHITE) or self.is_stalemate_for(Colour.BLACK) or self.is_checkmate_for(Colour.WHITE) or self.is_checkmate_for(Colour.BLACK)
+
+    def utility(self) -> int:
+        if self.is_stalemate_for(Colour.WHITE) or self.is_stalemate_for(Colour.BLACK):
+            return 0
+
+        if self.is_checkmate_for(Colour.WHITE):
+            return 1
+
+        if self.is_checkmate_for(Colour.BLACK):
+            return -1
+        
+        raise ValueError("Cannot determine the utility of board become it neither checkmate nor stalemate for either players")
+
+_fen_pos = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+INITIAL_BOARD = Board.setup_FEN_position(_fen_pos)

python/src/logic/move.py

@@ -1,4 +1,5 @@
 # from logic.pieces.piece import Piece
+from typing import Type
 from logic.position import Position
 from enum import Enum
 
@@ -8,11 +9,14 @@ class CastleSide(Enum):
     Queen = "O-O-O"
 
 class Move:
-    def __init__(self, piece: "Piece", pos: Position,/, is_capturing: bool = False, castle_side: CastleSide = CastleSide.Neither) -> None:
+    def __init__(self, piece: "Piece", pos: Position,/, is_capturing: bool = False, castle_side: CastleSide = CastleSide.Neither, en_passant: bool = False, becomes_en_passant_target: bool = False, promotes_to: Type["Piece"] = None) -> None:
         self.piece = piece
         self.pos = pos
         self.is_capturing = is_capturing
         self.castle_side = castle_side
+        self.becomes_en_passant_target = becomes_en_passant_target
+        self.en_passant = en_passant
+        self.promotes_to = promotes_to
 
     def to_algebraic(self) -> str:
         raise NotImplementedError("The move can't be translated to algbraic notation, as it was not implemented")
@@ -28,10 +32,19 @@ class Move:
             return "O-O-O"
 
         ret = ""
-        if type(self.piece).__name__ != "Pawn":
+        if type(self.piece).__name__ == "Pawn":
+            if self.is_capturing:
+                ret += self.piece.pos.to_algebraic()[0]
+                ret += "x"
+                ret += self.pos.to_algebraic()
+            else:
+                ret += self.pos.to_algebraic()
+        else:
             ret += self.piece.letter().upper()
-
-        ret += str(self.pos)
+            if self.is_capturing:
+                ret += "x"
+            ret += str(self.pos)
+        
         return ret
     
     def __repr__(self) -> str:

python/src/logic/pieces/bishop.py

@@ -17,7 +17,7 @@ class Bishop(Piece):
         # looking north west
         ret.extend(self._look_direction(board, -1, 1))
 
-        if not looking_for_check and board.is_check_for(self.colour):
+        if not looking_for_check:# and board.is_check_for(self.colour):
             return self.keep_only_blocking(ret, board)
 
         return ret

python/src/logic/pieces/king.py

@@ -23,11 +23,11 @@ class King(Piece):
             return self.keep_only_blocking(ret, board)
 
         # -- Castles
-        castling_writes = board.castling_writes_for(self.colour)
-        if len(castling_writes) == 0:
+        castling_rights = board.castling_rights_for(self.colour)
+        if len(castling_rights) == 0:
             return ret
 
-        if CastleSide.King in castling_writes:
+        if CastleSide.King in castling_rights:
             clear = True
             for dx in range(1, 3):
                 x = self.pos.x + dx
@@ -45,9 +45,9 @@ class King(Piece):
             if clear:
                 ret.append(Move(self, Position(6, self.pos.y), castle_side=CastleSide.King))
 
-        if CastleSide.Queen in castling_writes:
+        if CastleSide.Queen in castling_rights:
             clear = True
-            for dx in range(1, 3):
+            for dx in range(1, 4):
                 x = self.pos.x - dx
                 y = self.pos.y
 
@@ -57,7 +57,7 @@ class King(Piece):
 
                 move = self._move_for_position(board, x, y)
                 board_after_move = board.make_move(move)
-                if board_after_move.is_check_for(self.colour):
+                if dx < 3 and board_after_move.is_check_for(self.colour):
                     clear = False
                     break
 

python/src/logic/pieces/knight.py

@@ -16,7 +16,7 @@ class Knight(Piece):
             if move is not None:
                 ret.append(move)
 
-        if not looking_for_check and board.is_check_for(self.colour):
+        if not looking_for_check:# and board.is_check_for(self.colour):
             return self.keep_only_blocking(ret, board)
 
         return ret

python/src/logic/pieces/pawn.py

@@ -0,0 +1,80 @@
+from logic.move import Move
+from logic.pieces.bishop import Bishop
+from logic.pieces.knight import Knight
+from logic.pieces.piece import Colour, Piece
+from logic.pieces.queen import Queen
+from logic.pieces.rook import Rook
+from logic.position import Position
+
+class Pawn(Piece):
+    def legal_moves(self, board, / , looking_for_check = False) -> list[Move]:
+        ret = []
+
+        # can we capture to the left?
+        if self.pos.x > 0 and (
+            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y + 1)))
+            or
+            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y - 1)))
+        ):
+            if capturable_piece.colour != self.colour:
+                if (self.colour == Colour.WHITE and capturable_piece.pos.y == 7) or (self.colour == Colour.BLACK and capturable_piece.pos.y == 0):
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, capturable_piece.pos, is_capturing=True, promotes_to=piece))
+                else:
+                    ret.append(Move(self, capturable_piece.pos, is_capturing = True))
+
+        # can we capture to the right?
+        if self.pos.x < 7 and (
+            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y + 1)))
+            or
+            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y - 1)))
+        ):
+            if capturable_piece.colour != self.colour:
+                if (self.colour == Colour.WHITE and capturable_piece.pos.y == 7) or (self.colour == Colour.BLACK and capturable_piece.pos.y == 0):
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, capturable_piece.pos, is_capturing=True, promotes_to=piece))
+                else:
+                    ret.append(Move(self, capturable_piece.pos, is_capturing = True))
+
+        # -- Can we capture en passant?
+        if board._en_passant_target is not None and \
+            board._en_passant_target.pos.y == self.pos.y and (
+                board._en_passant_target.pos.x == self.pos.x - 1
+                or board._en_passant_target.pos.x == self.pos.x + 1
+        ):
+            if board._en_passant_target.colour != self.colour:
+                old_pos = board._en_passant_target.pos
+                new_pos = Position(old_pos.x, old_pos.y + (1 if self.colour == Colour.WHITE else -1))
+                ret.append(Move(self, new_pos, is_capturing = True, en_passant = True))
+
+        # -- Normal moves
+        if self.colour == Colour.WHITE:
+            for dy in range(1, 3 if self.pos.y == 1 else 2):
+                y = self.pos.y + dy
+                if y > 7 or board.piece_at(self.pos.x, y):
+                    break
+                pos = Position(self.pos.x, y)
+                if y == 7:
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, pos, promotes_to=piece))
+                else:
+                    ret.append(Move(self, pos, becomes_en_passant_target=dy==2))
+        else:
+            for dy in range(1, 3 if self.pos.y == 6 else 2):
+                y = self.pos.y - dy
+                if y < 0 or board.piece_at(self.pos.x, y):
+                    break
+                pos = Position(self.pos.x, y)
+                if y == 0:
+                    for piece in [Queen, Knight, Bishop, Rook]:
+                        ret.append(Move(self, pos, promotes_to=piece))
+                else:
+                    ret.append(Move(self, pos, becomes_en_passant_target=dy==2))
+
+        if not looking_for_check:# and board.is_check_for(self.colour):
+            return self.keep_only_blocking(ret, board)
+
+        return ret
+
+    def letter(self):
+        return "p"

python/src/logic/pieces/queen.py

@@ -29,7 +29,7 @@ class Queen(Piece):
         # looking north
         ret.extend(self._look_direction(board, 0, 1))
 
-        if not looking_for_check and board.is_check_for(self.colour):
+        if not looking_for_check:# and board.is_check_for(self.colour):
             return self.keep_only_blocking(ret, board)
 
         return ret

python/src/logic/pieces/rook.py

@@ -17,7 +17,7 @@ class Rook(Piece):
         # looking north
         ret.extend(self._look_direction(board, 0, 1))
 
-        if not looking_for_check and board.is_check_for(self.colour):
+        if not looking_for_check:# and board.is_check_for(self.colour):
             return self.keep_only_blocking(ret, board)
 
         return ret

python/src/logic/position.py

@@ -17,6 +17,14 @@ class Position:
         return x >= Position._MIN_POS and x <= Position._MAX_POS \
             and y >= Position._MIN_POS and y <= Position._MAX_POS
 
+    @staticmethod
+    def from_algebraic(square: str) -> "Position":
+        assert len(square) == 2, f"'{square}' is malformed"
+        x = Position._FILES.index(square[0])
+        y = Position._RANKS.index(int(square[1]))
+
+        return Position(x, y)
+
     def to_algebraic(self) -> str:
         return f"{Position._FILES[self.x]}{Position._RANKS[self.y]}"
 

python/src/main.py

@@ -0,0 +1,27 @@
+import time
+from pprint import pprint
+from tqdm import tqdm
+
+from ai.ai import move_generation_test
+from controller.controller import Controller
+from logic.board import INITIAL_BOARD, Board
+from logic.position import Position
+from view.gui import GUI
+from view.tui import TUI
+
+from ai.ai import peft
+
+if __name__ == "__main__":
+    board = INITIAL_BOARD
+
+    pos = "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8"
+    board = Board.setup_FEN_position(pos)
+
+    view = GUI()
+
+    controller = Controller(board, view)
+
+    # view.show()
+    # exit()
+
+    peft(pos)

python/tests/fen.py

@@ -0,0 +1,30 @@
+import unittest
+
+import sys
+sys.path.append('src') # you must execute pytest from the stickfosh dir for this to work
+
+from logic.board import Board
+
+class FENTests(unittest.TestCase):
+    def testInitialPosition(self):
+        pos = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+    def testRandomPositions(self):
+        pos = "r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1 b Qk - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "4k2r/6r1/8/8/8/8/3R4/R3K3 w Qk - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "8/8/8/4p1K1/2k1P3/8/8/8 b - - 0 1"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+        pos = "8/5k2/3p4/1p1Pp2p/pP2Pp1P/P4P1K/8/8 b - - 99 50"
+        self.assertEqual(pos, Board.setup_FEN_position(pos).to_fen_string())
+
+
+

python/tests/position.py

@@ -0,0 +1,30 @@
+import unittest
+
+import sys
+sys.path.append('src') # you must execute pytest from the stickfosh dir for this to work
+
+from logic.position import Position
+
+class PositionTests(unittest.TestCase):
+    def testXY2Algebraic(self):
+        self.assertEqual(Position(0, 0).to_algebraic(), "a1")
+        self.assertEqual(Position(1, 0).to_algebraic(), "b1")
+
+        self.assertEqual(Position(2, 1).to_algebraic(), "c2")
+        self.assertEqual(Position(4, 2).to_algebraic(), "e3")
+
+        self.assertEqual(Position(7, 7).to_algebraic(), "h8")
+
+    def testAlgebraic2XY(self):
+        self.assertEqual(Position.from_algebraic("a1"), Position(0, 0))
+        self.assertEqual(Position.from_algebraic("b1"), Position(1, 0))
+
+        self.assertEqual(Position.from_algebraic("c2"), Position(2, 1))
+        self.assertEqual(Position.from_algebraic("e3"), Position(4, 2))
+
+        self.assertEqual(Position.from_algebraic("h8"), Position(7, 7))
+
+        self.assertRaises(AssertionError, lambda : Position.from_algebraic("a11"))
+
+        self.assertRaises(ValueError, lambda : Position.from_algebraic("j1"))
+        self.assertRaises(ValueError, lambda : Position.from_algebraic("a9"))

src/logic/pieces/pawn.py

@@ -1,43 +0,0 @@
-from logic.move import Move
-from logic.pieces.piece import Colour, Piece
-from logic.position import Position
-
-class Pawn(Piece):
-    def legal_moves(self, board, / , looking_for_check = False) -> list[Move]:
-        ret = []
-
-        # can we capture to the left?
-        if self.pos.x > 0 and (
-            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y + 1)))
-            or
-            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x - 1, self.pos.y - 1)))
-        ):
-            if capturable_piece.colour != self.colour:
-                ret.append(Move(self, capturable_piece.pos, is_capturing = True))
-
-        # can we capture to the right?
-        if self.pos.x < 7 and (
-            (self.colour == Colour.WHITE and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y + 1)))
-            or
-            (self.colour == Colour.BLACK and (capturable_piece := board.piece_at(self.pos.x + 1, self.pos.y - 1)))
-        ):
-            if capturable_piece.colour != self.colour:
-                ret.append(Move(self, capturable_piece.pos, is_capturing = True))
-
-        if self.colour == Colour.WHITE:
-            for dy in range(1, 3 if self.pos.y == 1 else 2):
-                if self.pos.y + dy > 7 or board.piece_at(self.pos.x, self.pos.y + dy):
-                    break
-                pos = Position(self.pos.x, self.pos.y + dy)
-                ret.append(Move(self, pos))
-        else:
-            for dy in range(1, 3 if self.pos.y == 6 else 2):
-                if self.pos.y - dy < 0 or board.piece_at(self.pos.x, self.pos.y - dy):
-                    break
-                pos = Position(self.pos.x, self.pos.y - dy)
-                ret.append(Move(self, pos))
-
-        if not looking_for_check and board.is_check_for(self.colour):
-            return self.keep_only_blocking(ret, board)
-
-        return ret

src/main.py

@@ -1,14 +0,0 @@
-from controller.controller import Controller
-from logic.board import Board
-from view.gui import GUI
-from view.tui import TUI
-
-if __name__ == "__main__":
-    initial_board_position = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-    board = Board.setup_FEN_position(initial_board_position)
-
-    view = GUI()
-
-    controller = Controller(board, view)
-
-    view.show()