.gitignore

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

cpp/.gitignore

@@ -1,34 +0,0 @@
-# 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

@@ -1,56 +0,0 @@
-# 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/board.cpp

@@ -0,0 +1,108 @@
+#include <cctype>
+#include <map>
+#include <string>
+
+enum Piece {
+    None = 0,
+    King = 1,
+    Pawn = 2,
+    Knigt = 3,
+    Bishop = 4,
+    Rook = 5,
+    Queen = 6,
+};
+
+enum Colour {
+    White = 8,
+    Black = 16,
+};
+
+enum CastleRights {
+    KingSide = 1,
+    QueenSide = 2,
+};
+
+class Board {
+  private:
+    int squares[64] = {Piece::None};
+    Colour turn;
+    int castle_rights;
+
+  public:
+    static Board* setup_fen_position(std::string fen);
+
+    std::string to_fen();
+};
+
+Board* Board::setup_fen_position(std::string fen) {
+    Board* board = new Board();
+    std::map<char, Piece> c2p{
+        {'k', Piece::King},
+        {'p', Piece::Pawn},
+        {'n', Piece::Knigt},
+        {'b', Piece::Bishop},
+        {'r', Piece::Rook},
+        {'q', Piece::Queen},
+    };
+
+    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++;
+        }
+    }
+    return board;
+}
+
+std::string Board::to_fen() {
+    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;
+    for (int rank = 7; rank >= 0; rank--) {
+        int empty_cell_counter = 0;
+        for (int file = 0; file < 8; file++) {
+            if (this->squares[rank * 8 + file] == Piece::None) {
+                empty_cell_counter++;
+                continue;
+            }
+
+            int full_piece = this->squares[rank * 8 + file];
+            char piece = p2c[full_piece & 0b111];
+            Colour colour = (full_piece & 0b11000) == Colour::White
+                              ? Colour::White
+                              : Colour::Black;
+
+            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 += "/";
+    }
+    return ret;
+}

cpp/main.cpp

@@ -0,0 +1,18 @@
+#include "board.cpp"
+
+#include <iostream>
+
+int main(int argc, char* argv[]) {
+    std::string pos =
+        "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8";
+    Board* b = Board::setup_fen_position(pos);
+
+    std::string fen = b->to_fen();
+
+    std::cout << pos << std::endl;
+    std::cout << fen << std::endl;
+
+    std::cout << (fen.substr(0, fen.find(" ")) == pos.substr(0, pos.find(" ")))
+              << std::endl;
+    return 0;
+}

cpp/src/board.cpp

@@ -1,220 +0,0 @@
-#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 {
-    int8_t dest_piece = this->squares[move.target_square];
-
-    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 (move.en_passant)
-        ret.squares[move.target_square - 8] = Piece::None;
-    return ret;
-}
-
-int8_t Board::get_king_of(int8_t colour) const {
-    for (int i = 0; i < 64; i++)
-        if (this->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)
-            continue;
-        std::vector<Move> moves =
-            legal_moves(this->squares[i], *this, Coords::from_index(i), true);
-        std::vector<int8_t> targets = to_target_square(moves);
-        if (std::find(targets.begin(), targets.end(), i) != targets.end())
-            return true;
-    }
-    return false;
-}

cpp/src/board.hpp

@@ -1,35 +0,0 @@
-#pragma once
-
-#include "coords.hpp"
-#include "move.hpp"
-#include "pieces/piece.hpp"
-
-#include <string>
-
-struct Board {
-  private:
-    int8_t get_king_of(int8_t colour) 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;
-
-    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

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

cpp/src/coords.hpp

@@ -1,70 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#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) {
-        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"
-            );
-
-        int x = _FILES.find(pos[0]);
-        if (x == std::string::npos)
-            throw std::invalid_argument("The first character of the given "
-                                        "algebraic coordinate is invalid");
-
-        int 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{x, 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 this->to_index() < 64;
-    }
-};
-
-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

@@ -1,11 +0,0 @@
-#include "board.hpp"
-
-#include <iostream>
-
-int main(int argc, char* argv[]) {
-    std::string pos =
-        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-    Board b = Board::setup_fen_position(pos);
-    sizeof(b);
-    return 0;
-}

cpp/src/move.hpp

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "castle_side.hpp"
-
-#include <cstdint>
-
-struct Move {
-    int8_t source_square;
-    int8_t target_square;
-
-    bool is_capturing = false;
-    CastleSide castle_side = CastleSide::NeitherSide;
-    bool en_passant = false;
-    int8_t promoting_to = 0;
-};

cpp/src/pieces/bishop.cpp

@@ -1,23 +0,0 @@
-#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

@@ -1,76 +0,0 @@
-#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 ret;
-
-    // -- 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(),
-            .castle_side = CastleSide::KingSide
-        });
-    }
-
-    if (castling_rights & CastleSide::QueenSide && is_clear_queen_side(b, xy)) {
-        ret.push_back(Move{
-            xy.to_index(),
-            Coords{2, xy.y}.to_index(),
-            .castle_side = CastleSide::QueenSide
-        });
-    }
-
-    return ret;
-}

cpp/src/pieces/knight.cpp

@@ -1,28 +0,0 @@
-#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

@@ -1,51 +0,0 @@
-#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))
-                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))
-                ret.push_back(Move{xy.to_index(), right.to_index()});
-        }
-    }
-
-    // -- 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 : {Queen, Knigt, Bishop, Rook})
-                ret.push_back(Move{
-                    xy.to_index(),
-                    new_xy.to_index(),
-                    .promoting_to = piece
-                });
-    }
-
-    return ret;
-}

cpp/src/pieces/piece.cpp

@@ -1,72 +0,0 @@
-#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 = false
-) {
-    std::vector<Move> ret;
-    switch (p) {
-    case Piece::Pawn:
-        ret = pawn_moves(b, xy);
-    case Piece::Bishop:
-        break;
-    default:
-        break;
-    }
-
-    if (!looking_for_check)
-        return keep_only_blocking(ret, b);
-
-    return {};
-}
-
-std::optional<Move>
-move_for_position(const Board& board, const Coords source, const Coords dest) {
-    if (dest.is_within_bounds())
-        return {};
-
-    int8_t piece = board.squares[dest.to_index()];
-    if (piece == Piece::None)
-        return Move{source.to_index(), dest.to_index()};
-
-    int8_t source_colour = board.colour_at(source);
-    int8_t dest_colour = board.colour_at(dest);
-    if (source_colour != dest_colour)
-        return Move{source.to_index(), dest.to_index(), true};
-    return {};
-}
-
-std::vector<Move>
-look_direction(const Board& board, const Coords xy, int mult_dx, int mult_dy) {
-    std::vector<Move> ret;
-    for (int d = 0; d < 8; d++) {
-        int dx = mult_dx * d;
-        int dy = mult_dy * d;
-
-        std::optional<Move> move =
-            move_for_position(board, xy, Coords{xy.x + dx, xy.y + dy});
-        if (move.has_value()) {
-            ret.push_back(move.value());
-            if (move.value().is_capturing)
-                break;
-        }
-    }
-    return ret;
-}

cpp/src/pieces/piece.hpp

@@ -1,37 +0,0 @@
-#pragma once
-
-#include "../move.hpp"
-
-#include <cstdint>
-#include <optional>
-#include <vector>
-
-enum Piece : int8_t {
-    None = 0,
-    King = 1,
-    Pawn = 2,
-    Knigt = 3,
-    Bishop = 4,
-    Rook = 5,
-    Queen = 6,
-};
-
-enum Colour : int8_t {
-    White = 8,
-    Black = 16,
-};
-
-class Board;
-struct Coords;
-
-std::vector<Move> legal_moves(int8_t, const Board&, const Coords, bool);
-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

@@ -1,35 +0,0 @@
-#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

@@ -1,23 +0,0 @@
-#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/tests/fen.cpp

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

cpp/tests/lib.cpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#define ASSERT_EQUALS(expected, actual)                                        \
+    {                                                                          \
+        if (expected != actual)                                                \
+            std::cout << "Expected: " << std::endl                             \
+                      << '\t' << expected << std::endl                         \
+                      << "Got: " << std::endl                                  \
+                      << '\t' << actual << std::endl;                          \
+    }

cpp/tests/lib.hpp

@@ -1,16 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-#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));
-}