added gif for readme

thinking time runs out

.gitignore

@@ -1,174 +1,34 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
+# Prerequisites
+*.d
 
-# C extensions
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
 *.so
+*.dylib
+*.dll
 
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
+# Fortran module files
+*.mod
+*.smod
 
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
 
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
-.pdm.toml
-.pdm-python
-.pdm-build/
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
+# Executables
+*.exe
+*.out
+*.appobj/
+test_bin/
+main

Makefile

@@ -1,4 +1,5 @@
 CXXFLAGS += -O3 -Wall
+# CXXFLAGS += -pg
 
 # Add .d to Make's recognized suffixes.
 SUFFIXES += .d
@@ -27,8 +28,8 @@ obj/%.o:
 	@mkdir -p $(dir $@)
 	$(CXX) $(CXXFLAGS) -o $@ -c $<
 
-main: $(OBJFILES)
-	$(CXX) $(LDFLAGS) $(OBJFILES) $(LOADLIBES) $(LDLIBS) -o main
+stickfosh: $(OBJFILES)
+	$(CXX) $(CXXFLAGS) $(OBJFILES) $(LOADLIBES) $(LDLIBS) -o stickfosh -lsfml-graphics -lsfml-window -lsfml-system
 
 clean:
 	rm -rf obj/* $(DEPFILES) test_bin/
@@ -46,7 +47,7 @@ LIBS := $(filter-out obj/main.o,$(OBJFILES))
 test_bin/%: tests/%.cpp $(LIBS)
 	@echo $(LIBS)
 	@mkdir -p $(dir $@)
-	$(CXX) $(CXXFLAGS) -o $@ $< $(LIBS)
+	$(CXX) $(CXXFLAGS) -o $@ $< $(LIBS) -lsfml-graphics -lsfml-window -lsfml-system
 
 # The 'test' target builds all tests and then runs each one.
 .PHONY: test

README.md

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

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/src/board.hpp

@@ -1,51 +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) 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/main.cpp

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

cpp/src/pieces/pawn.cpp

@@ -1,84 +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))
-                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/stickfosh.cpp

@@ -1,96 +0,0 @@
-#include "stickfosh.hpp"
-
-#include "pieces/piece.hpp"
-#include "threadpool.hpp"
-
-#include <future>
-#include <map>
-
-static int INFINITY = std::numeric_limits<int>::max();
-
-std::string 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(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 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 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/stickfosh.hpp

@@ -1,9 +0,0 @@
-#pragma once
-
-#include "board.hpp"
-
-#include <string>
-
-std::string search(std::string, int);
-int minimax(const Board&, int);
-int eval(const Board&);

python/src/ai/ai.py

@@ -1,169 +0,0 @@
-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/controller/controller.py

@@ -1,63 +0,0 @@
-from logic.board import Board
-from logic.move import Move
-from logic.pieces.piece import Piece
-from logic.position import Position
-from view.view import View
-
-
-class Controller:
-    def __init__(self, board: Board, view: View) -> None:
-        self._board = board
-        self._view = view
-
-        self._view.set_controller(self)
-        self._reset_selection()
-
-        self._selected_piece: Piece = None
-        self._legal_moves: list[Move] = []
-
-    def _reset_selection(self):
-        self._selected_piece = None
-        self._legal_moves = []
-        self._view.update_board(self._board, self._selected_piece, self._legal_moves)
-
-
-    def _show_legal_moves(self, pos: Position):
-        piece = self._board.piece_at(pos.x, pos.y)
-
-        if piece:
-            if piece.colour != self._board._turn:
-                return
-            self._selected_piece = piece
-            self._legal_moves = piece.legal_moves(self._board)
-            self._view.update_board(self._board, self._selected_piece, self._legal_moves)
-        else:
-            self._reset_selection()
-
-    def _make_move(self, move: Move) -> None:
-        self._board = self._board.make_move(move)
-        self._reset_selection()
-
-    def on_tile_selected(self, x: int, y: int) -> None:
-        pos = Position(x, y)
-
-        piece = self._board.piece_at(x, y)
-
-        if self._selected_piece is None \
-            or (piece is not None and piece != self._selected_piece and piece.colour == self._selected_piece.colour):
-            self._show_legal_moves(pos)
-        else:
-            legal_moves_positions = [move for move in self._legal_moves if move.pos == pos]
-            assert len(legal_moves_positions) <= 1, f"Apparently we can make multiple moves towards {pos.to_algebraic()} with {type(self._selected_piece)}, which doesn't make sense..."
-
-            if len(legal_moves_positions) == 0: # click on a square outside of the possible moves
-                self._reset_selection()
-            else:
-                move = legal_moves_positions[0]
-                self._make_move(move)
-
-        if self._board.is_checkmate_for(self._board._turn):
-            self._view.notify_checkmate(self._board._turn)
-            
-        if self._board.is_stalemate_for(self._board._turn):
-            self._view.notify_stalemate(self._board._turn)

python/src/logic/board.py

@@ -1,360 +0,0 @@
-from logic.move import CastleSide, Move
-from logic.pieces.bishop import Bishop
-from logic.pieces.king import King
-from logic.pieces.knight import Knight
-from logic.pieces.queen import Queen
-from logic.pieces.rook import Rook
-from logic.pieces.pawn import Pawn
-from logic.pieces.piece import Colour, Piece
-from logic.position import Position
-
-from typing import Type
-
-class Board:
-    def __init__(self) -> None:
-        self._white: dict[Position, Piece] = {}
-        self._black: dict[Position, Piece] = {}
-        self._turn = None
-        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]:
-        assert len(c) == 1, f"The piece {c} isn't denoted by 1 character"
-        c = c.lower()
-        if c == "p":
-            return Pawn
-        if c == "r":
-            return Rook
-        if c == "n":
-            return Knight
-        if c == "b":
-            return Bishop
-        if c == "q":
-            return Queen
-        if c == "k":
-            return King
-        raise ValueError(f"Unknown piece '{c}'")
-
-    @staticmethod
-    def setup_FEN_position(position: str) -> "Board":
-        ret = Board()
-        index = 0
-
-        # -- Pieces
-        pieces = "prnbqk" # possible pieces
-        numbers = "12345678" # possible number of empty squares
-
-        x = 0
-        y = 7 # FEN starts from the top left, so 8th rank
-        for c in position:
-            index += 1
-            if c == " ":
-                break
-            if c in pieces or c in pieces.upper():
-                pos = Position(x, y)
-                piece = Board._piece_class_from_char(c)
-                if c.isupper():
-                    ret._white[pos] = piece(pos, Colour.WHITE)
-                else:
-                    ret._black[pos] = piece(pos, Colour.BLACK)
-
-                x += 1
-                continue
-            if c in numbers:
-                x += int(c)
-            if c == '/':
-                x = 0
-                y -= 1
-
-
-        # -- Active colour
-        if position[index] == "w":
-            ret._turn = Colour.WHITE
-        elif position[index] == "b":
-            ret._turn = Colour.BLACK
-        else:
-            raise ValueError(f"The FEN position is malformed, the active colour should be either 'w' or 'b', but is '{position[index]}'")
-        index += 2
-
-
-        # -- Castling Rights
-        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_rights.add(CastleSide.King)
-            if c == "Q":
-                ret._white_castling_rights.add(CastleSide.Queen)
-            if c == "k":
-                ret._black_castling_rights.add(CastleSide.King)
-            if c == "q":
-                ret._black_castling_rights.add(CastleSide.Queen)
-
-        # -- En passant target
-        if position[index] != "-":
-            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
-
-    def piece_at(self, x: int, y: int) -> Piece | None:
-        pos = Position(x, y)
-        white_piece = self._white.get(pos, None)
-        black_piece = self._black.get(pos, None)
-
-        assert white_piece == None or black_piece == None, f"There are two pieces at the same position {pos}, this shouldn't happen!"
-
-        if white_piece != None:
-            return white_piece
-        return black_piece
-
-    def is_check_for(self, colour: Colour) -> bool:
-        """ Is it check for the defending colour passed as parameter """
-        defending_pieces, attacking_pieces = (self._white, self._black) if colour == Colour.WHITE else (self._black, self._white)
-
-        kings = [piece for piece in defending_pieces.values() if type(piece) == King]
-        assert len(kings) == 1, f"We have more than one king for {colour}, that is no buono..."
-        king = kings[0]
-
-        for piece in attacking_pieces.values():
-            possible_pos = []
-            if type(piece) == King: 
-                # special case for the king, because it creates infinite recursion (since he looks if he's walking into a check)
-                for dx in [-1, 0, 1]:
-                    for dy in [-1, 0, 1]:
-                        x, y = piece.pos.x + dx, piece.pos.y + dy
-                        if Position.is_within_bounds(x, y):
-                            possible_pos.append(Position(x, y))
-            else:
-                possible_pos += [move.pos for move in piece.legal_moves(self, looking_for_check=True)]
-            if king.pos in possible_pos:
-                return True
-        return False
-
-    def is_checkmate_for(self, colour: Colour) -> bool:
-        """ Is it checkmate for the defending colour passed as parameter """
-        return self.is_check_for(colour) and self._no_legal_moves_for(colour)
-
-    def is_stalemate_for(self, colour: Colour) -> bool:
-        """ Is it stalemate for the defending colour passed as parameter """
-        return not self.is_check_for(colour) and self._no_legal_moves_for(colour)
-
-    def _no_legal_moves_for(self, colour: Colour) -> bool:
-        """ Return true if there are indeed no legal moves for the given colour (for checkmate or stalemate)"""
-        pieces = self._white if colour == Colour.WHITE else self._black
-        for piece in pieces.values():
-            if len(piece.legal_moves(self)) > 0:
-                return False
-        return True
-
-    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) 
-
-        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_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]
-        pieces_moving[move.pos] = piece.move_to(move.pos)
-        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..."
-            del pieces_moving[rook_pos]
-            new_rook_pos = Position(5, piece.pos.y)
-            pieces_moving[new_rook_pos] = Rook(new_rook_pos, piece.colour)
-
-        elif move.castle_side == CastleSide.Queen:
-            rook_pos = Position(0, piece.pos.y)
-            assert rook_pos in pieces_moving and type(pieces_moving[rook_pos]) == Rook, "Either rook is absent from the queen side or you are trying to castle with something else than a rook..."
-            del pieces_moving[rook_pos]
-            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_rights = set()
-
-            if type(piece) == Rook:
-                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_rights = set()
-
-            if type(piece) == Rook:
-                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,51 +0,0 @@
-# from logic.pieces.piece import Piece
-from typing import Type
-from logic.position import Position
-from enum import Enum
-
-class CastleSide(Enum):
-    Neither = ""
-    King = "O-O"
-    Queen = "O-O-O"
-
-class Move:
-    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")
-
-    @staticmethod
-    def from_algebraic(move: str) -> "Move":
-        raise NotImplementedError("The move can't be translated from algbraic notation, as it was not implemented")
-
-    def __str__(self) -> str:
-        if self.castle_side == CastleSide.King:
-            return "O-O"
-        if self.castle_side == CastleSide.Queen:
-            return "O-O-O"
-
-        ret = ""
-        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()
-            if self.is_capturing:
-                ret += "x"
-            ret += str(self.pos)
-        
-        return ret
-    
-    def __repr__(self) -> str:
-        return str(self)

python/src/logic/pieces/bishop.py

@@ -1,24 +0,0 @@
-from logic.move import Move
-from .piece import Piece
-
-class Bishop(Piece):
-    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
-        ret = []
-
-        # looking north east
-        ret.extend(self._look_direction(board, 1, 1))
-
-        # looking south east
-        ret.extend(self._look_direction(board, 1, -1))
-
-        # looking south west
-        ret.extend(self._look_direction(board, -1, -1))
-
-        # looking north west
-        ret.extend(self._look_direction(board, -1, 1))
-
-        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

@@ -1,69 +0,0 @@
-from logic.move import CastleSide, Move
-from logic.position import Position
-from .piece import Piece
-
-class King(Piece):
-    def legal_moves(self, board: "Board") -> list[Move]:
-        ret = []
-
-        # -- Regular moves
-        for dx in [-1, 0, 1]:
-            for dy in [-1, 0, 1]:
-                if dx == 0 and dy == 0: # skip current position
-                    continue
-                x = self.pos.x + dx
-                y = self.pos.y + dy
-                move = self._move_for_position(board, x, y)
-                if move:
-                    board_after_move = board.make_move(move)
-                    if not board_after_move.is_check_for(self.colour):
-                        ret.append(move)
-
-        if board.is_check_for(self.colour):
-            return self.keep_only_blocking(ret, board)
-
-        # -- Castles
-        castling_rights = board.castling_rights_for(self.colour)
-        if len(castling_rights) == 0:
-            return ret
-
-        if CastleSide.King in castling_rights:
-            clear = True
-            for dx in range(1, 3):
-                x = self.pos.x + dx
-                y = self.pos.y
-                if board.piece_at(x, y) is not None:
-                    clear = False
-                    break
-
-                move = self._move_for_position(board, x, y)
-                board_after_move = board.make_move(move)
-                if board_after_move.is_check_for(self.colour):
-                    clear = False
-                    break
-
-            if clear:
-                ret.append(Move(self, Position(6, self.pos.y), castle_side=CastleSide.King))
-
-        if CastleSide.Queen in castling_rights:
-            clear = True
-            for dx in range(1, 4):
-                x = self.pos.x - dx
-                y = self.pos.y
-
-                if board.piece_at(x, y) is not None:
-                    clear = False
-                    break
-
-                move = self._move_for_position(board, x, y)
-                board_after_move = board.make_move(move)
-                if dx < 3 and board_after_move.is_check_for(self.colour):
-                    clear = False
-                    break
-
-            if clear:
-                ret.append(Move(self, Position(2, self.pos.y), castle_side=CastleSide.Queen))
-
-        return ret
-
-

python/src/logic/pieces/knight.py

@@ -1,23 +0,0 @@
-from .piece import Piece
-
-class Knight(Piece):
-    def letter(self):
-        return "n"
-
-    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list["Move"]:
-        ret = []
-        for dx, dy in [
-            (+2, +1), (+1, +2), # north east
-            (+2, -1), (+1, -2), # south east
-            (-2, -1), (-1, -2), # south west
-            (-2, +1), (-1, +2), # north west
-        ]:
-            move = self._move_for_position(board, self.pos.x + dx, self.pos.y + dy)
-            if move is not None:
-                ret.append(move)
-
-        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

@@ -1,80 +0,0 @@
-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/piece.py

@@ -1,65 +0,0 @@
-from logic.move import Move
-from logic.position import Position
-from enum import Enum
-
-
-class Colour(Enum):
-    WHITE = "white"
-    BLACK = "black"
-
-    def __str__(self) -> str:
-        return self.value
-
-class Piece:
-    def __init__(self, pos: Position, colour: Colour) -> None:
-        self.pos = pos
-        assert colour == Colour.WHITE or colour == Colour.BLACK, "The colour of the piece must be either Piece.WHITE or Piece.BLACK"
-        self.colour = colour
-
-    def letter(self):
-        return type(self).__name__[0].lower()
-
-    def keep_only_blocking(self, candidates: list[Move], board: "Board") -> list[Move]:
-        ret = []
-        for move in candidates:
-            board_after_move = board.make_move(move)
-            if not board_after_move.is_check_for(self.colour):
-                ret.append(move)
-        return ret
-
-    def _look_direction(self, board: "Board", mult_dx: int, mult_dy: int):
-        ret = []
-        for d in range(1, 8):
-            dx = mult_dx * d
-            dy = mult_dy * d
-
-            move = self._move_for_position(board, self.pos.x + dx, self.pos.y + dy)
-            if move is None:
-                break
-            ret.append(move)
-            if move.is_capturing:
-                break
-
-        return ret
-
-    def _move_for_position(self, board: "Board", x: int, y: int) -> Move | None:
-        if not Position.is_within_bounds(x, y):
-            return None
-        piece = board.piece_at(x, y) 
-
-        if piece is None:
-            return Move(self, Position(x, y))
-
-        if piece.colour != self.colour:
-            return Move(self, Position(x, y), is_capturing=True)
-        return None
-
-    def position(self) -> Position:
-        return self.pos
-
-    def move_to(self, pos: Position) -> "Piece":
-        ret = type(self)(pos, self.colour)
-        return ret
-
-    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list["Move"]:
-        raise NotImplementedError(f"Can't say what the legal moves are for {type(self).__name__}, the method hasn't been implemented yet")

python/src/logic/pieces/queen.py

@@ -1,35 +0,0 @@
-from logic.move import Move
-from .piece import Piece
-
-class Queen(Piece):
-    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
-        ret = []
-
-        # looking north east
-        ret.extend(self._look_direction(board, 1, 1))
-
-        # looking south east
-        ret.extend(self._look_direction(board, 1, -1))
-
-        # looking south west
-        ret.extend(self._look_direction(board, -1, -1))
-
-        # looking north west
-        ret.extend(self._look_direction(board, -1, 1))
-
-        # looking east
-        ret.extend(self._look_direction(board, 1, 0))
-
-        # looking south
-        ret.extend(self._look_direction(board, 0, -1))
-
-        # looking west
-        ret.extend(self._look_direction(board, -1, 0))
-
-        # looking north
-        ret.extend(self._look_direction(board, 0, 1))
-
-        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

@@ -1,23 +0,0 @@
-from logic.move import Move
-from .piece import Piece
-
-class Rook(Piece):
-    def legal_moves(self, board: "Board", / , looking_for_check = False) -> list[Move]:
-        ret = []
-
-        # looking east
-        ret.extend(self._look_direction(board, 1, 0))
-
-        # looking south
-        ret.extend(self._look_direction(board, 0, -1))
-
-        # looking west
-        ret.extend(self._look_direction(board, -1, 0))
-
-        # looking north
-        ret.extend(self._look_direction(board, 0, 1))
-
-        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

@@ -1,43 +0,0 @@
-class Position:
-    _RANKS = range(1, 9)
-    _FILES = "abcdefgh"
-
-    _MIN_POS = 0
-    _MAX_POS = 7
-
-    def __init__(self, x, y) -> None:
-        assert x >= self._MIN_POS and x <= self._MAX_POS, f"Invalid argument: x should be between {self._MIN_POS} and {self._MAX_POS}, but is {x}"
-        assert y >= self._MIN_POS and y <= self._MAX_POS, f"Invalid argument: y should be between {self._MIN_POS} and {self._MAX_POS}, but is {y}"
-
-        self.x = x
-        self.y = y
-
-    @staticmethod
-    def is_within_bounds(x: int, y: int) -> bool:
-        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]}"
-
-    def __eq__(self, value: object, /) -> bool:
-        if type(value) != type(self):
-            return False
-        return value.x == self.x and value.y == self.y
-
-    def __hash__(self) -> int:
-        return hash((self.x, self.y))
-
-    def __str__(self) -> str:
-        return f"{Position._FILES[self.x]}{Position._RANKS[self.y]}"
-
-    def __repr__(self) -> str:
-        return str(self)

python/src/main.py

@@ -1,27 +0,0 @@
-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/src/view/gui.py

@@ -1,155 +0,0 @@
-import tkinter as tk
-from tkinter import messagebox
-from typing import Type
-from PIL import ImageTk, Image
-import os
-
-from logic.board import Board
-from logic.move import Move
-from logic.pieces.bishop import Bishop
-from logic.pieces.king import King
-from logic.pieces.knight import Knight
-from logic.pieces.pawn import Pawn
-from logic.pieces.piece import Colour, Piece
-from logic.pieces.queen import Queen
-from logic.pieces.rook import Rook
-from logic.position import Position
-from view.view import View
-
-class GUI(View):
-    def __init__(self) -> None:
-        super().__init__()
-
-        self.root = tk.Tk()
-        self.root.title("Chess Board")
-
-        self.tile_size = 80
-        board_size = self.tile_size * 8
-
-        self.canvas = tk.Canvas(self.root, width=board_size, height=board_size)
-        self.canvas.pack()
-
-        self.canvas.bind("<Button-1>", self._on_canvas_click)
-
-        self._piece_images = self._load_piece_images("res/")
-
-    def _piece_svg(self, root: str, piece: Type[Piece], colour: Colour) -> ImageTk.PhotoImage:
-        piece_name = piece.__name__.lower()
-
-        path = os.path.join(root, f"{"white" if colour == Colour.WHITE else "black"}-{piece_name}.png")
-        img = Image.open(path)
-
-        if img.mode == "LA":
-            img = img.convert(mode="RGBA")
-            img.save(path)
-
-        return ImageTk.PhotoImage(img)
-
-    def _load_piece_images(self, root: str) -> dict[Type[Piece], dict[Colour, ImageTk.PhotoImage]]:
-        ret = {}
-        for piece in [Pawn, Rook, Knight, Bishop, Queen, King]:
-            if piece not in ret:
-                ret[piece] = {}
-            ret[piece][Colour.WHITE] = self._piece_svg(root, piece, Colour.WHITE)
-            ret[piece][Colour.BLACK] = self._piece_svg(root, piece, Colour.BLACK)
-
-        return ret
-
-    def _on_canvas_click(self, event):
-        x, y = event.x // self.tile_size, event.y // self.tile_size
-        y = 7 - y
-
-        self._controller.on_tile_selected(x, y)
-
-    def notify_checkmate(self, colour: Colour) -> None:
-        messagebox.showinfo("Checkmate",  f"{colour} is currently checkmated") 
-        
-    def notify_stalemate(self, colour: Colour) -> None:
-        messagebox.showinfo("Stalemate",  f"{colour} is currently stalemated") 
-        
-
-    def update_board(self, board: Board, selected_piece: Piece, legal_moves: list[Move]) -> None:
-        self.canvas.delete("all")
-        self._draw_chess_board(board, selected_piece, legal_moves)
-
-
-    def _draw_chess_board(self, board: Board, selected_piece = None, legal_moves = []):
-        colours = ["#EDD6B0", "#B88762"]  # Light and dark squares
-        alt_colours = ["#F6EB72", "#DCC34B"]  # Light and dark squares, when selected
-        circle_colours = ["#CCB897", "#9E7454"] # circles to show legal moves
-
-        for y in range(8):
-            for x in range(8):
-                colour = colours[(x + y) % 2]
-                pos = Position(x, 7-y)
-                if selected_piece is not None and pos == selected_piece.pos:
-                    colour = alt_colours[(x + y) % 2]
-
-                self.canvas.create_rectangle(
-                    x * self.tile_size, 
-                    y * self.tile_size, 
-                    (x + 1) * self.tile_size, 
-                    (y + 1) * self.tile_size, 
-                    fill=colour,
-                    outline=colour,
-                )
-
-                if selected_piece is not None:
-                    possible_positions = [move.pos for move in legal_moves] 
-                    if pos in possible_positions:
-                        colour = circle_colours[(x + y) % 2]
-                        move = [move for move in legal_moves if move.pos == pos][0]
-                        if move.is_capturing:
-                            radius = .40 * self.tile_size
-                            self.canvas.create_oval(
-                                (x + .5) * self.tile_size - radius,
-                                (y + .5) * self.tile_size - radius,
-                                (x + .5) * self.tile_size + radius,
-                                (y + .5) * self.tile_size + radius,
-                                fill="",
-                                outline=colour,
-                                width=.075 * self.tile_size,
-                            )
-                        else:
-                            radius = .15 * self.tile_size
-                            self.canvas.create_oval(
-                                (x + .5) * self.tile_size - radius,
-                                (y + .5) * self.tile_size - radius,
-                                (x + .5) * self.tile_size + radius,
-                                (y + .5) * self.tile_size + radius,
-                                fill=colour,
-                                outline=colour,
-                            )
-
-                piece = board.piece_at(x, 7-y)
-
-                if piece:
-                    self.canvas.create_image(
-                        (x + 0.5) * self.tile_size, 
-                        (y + 0.9) * self.tile_size, 
-                        image=self._piece_images[type(piece)][piece.colour],
-                        anchor=tk.S,
-                    )
-
-                # Cell annotations
-                text_colour = colours[(x + y + 1) % 2] # the other colour
-
-                if x == 0: # numbers in the top left of the first column
-                    self.canvas.create_text(
-                        (x + .15) * self.tile_size, 
-                        (y + .15) * self.tile_size, 
-                        text=8-y, 
-                        fill=text_colour, 
-                        font=("Arial", 12, "bold")
-                    )
-                if y == 7: # numbers in the top left of the first column
-                    self.canvas.create_text(
-                        (x + .85) * self.tile_size, 
-                        (y + .85) * self.tile_size, 
-                        text="abcdefgh"[x], 
-                        fill=text_colour, 
-                        font=("Arial", 12, "bold")
-                    )
-
-    def show(self) -> None:
-        self.root.mainloop()

python/src/view/tui.py

@@ -1,57 +0,0 @@
-from logic.board import Board
-from logic.pieces.bishop import Bishop
-from logic.pieces.king import King
-from logic.pieces.knight import Knight
-from logic.pieces.pawn import Pawn
-from logic.pieces.piece import Piece
-from logic.pieces.queen import Queen
-from logic.pieces.rook import Rook
-from view.view import View
-
-class TUI(View):
-    def __init__(self, board: Board) -> None:
-        super().__init__(board)
-
-    def show(self) -> None:
-        board_view = [
-            [" " for _ in range(0, 8)]
-            for _ in range(0, 8)
-        ]
-
-        for pos, piece in self.board._white.items():
-            board_view[pos.y][pos.x] = self.string_of(piece).upper()
-
-        for pos, piece in self.board._black.items():
-            board_view[pos.y][pos.x] = self.string_of(piece)
-
-        # we reverse the board because (0, 0) in in the bottom left, not top left
-        board_view.reverse()
-        print(self.to_string(board_view))
-
-    def to_string(self, board_view: list[list[str]]) -> str:
-        VER_SEP = "|"
-        HOR_SEP = "-"
-        ROW_SEP = HOR_SEP * (2*len(board_view[0]) + 1)
-        ret = ROW_SEP + "\n"
-        for row_view in board_view:
-            row_str = VER_SEP + VER_SEP.join(row_view) + VER_SEP
-            ret += row_str + "\n"
-            ret += ROW_SEP + "\n"
-
-        return ret
-
-    def string_of(self, piece: Piece) -> str:
-        type_ = type(piece) 
-        if type_ == Pawn:
-            return "p"
-        if type_ == Queen:
-            return "q"
-        if type_ == Bishop:
-            return "b"
-        if type_ == Knight:
-            return "n"
-        if type_ == Rook:
-            return "r"
-        if type_ == King:
-            return "k"
-        raise ValueError(f"Unknown piece type {type(piece)}")

python/src/view/view.py

@@ -1,24 +0,0 @@
-from logic.board import Board
-from logic.move import Move
-from logic.pieces.piece import Colour, Piece
-
-
-class View:
-    def __init__(self) -> None:
-        self._controller: "Controller" = None
-
-    def show(self) -> None:
-        raise NotImplementedError(f"Can't show the board, the show() method of {type(self)} is not implemented")
-
-    def update_board(self, board: Board, selected_piece: Piece, legal_moves: list[Move]) -> None:
-        raise NotImplementedError(f"Can't update the board, the update_board() method of {type(self)} is not implemented")
-
-    def notify_checkmate(self, colour: Colour) -> None:
-        raise NotImplementedError(f"Can't notify of the checkmate, the notify_checkmate() method of {type(self)} is not implemented")
-
-    def notify_stalemate(self, colour: Colour) -> None:
-        raise NotImplementedError(f"Can't notify of the stalemate, the notify_stalemate() method of {type(self)} is not implemented")
-
-    def set_controller(self, controller: "Controller") -> None:
-        self._controller = controller
-

python/tests/fen.py

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

@@ -1,30 +0,0 @@
-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"))

res/equal_positions.fen

@@ -0,0 +1,500 @@
+r1bq1rk1/pp3pbp/2n1pnp1/2pp4/2P5/2NPP1P1/PP2NPBP/R1BQ1RK1 w - - 0 9
+2kr2nr/ppp1b1pp/2n5/2N1p3/P5q1/3PQN2/1PP2PP1/R3KB1R w KQ - 0 16
+r4rk1/pp1b1ppp/4pn2/2b5/2P5/2N5/PP2BPPP/R1BR2K1 w - - 0 13
+r1bq1rk1/1p3ppp/p1n1pn2/2b5/2B5/2N1PN2/PP1B1PPP/R2Q1RK1 w - - 0 10
+1q2rrk1/pp1n1ppp/2pbpn2/3p3b/2PP4/1P1BPN1P/PB1NQPP1/2RR2K1 w - - 7 14
+r2qr1k1/pp3ppp/4b1n1/2pNb3/2P5/1P5P/PB2BPP1/R2Q1RK1 w - - 0 17
+3q1rk1/3nbpp1/r1p1pn1p/2Pp2B1/3P4/2N1PN2/5PPP/2RQ1RK1 w - - 0 15
+rnbq1rk1/pp4pp/3b4/2pPpp2/2P1p3/4P1P1/PP1N1PBP/R1BQ1RK1 w - - 0 12
+r2qkb1r/pp4pp/2npbn2/2p1p3/7N/2PP4/PP2BPPP/RNBQ1RK1 w kq - 3 9
+r4rk1/pbpn2pp/1p2p1q1/4Pp2/2P5/5PP1/PPQB2BP/R3R1K1 w - - 1 18
+rn2k2r/pp1b1ppp/1qpp1b2/3Pp3/2P1P3/2N2N2/PP3PPP/R2QKB1R w KQkq - 0 9
+r2qr1k1/p1p2pp1/2pp1n1p/2b3B1/4P1b1/2NB4/PPPQ1PPP/R4RK1 w - - 0 12
+r1bqr1k1/ppp2p1p/3p1pn1/3P4/2PQ4/5NP1/P4PBP/R4RK1 w - - 0 15
+r3k1nr/pp3bpp/2pb1n2/5p1P/8/2NP3N/PPP2PB1/R1B1K2R w KQkq - 10 17
+r2qk1nr/pp3pp1/2nb2b1/2ppp3/6P1/P2PP3/1PPNQ1BP/R1B1K1NR w KQkq - 1 10
+r1bqk2r/p4ppp/2p2n2/3pp3/4P3/P1b2P2/1PPB2PP/R2QKB1R w KQkq - 0 10
+r2q1rk1/pn1bbppp/2p2n2/4p1N1/1P6/1BP5/P2P1PPP/RNBQK2R w KQ - 3 12
+r1bq1rk1/1p2bp1p/p2ppnpP/2p1n3/4P3/1BPP2B1/PP2QPP1/RN2K1NR w KQ - 0 13
+r1bq1rk1/4bpp1/p3pn1p/1p2n3/2pP1B2/2N1P2P/PPB2PP1/R2Q1RK1 w - - 0 14
+2kr2nr/1ppn1pp1/p2p3p/3Pp1q1/4P3/2N2B2/PPP2PPP/R1Q2RK1 w - - 2 12
+r1b2rk1/1pp3p1/p1nb1q1p/3p1p2/1P1P4/P3PN1P/1B1n1PP1/RB1Q1RK1 w - - 0 14
+1k1r3r/pppnqpp1/3b2p1/3B2P1/8/4P1PP/PPPNQ3/2KR3R w - - 1 18
+r3k2r/ppp2ppp/1nn5/4P3/1bP3b1/5N2/PP2BPPP/R1BNK2R w KQkq - 5 10
+r2q1rk1/1pp1ppbp/p2p1np1/2nP1b2/2P5/1PN1PN2/PB2BPPP/R2QK2R w KQ - 0 10
+r2qk2r/pp3ppp/2n1bn2/2bp4/8/2N1P1P1/PP3PBP/R1BQK1NR w KQkq - 3 9
+1r3rk1/p1q2ppp/2pb1n2/2pp4/5P2/3P1Q1P/PPP1N1P1/R1B1R1K1 w - - 5 15
+2r2rk1/1p1nqpbp/pn4p1/Q1pp4/8/2PPB2P/PP1NNPP1/R4RK1 w - - 2 16
+3q1rk1/4ppbp/3p1np1/1r6/1p1BP3/1P3P2/P2Q2PP/2RN1RK1 w - - 0 18
+r2q1rk1/4bppp/pp2p3/2p2n2/8/1PBPP1P1/P4PNP/2RQ1RK1 w - - 1 16
+r2qkb1r/2p1pppp/p1n1b3/1p6/B2P4/2P1P3/P4PPP/R1BQK1NR w KQkq - 0 9
+r2q1rk1/1p2bppp/p1n1pn2/3p4/3P4/2N1PB2/PPQ2PPP/R1B1R1K1 w - - 2 12
+r1b1kbnr/p1p2ppp/2p5/8/4q3/5N2/PPP2PPP/RNBQK2R w KQkq - 0 9
+r1b1kbnr/4pppp/p7/1P6/1np5/8/1P2PPPP/R1BNKBNR w KQkq - 1 9
+2kr1br1/pp1b2pp/2n1p3/5p2/8/1PB1P1P1/P3NP1P/R3KB1R w KQ - 1 14
+rn1q1rk1/pb2bppp/1p2pn2/3p4/3P4/2N1PN1P/PP2BPP1/R1BQ1RK1 w - - 2 10
+rnb1k2r/pp2n1pp/2pb1p2/3pN3/3P4/2N5/PPP2PPP/R1B1KB1R w KQkq - 0 9
+rn1qr1k1/pb3ppp/1p2pn2/2ppN3/2PP4/P1b1P3/1P1BBPPP/R2Q1RK1 w - - 0 11
+r1b2rk1/2qn1ppp/p2bpn2/1p1p4/1P1P4/P2B1NP1/2P1NP1P/R1BQ1RK1 w - - 0 12
+rn1qk2r/pbp2pp1/1p2pb1p/3p4/3P4/2N1PNP1/PPP2PBP/R2QK2R w KQkq - 0 9
+r4rk1/pp2ppbp/2n3p1/2qp1b2/3P4/1P2P3/PB1NBPPP/2R2RK1 w - - 0 15
+r4rk1/ppBq1ppp/2n5/2nN3b/1P6/P4N1P/4BPP1/b2Q1RK1 w - - 0 17
+r2qk2r/p2n1ppp/3bpn2/3p1b2/3P4/2N5/PP2PPPP/R1BQKBNR w KQkq - 5 9
+r2q1rk1/ppp1bppp/1nn1p3/8/3PP1b1/P1N2N2/1P2BPPP/R1BQ1RK1 w - - 5 10
+r2q1rk1/pppb1ppn/2np3p/4p3/1P2P1P1/P2PbN1P/2P1QPB1/RN3RK1 w - - 0 12
+2kr3r/ppp1nppp/4b3/3n4/2B5/2P2N2/PP3PPP/RN3RK1 w - - 0 12
+r3kb1r/pp1bnppp/2n1p3/q2pP3/N2P1P2/3B1N2/PP4PP/R1BQK2R w KQkq - 9 11
+2kr2nr/pp1b4/2n1p3/P2pPpqp/2pP2p1/2P1N1P1/1P3PBP/RN1QK2R w KQ f6 0 15
+r2q1rk1/1p1bbppp/p1n1p3/8/4P3/2P1BN2/P2QBPPP/R3K2R w KQ - 4 13
+r3r3/pp1kbppp/2bp4/3n4/3N1B2/2N5/PPP2PPP/R3R1K1 w - - 6 15
+r2qk2r/pp3ppp/2npbn2/4p1B1/1b2P3/2N2P2/PPPQN1PP/R3KB1R w KQkq - 1 10
+rnbq1rk1/pp2b1pp/2p5/3p1p2/3Pn2N/2N3P1/PP2PPBP/R1BQ1RK1 w - - 7 10
+r3kb1r/1pp1qpp1/p1n4p/3pPb2/3P1P2/5N2/PP4PP/RNBQ1RK1 w kq - 2 12
+r4bnr/1pkb2pp/p1n2p2/2p1p3/2N5/2P1P1P1/PP2NPBP/R1B1K2R w KQ - 2 14
+2kr3r/ppp1nppp/6q1/5b2/3p4/3P1P2/PPPQ1KPP/R1B2B1R w - - 0 15
+r3k2r/1p1qbppp/p3pn2/3p2B1/8/2N2Q2/PPP2PPP/2KRR3 w kq - 2 17
+r3kb1r/pp3p1p/1qn1bpp1/1B1p4/3P4/1QN1P3/PP3PPP/R3K1NR w KQkq - 3 10
+rnbq1rk1/5ppp/1p1b1n2/3pp3/1P6/P1P1P3/1B3PPP/RN1QKBNR w KQ - 1 9
+r1bq1rk1/ppp2pp1/2n2p1p/8/1bBP4/2N1PN2/PP3PPP/R2QK2R w KQ - 1 9
+r3k3/pp1n1ppr/3bb2p/2p5/8/4BN2/PPP2PPP/RN2K2R w KQq - 0 13
+r1bqr1k1/pp1nppbp/2pp2p1/3P4/2PP4/1P1BB3/P2Q1PPP/R3K1NR w KQ - 2 12
+r3kb1r/1p1n1ppp/p1p1p3/2Pp1bB1/3P4/1PN2P2/1P2P1PP/R3KB1R w KQkq - 0 12
+r3k2r/ppp1n1pp/2nppq2/4p3/1P1bP3/P1N2N1P/2PP1PP1/R1BQ1RK1 w kq - 1 10
+rn1qr1k1/1p3pbp/p2p1np1/2pP1bB1/2P5/2N2N2/PP2BPPP/R2Q1RK1 w - - 2 12
+1k1rr3/1ppnqppp/4b3/1N1pP3/8/3B4/PPPbQPPP/1K1R3R w - - 0 16
+3rk2r/ppp1bppp/5nb1/4p3/2B1P3/5P1P/PPP3P1/RNB2RK1 w k - 1 12
+r2qk2r/p1pn1pp1/2pbpn1p/3p4/3P1B2/P3PN1P/1PP1NPP1/R2QK2R w KQkq - 0 11
+r1bq1rk1/pp3pbp/2np1np1/2p1p3/4P3/P1NP1N1P/1PPBBPP1/R2QK2R w KQ - 4 9
+r1bq1r2/pp2ppkp/3p1np1/8/3nP3/2N5/PPPQBPPP/R3K2R w KQ - 0 11
+rn1q1rk1/pb3ppp/1p2p3/2pn4/8/1P1P1NP1/Pb1NPPBP/R1Q2RK1 w - - 0 12
+r4b1r/pppkp1p1/2nq1nQ1/3p3p/3P3P/4PP2/PPP5/RNB1K1NR w KQ - 3 12
+r2qk1nr/1bp2ppp/p3p3/1p2P3/1P1P4/1B6/P2N1PPP/R2Q1RK1 w kq - 4 18
+r1bqk2r/p1p2ppp/2p5/3p4/3Pn3/3Q1N2/PP3PPP/RN3RK1 w kq - 0 12
+r2q1rk1/pbp1bppn/1p1p3p/8/4P2B/2N1QN2/PPP2PPP/R2R2K1 w - - 4 14
+r2q1rk1/p2bbppp/2pp1n2/4p1B1/Q3P3/2N2N2/PPP2PPP/R4RK1 w - - 8 11
+r1bqk2r/2p1bpp1/p1np1n1p/1p2p3/2B1P3/2NPBN1P/PPPQ1PP1/R3K2R w KQkq - 0 9
+r2q1rk1/1bp1bppp/p1np1n2/1p2p3/4P3/PB1P1N1P/1PP2PP1/RNBQ1RK1 w - - 1 10
+rn1q1rk1/pp2p1bp/3ppnpB/2p5/3PP3/5P2/PPPQ2PP/RN2K1NR w KQ - 0 9
+rn3rk1/3pqppp/b1pb4/1p2p3/2P1P3/BB1P1N2/5PPP/R2Q1RK1 w - - 1 16
+r1bq1rk1/1pp1npbp/p1np2p1/4p3/1PP1P3/P2PBN2/4BPPP/RN1QK2R w KQ - 2 9
+r1b2rk1/1pq1ppbp/p2p1np1/8/3NP3/2NQ1P2/PPP3PP/R1B2RK1 w - - 0 13
+rnb2rk1/4qppp/p2pp3/2n5/1p1N4/1B4N1/PPP2PPP/R2QR1K1 w - - 4 14
+r1q1kb1r/1p1npppp/p1p3b1/P1Pp4/1P1PnB2/2N4P/2Q1PPP1/R3KBNR w KQkq - 5 11
+r2qk1nr/p2bbppp/2p1p3/3pP3/3P1P2/5N2/PP4PP/RNBQK2R w KQkq - 2 10
+r1b2rk1/1pq1bppp/p1nppn2/6B1/P2NP3/1BN5/1PP2PPP/R2Q1RK1 w - - 7 11
+r2qk2r/1bpn1pb1/pp1p2pp/8/1PPNP3/P2nBN1P/5PP1/1R1Q1RK1 w kq - 0 16
+r1bqnrk1/pp1nbp1p/2p3p1/3p2B1/3P4/2NBP3/PPQ1NPPP/R4RK1 w - - 4 11
+r2q1rk1/pbpnnppp/1p2p3/8/3PPP2/2NB1N2/PP4PP/R2QK2R w KQ - 4 11
+r1b1k2r/1pp1bppp/p1p2n2/8/8/5N2/PPPPKPPP/RNB1R3 w kq - 3 10
+r2qk2r/1b2nppp/p3p3/3pP3/8/1N1Qb3/PP3PPP/RN3RK1 w kq - 0 14
+r3kb1r/ppp2ppp/2n2n2/4p3/2P5/3BPb1P/PP3PP1/RNBK3R w kq - 0 9
+r3kb1r/ppp2pp1/2n3qp/4p3/2P3b1/P2P1N2/1P2BPPP/R1BQ1RK1 w kq - 1 11
+rnb1k3/ppq1b2r/2p1pnN1/3p4/3P1P1P/2N5/PPPB2P1/R2QK2R w KQq - 1 14
+r2qrbk1/pp1bnppp/3p4/3Pp3/8/1N4P1/PP2PPBP/R1BQ1RK1 w - - 1 14
+2kr3r/pppbbppp/3q4/4n3/2B2B2/2P2Q2/PP3PPP/RN3RK1 w - - 2 13
+rn2kbnr/pp2pppp/8/2p1P3/2Pp1B2/3P1q1P/PP3PP1/RN2KB1R w KQkq - 0 9
+r4rk1/5ppp/p4n2/2bp1qB1/8/2N5/PP3PPP/R2Q1RK1 w - - 4 16
+r1b2rk1/pppnqppp/8/4p3/4P2N/1P1P3P/1PP3P1/RN1QK2R w KQ - 0 13
+r1b1kb1r/p4ppp/2p5/2pp2B1/6n1/3P1N2/PPP1KPPP/RN5R w kq - 1 11
+rnbq1rk1/pp2bpp1/4pn1p/2p5/2BPP2B/2N2N2/PP3PPP/R2QK2R w KQ - 0 9
+r3kb1r/2Bn1ppp/2ppp1n1/8/2B1P3/2P5/PP3PPP/RN2K2R w KQkq - 3 13
+r1bq1rk1/ppp1bppp/1n6/4p3/8/1PN4P/1PPPNPP1/R1BQ1RK1 w - - 0 12
+r1bqk2r/np3ppp/1bpp1n2/pP2p3/P3P1P1/3P1N1P/2P2P2/RNBQKB1R w KQkq - 0 10
+r3k2r/2p1bpp1/p1nqp2p/1p1p1b2/1P1Pn3/PNPBPN1P/1B3PP1/R2QK2R w KQkq - 4 12
+r1bqk2r/1pp2pb1/p2p1npp/3Pp2n/1P2P3/2PB1PP1/P2NN2P/R1BQK2R w KQkq - 1 12
+r4rk1/pp2npp1/1qpNb2p/4P3/4P3/4N3/PPP3PP/R2Q1RK1 w - - 3 16
+1k1rr3/1pp3pp/p1nbRp1n/8/3P4/P1N2N1P/1P3PP1/R1B3K1 w - - 1 18
+r3k1nr/p3bpp1/1pqp3p/3Np3/4P2B/3Q1b2/PPP2PPP/R4RK1 w kq - 0 13
+2bqr1k1/r3bppp/2n1pn2/p1pp4/PpP5/1P1PPNP1/2QN1PBP/1RB2RK1 w - - 1 14
+r2qkb1r/2p2ppp/p1np4/1p2p2n/1P2P3/P7/R1PP1PPP/1NBQ1RK1 w kq - 0 12
+r1b1k1nr/1p4pp/1pn1pp2/3pP3/1b1P1P2/5N2/PP4PP/RNB1KB1R w KQkq - 1 10
+2rq1rk1/pp1bbppp/4pn2/2p1N1B1/8/2NP4/PPP2PPP/R2Q1RK1 w - - 5 11
+r2q1rk1/pp2bppp/2np1n2/2p1p3/4P3/1PNP1bPP/PBP2PB1/R2QK2R w KQ - 0 10
+r1bqkbnr/3p1pp1/n3p2p/1p1P4/p1p1P3/P1P2N2/BP1N1PPP/R1BQK2R w KQkq - 0 11
+r3k2r/pbqnbppp/1p2pn2/2pp4/Q1P5/P2P1NP1/1P1NPPBP/R1B2RK1 w kq - 1 10
+r3kb1r/pp1nppp1/2p2n1p/8/5q2/2NP1B2/PPP2PPP/R1B2RK1 w kq - 0 11
+r2q1rk1/ppp1ppbp/2np2p1/7n/2P1PP2/P1NPB2P/1P4P1/R2QKB1R w KQ - 1 12
+r2q1rk1/p1n2p2/3p2pp/1ppPp3/4P2b/2PB2NP/PP3PP1/R2Q1RK1 w - - 0 18
+r2q1rk1/p4ppp/1bp1p1n1/3pP3/1P1P4/P1N1BQ1P/5PP1/R3K2R w KQ - 3 15
+r2qk2r/pppb1ppp/3p1n2/2b1n3/3NPB2/2P4P/PP2BPP1/RN1QK2R w KQkq - 3 10
+rnbr2k1/pp3ppp/2p2bn1/4p3/2P5/1P2PNP1/PB3PBP/RN3RK1 w - - 0 12
+r1br2k1/pppnbpp1/4p2p/3q4/8/P2PBN1P/1PP1BPP1/R2Q1RK1 w - - 0 13
+r2qk1nr/ppp3bp/2n1bpp1/3p2P1/1P1Pp2P/4P3/P1PB1P2/RN1QKBNR w KQkq - 0 9
+2kr1b1r/p1p1pppp/2p1bn2/8/3P4/2N5/PPP2PPP/R1B1K1NR w KQ - 0 10
+r3kb1r/p4ppp/npp1pn2/2Pq4/N2P1B2/P7/1P3NPP/R2QK2R w KQkq - 2 15
+r2qk2r/pp3ppp/3b1n2/2np4/6b1/P3PN2/1P2BPPP/RNBQK2R w KQkq - 4 10
+r2qk2r/pp2bppp/3p4/2pnp3/3BP3/PP4P1/2PP1P1P/R2QK1NR w KQkq - 0 14
+rn1q1rk1/pbp1bppp/1p1pp1n1/8/2B1P3/P1NP1N1P/1PP2PP1/R1BQ1RK1 w - - 0 9
+r1b1k2r/pp4p1/1nppBn2/6Bp/3P4/P7/P4PPP/R3K1NR w KQkq - 4 14
+2k1r2r/1ppn4/p2qppbb/1P1p1n1p/P2P1P1P/2N1P2B/2P1N3/R1BQK2R w KQ - 1 16
+r1bq1rk1/p3b1pp/1p2p3/nBp1Pp2/3P4/2P1BN2/P1PQ2PP/R4RK1 w - - 4 14
+rnbqk2r/1p3ppp/p3pb2/8/2BP4/2N2N2/PP3PPP/R2QK2R w KQkq - 0 10
+r1bqk2r/pp1nbpp1/2p1pn1p/2Pp4/3P3B/2N1P3/PP3PPP/R2QKBNR w KQkq - 1 9
+r2qk2r/pp4bp/n1pp1ppn/4p1B1/4P2P/P1NP1QP1/1PPK1PB1/R6R w kq - 0 13
+r2qkb1r/1p3pp1/p1npbn1p/2p1p3/4P3/2NPBNP1/PPPQ1PBP/2KR3R w kq - 8 10
+2rqk2r/pp1nbpp1/2n1p1p1/3p2B1/3P2P1/2P2PN1/PP5P/RN1Q1RK1 w k - 2 15
+r1bq1rk1/pp1nppbp/2np2p1/8/2B1PB2/2N2N1P/PP2QPP1/R4RK1 w - - 1 11
+r2qkb1r/pp2pppp/2b2n2/1B2n3/4p3/P1N5/1PP1QPPP/R1B1K1NR w KQkq - 0 9
+r2qk1nr/pp1n2pp/2p1bp2/4b3/P7/1PB2N2/2PP2PP/RN1QKB1R w KQkq - 0 11
+2r1r1k1/ppqn1ppp/3b4/3Pp3/7N/1P4P1/P3QP1P/R1B2RK1 w - - 1 18
+rnbq1rk1/p3ppbp/1ppp2p1/4P3/3P1P2/2P3P1/PP4BP/RN1QK1NR w KQ - 0 10
+r3k2r/ppp2ppp/2n1p3/3pP1q1/3P3n/5B1P/PPP1NPP1/R2Q1RK1 w kq - 6 12
+rn2r1k1/ppp1bp2/3pbn1p/6p1/2N5/2NP2B1/PPP2PPP/2KR1B1R w - - 2 13
+1r1q1rk1/pb1pppbp/2n2np1/2p5/1p2P1P1/6NP/PPPPNPB1/R1BQ1RK1 w - - 2 11
+1rbq1rk1/b1p2pp1/2n4p/4p3/NnB5/3P1N1P/1P3PP1/R1BQ1R1K w - - 0 18
+r2q1rk1/pp1n1ppp/2p1bn2/3pp3/2P1P3/P1PPBN1P/4BPP1/R2QK2R w KQ - 0 11
+r2q1rk1/5ppp/p1p2nb1/3p4/1P2p3/4PPN1/1PP1N1PP/R2QK2R w KQ - 0 16
+r1bq1rk1/1p2nppp/p1npp3/3p4/3P4/2NBPN2/PPP2PPP/R2Q1RK1 w - - 2 9
+r2q1rk1/1p1n1ppp/p2pbb2/3Np3/4P3/1N6/PPP1BPPP/R2Q1RK1 w - - 2 12
+r4rk1/pp3ppp/5n2/2bq4/8/5N2/PP3PPP/R1BQ1RK1 w - - 0 15
+rn1qk2r/pp2ppbp/1n1p2p1/8/2PP2b1/5N2/PP2BPPP/RNBQ1RK1 w kq - 1 9
+rn1q1rk1/pbp1bppp/1p3n2/3p2B1/3P4/P1N1PN2/1P3PPP/R2QKB1R w KQ - 1 9
+rnbqk2r/1pp3pp/p2npp2/3p4/1P1P4/P3PN2/2P2PPP/RN1QKB1R w KQkq - 0 9
+r1b1q1k1/1p3pbp/p4np1/3pr3/3Q4/N1P1BB1P/PP3PP1/R3K2R w KQ - 0 15
+2rr2k1/pp2bpp1/1qp1pnp1/8/2PP1B2/1Q4P1/PP3PBP/3RR1K1 w - - 3 18
+rnbq1rk1/pp2bpp1/3p1n1p/2p3B1/2B5/5N2/PPPN1PPP/R2QR1K1 w - - 0 11
+r3kb1r/1p1b1pp1/pqn1p1p1/3pP3/P2P4/5N2/1P3PPP/RNBQ1RK1 w kq - 1 12
+r1b2rk1/1pp1qppn/p1n1p2p/3p4/3P1P2/NPPBPNP1/P6P/R2QK2R w KQ - 1 12
+r4rk1/ppp2ppp/2nq1b2/4p3/1PP3b1/P2P1N2/4BPPP/R1BQ1RK1 w - - 1 12
+r3kb1r/3n1pp1/2ppbn2/1p2p3/p3P2p/P1PPBP2/1PB1N1PP/RN3RK1 w kq - 2 14
+r1bq1rk1/p3ppbp/6p1/3p4/8/4BP2/PPP1B1PP/R2Q1RK1 w - - 0 13
+r2q1rk1/pp1bppbp/2np1np1/1B6/3NP3/2P1B3/PP1N1PPP/R2Q1RK1 w - - 6 10
+1r1qk1nr/p1pb1ppp/6n1/4P3/1b1PB3/2N5/PPP2PPP/R1BQK2R w KQk - 5 12
+r2qkb1r/pbpp2pp/1pn2p2/4p3/1P1P1Pn1/2P1PNP1/P2Q3P/R1B1KBNR w KQkq - 1 10
+r3kbnr/ppp2ppp/4b3/8/3p1P2/2N5/PPPP2PP/R1B1KB1R w KQkq - 0 9
+rnbq1rk1/1p2bpp1/p1p1pn1p/3pB3/1P1P4/P1P2N2/3NPPPP/R2QKB1R w KQ - 3 9
+r1b1k2r/pp1n1pp1/2pp1n2/4p1Bp/2B1P3/2PP4/P1P1NPPP/R3K2R w KQkq - 2 10
+r3r1k1/pp3pb1/3p1qpp/3Pp3/4P1b1/2NQ1N2/PP3PPP/R4RK1 w - - 0 16
+r1b1k1nr/1pq1bppp/p1n5/1Bpp4/P7/1P3N2/2PP1PPP/RNBQ1RK1 w kq - 0 9
+r2qk2r/1p1nbppp/p1p1pn2/3pB3/1P1P4/P2PPN2/5PPP/RN1QK2R w KQkq - 1 10
+r4rk1/pp3ppp/2n1bn2/3qp3/8/1NP1P3/P3BPPP/R1BQ1RK1 w - - 0 12
+rnbqr1k1/ppp2pp1/3p1b1p/P7/2PP4/3B1NP1/1P3PP1/RN1Q1RK1 w - - 3 15
+2kr1bnr/ppp1pppp/6b1/q5N1/3P4/2NnB3/PPP2PPP/R2Q1RK1 w - - 0 11
+r3k2r/pp2ppbp/2p3p1/3n1b2/N2n1N2/3P4/PPPB1PPP/R2BK2R w KQkq - 14 15
+r1bq1rk1/pp3ppp/8/4p2Q/1b1pN2P/1P1P2N1/1PP2PP1/R3K2R w KQ - 1 16
+rn1qkb1r/ppp2p2/5n1p/4p1p1/2BP1pb1/2N2N2/PPP3PP/R1BQ1RK1 w kq - 0 9
+rnb2k1r/ppp1q1pp/8/4N3/6n1/2Q5/PP3PPP/RNB1K2R w KQ - 1 12
+r1bq1rk1/ppp1bppp/3p1n2/4p1B1/4P3/1PNP1N2/1PP2PPP/R2QK2R w KQ - 3 9
+r2qkb1r/1p1n1ppp/p3pn2/1B1p1b2/3P1P2/2N1PN2/PP4PP/R1BQK2R w KQkq - 0 9
+r1b1k1nr/1p1p1ppp/p3p3/q1b5/4P3/3B1N2/PPP1NPPP/R2Q1RK1 w kq - 2 13
+rnbq1rk1/ppp3pp/1n6/3Ppp2/4P3/2N2P2/PP1Q2PP/R3KBNR w KQ - 0 10
+rn1qk1nr/1p3ppp/p2bp3/3pN3/3P4/2N5/PPP1bPPP/R1BQ1RK1 w kq - 0 9
+3r1rk1/4qppp/1pnp1n2/p1p1p3/P1P1P1b1/1P1P1NP1/2QN1PBP/R3R1K1 w - - 1 15
+r1bqk2r/1p1pbppp/p1n1p3/4P3/2B3n1/2N1BN2/PP3PPP/R2Q1RK1 w kq - 1 10
+r2qk2r/1pp2p2/p1np1n1p/2b1p1p1/2B1P1b1/P1NP1NB1/1PP2PPP/R2QK2R w KQkq - 2 10
+rnbq1rk1/1pp1bppp/p3p3/8/2pP4/2N1PN2/PP2BPPP/R2Q1RK1 w - - 0 10
+r1b2rk1/4q1pp/p1pp1p2/np2p1B1/4P3/3P1N1P/PPP2PP1/R2Q1RK1 w - - 0 14
+r4rk1/1p2qpp1/p2pnn1p/4p2b/1PB1P2B/2PP1N1P/5PP1/R2Q1RK1 w - - 1 16
+r2q1rk1/pb1nn1bp/1p4p1/4pp2/3pP3/1N1P1P1P/PP2BBPN/2RQ1RK1 w - - 0 16
+r3k2r/1pp1bp2/p1np2pp/P3p2n/1PB1P2P/2PP3P/1B3P2/RN2K1R1 w Qkq - 1 16
+rnbqkb1r/pp4pp/5p2/3np3/4P3/2N5/PP3PPP/R1BQK1NR w KQkq - 0 9
+rn1q1rk1/ppp1bpp1/7p/3p4/3P2b1/3BPN2/PP3PPP/R1BQ1RK1 w - - 2 10
+r1b1k2r/ppp2ppp/4q3/4n3/2P1Q3/3P4/P2B2PP/R3KB1R w KQkq - 0 16
+2kr3r/pppbqpbp/1n4p1/3Pp3/4Pp2/1PNB4/PBPQ2PP/1K2R2R w - - 2 16
+r2qkb1r/1p1n1ppn/p3p2p/3p1b2/8/PBNP1P1P/1PP1N1P1/R1BQK2R w KQkq - 4 11
+rn2k1r1/pp2p2p/3p2p1/2pP1p1P/b1P1n3/2P1BN2/P3PPP1/2R1KB1R w Kq - 1 14
+r2qk2r/ppp2ppp/2nbp3/3p4/3P1B2/3PPN2/PP1Q1PPP/R4RK1 w kq - 1 10
+r2qrbk1/1ppb1ppp/p2p1n2/8/4PB2/1PNP3P/1PP3PN/R2Q1R1K w - - 3 14
+r2qr1k1/pp1bnppp/2pb1n2/3pp3/P3P3/3P1NPP/1PPNQPB1/R1B2RK1 w - - 1 11
+r2q1rk1/1ppbb1pp/p3p3/3pBp2/1P1PnP2/2PBP1P1/P6P/RN2QRK1 w - - 1 16
+r1bq1rk1/b1p2pp1/p1n2n1p/1p6/1PNp1B2/P2B1N1P/2P2PP1/R2QR1K1 w - - 0 15
+rnbq1rk1/pp2bppp/2p2n2/3p4/3P4/2NB1N2/PPP2PPP/R1BQ1RK1 w - - 2 10
+r1bqk2r/1p1nn1p1/2pp3p/p3p3/4P3/2NB1N1P/PPP2PP1/R2Q1RK1 w kq - 0 11
+r2qk2r/1p2b1pp/p1np1n2/2p1pb2/8/2NPBN2/PPPQBPPP/R4RK1 w kq - 2 10
+rn1qk2r/pp2nppp/1b2p3/3pP3/3P1P2/5N2/PP4PP/RNBQK2R w KQkq - 3 10
+r1bqk2r/p3npbp/1pn1p1p1/3p4/B7/2N2N2/PPPP1PPP/R1BQR1K1 w kq - 0 10
+r2q1rk1/pp3ppp/2nbpn2/3p4/3P2b1/P1N2NP1/1P2PPBP/R1BQ1RK1 w - - 3 10
+rn2k2r/pp2bppp/2p1pn2/q7/3P4/2NbBN2/PPP2PPP/R2Q1RK1 w kq - 0 10
+2r1r1k1/pp2bpp1/2ppq1np/8/3PPQN1/2N4P/PPP3P1/3R1RK1 w - - 1 18
+r1bq1rk1/pp2nppp/2pp4/1B1Pp3/1bP5/3P1N2/PP3PPP/R1BQ1RK1 w - - 0 10
+rn1q1rk1/pp2bppp/2p1bn2/2Pp4/BP1Pp3/P1N1P3/5PPP/R1BQK1NR w KQ - 2 10
+r1bq1rk1/2p2pp1/p2p1b1p/1p1P4/8/PPPB3P/5PP1/R1BQ1RK1 w - - 1 15
+r2q1rk1/4bpp1/pp2pn1p/2pp4/P2P1P2/2PBPQ2/1P1B2PP/R4RK1 w - - 0 17
+rnbqk2r/ppb2ppp/2p1pn2/P2p4/1P1P3P/2P1PN2/5PP1/RNBQKB1R w KQkq - 1 9
+rn3b1r/ppp1k1pp/3p1nb1/6N1/2BPp3/8/PPP2PPP/RNB1K2R w KQ - 0 10
+r1bqr1k1/1p2bppp/p1pp1n2/8/3pP3/1PN1BN1P/1PPQ1PP1/R4RK1 w - - 0 13
+2kr1b2/ppq5/3p2pn/3p1b2/3PpP2/1B2B3/PP4PP/RN3RK1 w - - 2 17
+r2q1rk1/ppp2ppp/3b1n2/3pNb2/3P1B2/2PB3P/PP1n1PP1/R2Q1RK1 w - - 0 13
+r2r2k1/ppp2pbp/2n1p1p1/4P3/3P4/Pb2BN2/1P2BPPP/R4RK1 w - - 0 18
+2kr2nr/pp3ppp/4p3/8/1bBnP3/2N2P2/PP3P1P/R1B2RK1 w - - 4 16
+r3k1nr/1bp1qpp1/p1pp3p/2b1p3/Q3P3/2PP1N2/PP3PPP/RNB2RK1 w kq - 3 10
+r1bq1rk1/pp2b1pp/2np4/2p1pp2/2P2Bn1/P1NP1NP1/1P2PPBP/R2Q1RK1 w - - 0 11
+r3k1nr/pp3ppp/1q2p3/3p4/3b4/P4PP1/1P3PBP/1RBQ1RK1 w kq - 0 14
+r2qk2r/ppp1bppp/3p1nb1/3Np3/2B1P1P1/5Q1P/PPPP1P2/R1B1R1K1 w kq - 3 11
+2rqkb1r/pp3ppp/2n1pn2/3p3b/3P4/2NBP2P/PPQ1NPP1/R1B1K2R w KQk - 3 10
+r2qk2r/ppp1bppn/2npb2p/8/4P1P1/2N2P1N/PPP4P/R1BQKBR1 w Qkq - 6 10
+r1bq1rk1/ppp2pp1/1bnp1n1p/4p3/2B1P3/P1NPBN1P/1PP2PP1/R2QK2R w KQ - 3 9
+r1bqkb1r/p4ppp/2p5/n2np1N1/8/3B4/PPPP1PPP/RNBQK2R w KQkq - 2 9
+2kr1b1r/1ppqnpp1/p3p2p/P2pP3/1PnP2P1/2P2N2/5P1P/RNBQ1R1K w - - 0 14
+r2qkb1r/1pp3pp/p2p1n2/8/4Pp2/3Q4/PPP3PP/RNB2RK1 w kq - 0 12
+r4rk1/1p2bppp/p4n2/4p3/PnB1P1b1/2N2N2/1P3PPP/R1BR2K1 w - - 1 15
+r1bnk1nr/pp2b1p1/7p/2p2pN1/4pB2/2N3P1/PPP1PPBP/R4RK1 w kq - 0 11
+r3k1nr/1p1n1pp1/2p1bq1p/p1b1p3/P3P3/2NBBN2/1PP2PPP/R2Q1RK1 w kq - 5 11
+r2q1rk1/pp1bppbp/2p3p1/8/3P4/2B1PN1P/PP2QPP1/2R1K2R w K - 1 15
+rn1qk2r/ppp1bppp/2b1p3/4P3/3P4/1Q6/PP3PPP/R1B1KBNR w KQkq - 4 11
+r2qkb1r/1b2nppp/p3p3/1pn1P3/8/P2B1N2/1P1N1PPP/R1BQ1RK1 w kq - 0 12
+r1bq1rk1/ppp2ppp/2n5/2bnp3/8/3P1NN1/PPP1BPPP/R1BQ1RK1 w - - 7 9
+rnbq1rk1/1p1p2bp/2p1p1p1/p2n4/4p3/1PP2PP1/PB1PN1BP/RN1Q1RK1 w - - 0 11
+r4rk1/3qbppp/p1n1pn2/1p1p4/1P4b1/P4NP1/1BPNPPBP/2RQ1RK1 w - - 2 14
+rn2k2r/pp6/2p3pp/7n/3PpB1P/5bP1/PPP5/RN2KB1R w KQkq - 2 18
+r3k1nr/p4p1p/2bp1b2/nBp2P2/8/2P5/PP2N2P/RNB1KR2 w Qkq - 4 17
+r1bq1rk1/1pp2pp1/2np3p/p2Np3/2P1P1n1/P2PPN2/1P2B1PP/R2QK2R w KQ - 0 11
+r1bq1rk1/4bppp/p2p1n2/npp1p3/4P3/2PP1N1P/PPB2PP1/RNBQ1RK1 w - - 0 11
+r1bq1rk1/ppp1npp1/1b3n1p/1P1p4/2B1P3/2PP1N2/P4PPP/RNBQK2R w KQ - 0 10
+r2q1rk1/p4ppp/1ppp1b2/8/P1B1P3/1QP2PPb/1P1N3P/R3R1K1 w - - 1 18
+r4rk1/1b2qpbp/p3p1p1/np1p4/3P1N2/N1P3P1/PP3PBP/R2Q1RK1 w - - 4 16
+r2qk2r/pp1b2pp/2pbp3/5p2/3Pp3/1P2P1P1/PBP1NP1P/R2Q1RK1 w kq - 0 13
+r2qkb1r/1ppb3p/p1n1pp2/3p4/3P3B/5N2/PPP2PPP/RN1QK2R w KQkq - 2 10
+r2qk2r/p1pbbppn/2pp3p/8/3NP2B/2N5/PPP2PPP/R2Q1RK1 w kq - 2 11
+r2q1rk1/1p3pp1/p4b1p/2pp4/3n4/PB1P1QNP/1PP2PP1/R4RK1 w - - 1 16
+3r1rk1/ppp1bppp/5n2/3p4/1n1P4/2NPBN1P/PP3PP1/4RRK1 w - - 3 15
+r1b2rk1/1ppn1ppp/p4q2/4p3/2BP4/P3PN2/1P3PPP/R2Q1RK1 w - - 0 13
+rn2kbnr/p1p1pp1p/1p4p1/8/3P4/2PB1P2/PP5P/RNB1K2R w KQkq - 0 10
+2r2rk1/pp3ppp/1n1qpn2/8/5P2/1PR1PN2/PB2Q1PP/5RK1 w - - 1 18
+3q1rk1/p1pn1ppp/4rn2/2b1p3/8/2P1p2N/PPQP1PPP/RNB1K2R w KQ - 0 13
+rnbqk2r/2p1bpp1/p2p1n1p/1p6/2BNP3/P4P2/1PP3PP/RNBQ1RK1 w kq - 0 9
+rn1qk2r/pp3pp1/4bn1p/2bpp3/7B/2PP4/PPB2PPP/RN1QK1NR w KQkq - 0 9
+r3k2r/p1pp1ppp/np2p3/3nP3/3P4/2P2N2/P1PB1PPP/R3K2R w KQkq - 0 13
+r2q1rk1/pp1bbppp/2nppn2/2p3B1/2P1P3/2NP1N2/PP1QBPPP/R3K2R w KQ - 8 9
+r2q1rk1/ppp1bppp/2n1bn2/3pp3/4P3/1PNP1N1P/PBP1BPP1/R2QK2R w KQ - 0 9
+r1bq1rk1/pp1nppbp/3p2p1/2p5/2BPPPn1/2N1BN2/PPPQ2PP/R3K2R w KQ - 2 9
+r1b1kr2/pppq2pp/4pp2/4P3/1Q2p3/P3P3/2P2PPP/R1B1K2R w KQq - 0 15
+r4rk1/pp2nppp/1qn1p3/3pP3/3P4/N4N2/PP1Q1PPP/R4RK1 w - - 3 13
+r1bq1rk1/pp1nb1pp/2p1p3/2Pp1p2/3PnB2/2NBPN1P/PP3PP1/R2QK2R w KQ - 3 10
+r1bq1rk1/1p1pppbp/p1n2np1/8/4P3/1NN5/PPP1BPPP/R1BQ1RK1 w - - 0 9
+rnbq1rk1/ppppp1bp/6p1/6N1/3P4/5N2/PPP2PPP/R2QKB1R w KQ - 3 9
+r3k2r/pppqnpbp/2npb1p1/4p3/2P1P3/PPN2N1P/1B1P1PP1/R2QKB1R w KQkq - 3 9
+r3k2r/pppq1pp1/2bp1b2/4p2p/4P3/2NP1N1P/PPPQ1PP1/R3K2R w KQkq - 2 11
+r3kb1r/pp1nnpp1/2p1p2p/3pP3/3P4/2NP1N2/PP1B1PPP/2R2RK1 w kq - 0 12
+r2qkb1r/ppp2ppp/5n2/4p3/3Q4/7P/PPP1NPP1/R1B1K2R w KQkq - 0 11
+2kr3r/1pp1qppn/p1bp4/4p2p/4P3/2NP1N1P/PPP1QPP1/R2R2K1 w - - 0 14
+r4rk1/1bp2ppp/np1qpn2/p2p4/P2P4/NPP1P1P1/4NPBP/R2QK2R w KQ - 5 11
+r1br2k1/1pp1nppp/p1p5/2b5/3NP3/2P5/PP1N1PPP/R1B2RK1 w - - 5 11
+1k1r3r/bpp2pp1/p2q1n2/3Pp2p/4P1b1/1BN1B3/PP3PPP/R3QRK1 w - - 2 17
+r2q1rk1/1pp2ppp/p1bbpn2/3pN3/5P2/1P1PP3/PBP3PP/RN1Q1RK1 w - - 2 11
+rn3rk1/1b1qppbp/3p1np1/1pp5/4P3/BPNB1P2/2PPN1PP/R2QK2R w KQ - 0 13
+1rb1nrk1/p2n2qp/3p2pQ/1pp5/4N1P1/5P2/PPP1P3/R3KBNR w KQ - 4 18
+r2q1rk1/pbppn1bp/1p2p1p1/8/4P3/1PNB1Q2/P1PB1PPP/2R1R1K1 w - - 2 13
+r1bqk2r/1n4pp/2pp1b2/pp2pp2/1P2P3/P1NP3P/B1P1NPP1/R2QK2R w KQkq - 0 13
+rnbq1k1r/ppp5/3p1n1p/3p2p1/8/B1P2Q2/P1P2PPP/R3KBNR w KQ - 0 11
+rn1q1rk1/pp3pp1/2pb1n1p/3p4/2PP4/1P3B2/PB1N1PPP/R2Q1RK1 w - - 5 12
+r2qk2r/pb1nnpbp/1p1pp1p1/2p5/3PPP2/1BN1B3/PPPQN1PP/R3K2R w KQkq - 0 10
+rn2k2r/p1p2ppp/1p2bn2/P3p3/4P3/5P2/P1PB2PP/R2K1BNR w q - 2 11
+r3k1nr/pp3p2/2ppq2p/2n1p1p1/4P3/P2P1N1P/1PP2PP1/R1BQ1RK1 w kq - 0 12
+r1b1k2r/pp1qbpp1/3p1n1p/2pBp3/Q1P1P3/3P1N2/PP3PPP/R1B2RK1 w kq - 3 11
+r1b2rk1/p4ppp/2p1pn2/q7/2p5/1PNBP3/P4PPP/2RQK2R w K - 0 13
+r4rk1/p4ppp/1q2pn2/1bbp4/8/P1P1PQ2/3NBPPP/R1B2RK1 w - - 6 15
+r4rk1/2qbbp1p/p2p1np1/1pnPp3/P1p1P3/2P2NNP/1PB2PP1/R1BQR1K1 w - - 0 17
+r3kb1r/p4p1p/2pp1np1/1pn5/4P3/1BN2P2/PPP2P1P/R1B1K1R1 w Qkq - 2 13
+r3nrk1/p1p2p1p/3bp1pP/1N1p1b2/8/P3PN2/1PP2PP1/R1B1K2R w KQ - 4 14
+r1b2rk1/ppp2ppp/1b6/1q2P3/2N5/5N2/PPP1Q1PP/2KR3R w - - 2 15
+r3kbnr/pb3ppp/2p1p3/8/8/4P1P1/PP3P1P/RNBK1B1R w kq - 1 10
+r2qkb1r/pp1nppp1/2p4p/3n3b/3P4/2N1PN1P/PP2BPP1/R1BQK2R w KQkq - 1 9
+r1b2rk1/1p2bppp/2n1pn2/2qp4/2P5/P3PNP1/1B1N1PBP/R1Q2RK1 w - - 1 15
+r1bq2nr/pppk3p/2nb4/3p1p1B/3PpNp1/4P3/PPP2PPP/RNBQ1RK1 w - - 2 11
+r1bq1rk1/ppp2pp1/1bnp1n1p/4p3/2B1P2B/1N1P1N2/PPP2PPP/R2QK2R w KQ - 2 9
+r4rk1/4qppp/1pnp1b2/p1p1p3/2P1P3/PP1P4/1B1NbPPP/R2Q1RK1 w - - 0 14
+rnbqkb1r/p3pppp/2p5/3nP3/P2PN3/2p2N2/5PPP/R1BQKB1R w KQkq - 0 10
+rn2k2r/1bppqpbp/pp2pnp1/6N1/2B1P3/2PP1Q2/PP3PPP/RNB2RK1 w kq - 0 9
+r3r1k1/pp1qbpp1/2n1bn1p/3p4/2pP4/P1N2NB1/1PPQBPPP/R4RK1 w - - 8 14
+r1bq1rk1/1p2bpp1/p1n1pn1p/8/2p4B/P1N1PN2/1P3PPP/2RQKB1R w K - 0 12
+r3k2r/2pqppbp/ppbp1np1/8/3PP3/2N1BN2/PPPQ1PPP/R4RK1 w kq - 2 11
+r1bq1rk1/1p2bppp/pn6/2pP4/P7/2N5/BP3PPP/R2QK1NR w KQ - 2 12
+r1bq1rk1/pp2ppbp/5np1/3P4/1nBN4/2N1BP2/PPP3PP/R2QK2R w KQ - 1 10
+rnb1k1nr/pp2bppp/2p1p3/3pP3/3P1B2/1NP5/PP3PPP/R3KBNR w KQkq - 0 9
+rnb1k2r/pp2q1pp/3b4/3n1p2/3Pp3/1Q2P3/PP1NBPPP/R1B1K2R w KQkq - 0 11
+r1bq1rk1/pp3ppp/n1pbp3/8/3P4/4PN2/PPP3PP/RNBQ1RK1 w - - 3 11
+1r1qr1k1/p2nbppp/5n2/2p4b/2Pp4/1P3N1P/P1B2PP1/RNBQR1K1 w - - 1 16
+2kr3r/1pp2ppp/p1pbbn2/4N3/8/8/PPPP1PPP/RNB1RK2 w - - 7 12
+r2qkb1r/pppnpp1p/6p1/3pP3/5P2/4P3/PPP1Q1PP/RNB1K2R w KQkq - 0 9
+r2qkb1r/ppp3pp/5n2/3p1b2/3n4/P3P3/1PP1BPPP/RNBQK2R w KQkq - 0 9
+r2q1rk1/pp1bppbp/2np1np1/2p5/4PP2/3P3P/PPP1B1PN/RNBQ1RK1 w - - 1 9
+2kr3r/pppqbpp1/5n1p/3pn3/3P2b1/1P4P1/PB1NPPBP/R2Q1RK1 w - - 0 12
+rn1qk2r/pp2npp1/1bp1p2p/3pP3/3P1Pb1/2P2NP1/PP4BP/RNBQK2R w KQkq - 1 10
+rnb2r1k/1p3ppp/2pp3n/p3p1q1/P1B1P2N/2NPP2P/1PP3PK/R2Q1R2 w - - 7 13
+r3kb1r/pp3ppp/2n1p3/2p5/4nP2/2P1Bb1P/PP2K1P1/RN3B1R w kq - 0 11
+r2qr1k1/pp2ppbp/2p2np1/6B1/3P4/2P2Q1P/PPB2PP1/R4RK1 w - - 3 14
+3r1rk1/1bq1bppp/p1n1pn2/1p1p2B1/4P3/PNNB4/1PPQ1PPP/3R1R1K w - - 0 15
+r1bq1rk1/pppp2bp/2n1p1p1/5n2/2PP4/2N1BN2/PP2BPPP/R2QK2R w KQ - 2 9
+rnb1k2r/pp1p1pp1/2p2n1p/2b1p3/2B1P2P/2NP1P2/PPP1NP2/R1B1K2R w KQkq - 1 9
+rn1qk2r/1b3pp1/p3pb1p/1pp5/8/PB1P1N2/1PP1QPPP/R1B2RK1 w kq - 0 13
+r2qk2r/ppp2pp1/3b3p/n2Bn3/4P1b1/1QP2N2/PP1N1PPP/R1B1K2R w KQkq - 2 11
+r1b1k1nr/5ppp/p2p1q2/1pp1p3/2PbP3/1B6/PP1PQPPP/RNB1R1K1 w kq - 0 11
+r4rk1/ppq1bppp/3ppn2/2p5/4PP2/2PPBQP1/PP1N3P/R4RK1 w - - 6 13
+rn2kbnr/p1p2ppp/2ppp3/2q3B1/6P1/2NP1N2/PPP1PP1P/R2QK2R w KQkq - 1 9
+r1bq1rk1/5ppp/p1nbpn2/1p1p4/8/2PP1NP1/PP1N1PBP/R1BQR1K1 w - - 0 11
+r1bq1k1r/1p1nbppp/p1n1p3/3p2B1/5P1P/2N4N/PPPQ2P1/2KR1B1R w - - 1 13
+r2q1rk1/pp3ppp/2n2n2/2bp4/5Bb1/3B1N2/PPPN1PPP/R2Q1RK1 w - - 8 10
+r1b1kbnr/2pn1pp1/p2p3p/1p1Pp3/4P3/1B3P1P/PPP1NP2/RNB1K2R w KQkq - 1 10
+r2q1rk1/ppp1nppp/3p4/3Np1b1/4P1B1/3P4/PPP2PPP/R2Q1RK1 w - - 6 15
+r1b1k2r/pp3ppp/2nqpn2/3p4/3P4/2N1PN2/PP3PPP/R2QKB1R w KQkq - 0 9
+rnbq1rk1/pp3pb1/2p1pn1p/4p1p1/3P3B/2NB1N2/PPP2PPP/R2Q1RK1 w - - 0 11
+r4rk1/pp2ppbp/2n3p1/2pqP3/6b1/2PB1N2/PP3PPP/R1BQR1K1 w - - 1 12
+2rqkb1r/pp1n1ppp/2p1pn2/3p4/3P4/1P2PB2/PBP2PPP/RN1Q1RK1 w k - 2 9
+4r1k1/ppp2ppp/1q1b1n2/8/2P1r1b1/1P1Q1N2/P2B1PPP/RN3RK1 w - - 2 17
+r2qr1k1/pp1n1ppp/3bbn2/2pp4/3P4/2NBBN1P/PPP2PP1/R2QR1K1 w - - 0 11
+r1n2rk1/1p1b1pp1/p1p2q1p/2bp4/3P4/P3PN2/1P2BPPP/2RQ1RK1 w - - 0 17
+r3k2r/1ppq1ppp/p1nbpnb1/1N1p2B1/3P2P1/5N1P/PPP1PPB1/R2Q1RK1 w kq - 0 11
+r4rk1/pppq1p1p/2np1bp1/3Bp2b/4P3/2PP2QN/PP3PPP/RN2K2R w KQ - 0 12
+r1b1rnk1/ppq2ppp/2p2n2/3p4/3P4/3BPN2/PPQN1PPP/2R2RK1 w - - 0 14
+r1b1k1nr/1p1p1pp1/4pq2/p1b2P1p/2P1P1n1/1Q5N/PP2B1PP/RNB1K2R w KQkq - 0 11
+r1b2rk1/1ppp1pp1/2n2q1p/p1b1p3/4P3/2PP1N2/PP2BPPP/RN1Q1RK1 w - - 0 9
+r2qkbnr/pp1n2pp/2p2p2/3p3b/Q2P4/2N2N2/PP2PPPP/R1B1KB1R w KQkq - 2 9
+r1bq1rk1/pp2npbp/2n1p1p1/2p1P3/3p1P2/3P1N2/PPP1BBPP/RN1Q1RK1 w - - 0 10
+4rrk1/ppqb2pp/2pbp3/3pN3/3PpP2/PP2P3/1BP3PP/R2Q1R1K w - - 0 17
+r1bq1rk1/2p1bppp/p1np1n2/1p2p3/4P3/1BPP1N1P/PP3PP1/RNBQK2R w KQ - 1 9
+r1b1k2r/1p1pnpbp/p1n1p3/5p2/8/2NBPN1P/PPP2PP1/R1B2RK1 w kq - 1 12
+4k1nr/2ppq1pp/rpn2p2/4P3/8/P3PN2/1B1Q1PPP/R3K2R w KQk - 0 13
+rnb1kbnr/pp2q1pp/3p4/4p3/4p3/2P1BPP1/PP5P/RN1QKBNR w KQkq - 0 9
+r4rk1/ppp2ppp/3pb3/4p3/1PB1P1nq/P2P1n1P/2P1NPP1/R1BQ1R1K w - - 3 13
+rnbqk2r/pp2bpp1/2p4p/3p4/3P3B/5N2/PP2PPPP/R2QKB1R w KQkq - 0 9
+r1b1r1k1/4ppbp/pq4p1/npp5/4N3/P1PPn1NP/1PB2PP1/R3QRK1 w - - 0 17
+r3kbnr/1pp4p/p2q2p1/3pp2Q/1P6/P3P1P1/2P2P1P/RN2KB1R w KQkq - 0 12
+r3k2r/2pq1ppp/p1nbpn2/1p1p4/3P1P2/2P1P2P/PPB2P2/RNBQK2R w KQkq - 1 11
+r2qkb1r/p1pb1ppp/3p1n2/2p5/4P3/1N6/PPP2PPP/RNBQ1RK1 w kq - 2 9
+2kr3r/pppq2p1/2nppb2/7p/P3P3/2P1BP2/1P1N2PP/R2Q1RK1 w - - 0 14
+r4rk1/4nppp/pqp1p3/3pP3/QP4P1/2Pb1N1P/P4P2/R1B2RK1 w - - 2 18
+r1b1k2r/ppp2ppp/2n2n2/2b1pP2/4P3/2N2N2/PPP3PP/R1BK1B1R w kq - 1 9
+r1b1qrk1/p1p3pp/1p1b1n2/5p2/2P1p3/1P2P1P1/PBQ1NPBP/R4RK1 w - - 0 16
+r1bqk1nr/1pp2ppp/1p1p4/8/2BnP3/8/PPP2PPP/R1BQK2R w KQkq - 0 9
+rnbq1rk1/ppp2pp1/4pn1p/b7/2p5/PP4PN/1B1PPPBP/RN1Q1RK1 w - - 0 9
+r2q1rk1/pp1n1ppp/2p1p3/3n1b2/2BPP3/2b2N2/PP1B1PPP/R2Q1RK1 w - - 0 11
+r2q2k1/pp3pp1/2pbb2p/3n4/3P4/3B1N1P/PP1B1PP1/R3Q1K1 w - - 1 17
+r1bq1rk1/bpp3pp/p1np2n1/4pp2/1PP1P3/P4NP1/1B1P1PBP/RN1Q1RK1 w - - 0 11
+rnbq1rk1/pp3pp1/3p1n1p/2pPp1B1/2P1P3/2P2N2/P1Q2PPP/R3KB1R w KQ - 0 10
+r1b1k2r/ppq2ppp/2nb1n2/1B1pN3/3P4/2N5/PP3PPP/R1BQK2R w KQkq - 8 10
+3r1rk1/1pq1bppp/p1npbn2/8/2P5/1PN2N2/PB2BPPP/R2Q1RK1 w - - 4 13
+r3kbnr/pp3ppp/2q1p3/2ppP3/3P4/P1N2b1P/1PP2PP1/R1BQ1RK1 w kq - 0 11
+rn1qk2r/pp2bpp1/2n1p3/1B1pPb1p/Q2P4/2N2N2/PP3PPP/R1B1K2R w KQkq - 4 10
+r2q1rk1/1ppnppbp/p2p1np1/8/1P1P2b1/P3PN2/1BPNBPPP/R2QK2R w KQ - 0 9
+r1bq1rk1/2p1bppp/p1np1n2/1p2p3/4P3/1BNP1N1P/PPP2PP1/R1BQK2R w KQ - 3 9
+r3r1k1/p1p2ppp/1pn5/2q5/2P3b1/3P1N2/PQPB2PP/R4R1K w - - 2 17
+r3k1nr/pp3pp1/2n1p2p/2qpP3/8/2PB1Q1P/PP3PP1/RN2K2R w KQkq - 0 12
+r3kbnr/ppp2ppp/5q2/4p3/3P2b1/1P1P1pP1/P2N1PBP/R1BQK2R w KQkq - 0 10
+r1bq1rk1/pp3ppp/1bn2n2/3p4/8/1N1B1N2/PPP2PPP/R1BQ1RK1 w - - 6 10
+r1b2rk1/p2p1ppp/2p1pn2/2q5/2P5/P1N1P3/3QBPPP/RR4K1 w - - 6 15
+r2q1rk1/pb2ppbp/1p4p1/n1p1P3/2P5/1P3N2/PBQNRPPP/R5K1 w - - 0 16
+rn1qk2r/pp2nppp/4p3/3pP3/8/3QbN2/PPP2PPP/RN3RK1 w kq - 0 10
+2kr3r/pppqbppp/3p4/4nP2/2B1P3/2P5/PP4PP/R1BQ1RK1 w - - 0 15
+r1bq1rk1/pp1nppbp/2np2p1/2p5/4P1P1/2NPB2P/PPPQNP2/R3KB1R w KQ - 1 9
+r1b1k3/ppq1bp1r/2pp1n2/4p1pp/2BPPn2/1QP1B1N1/PP1N1PPP/R4RK1 w q - 0 15
+r2q1rk1/2pbb1pp/p2p1n2/3Ppp2/2Q1P3/5N2/PP1N1PPP/R1B1R1K1 w - - 1 15
+r2qkb1r/1p3ppp/p1n1b3/3pPp2/3P4/2N2N2/PP3PPP/R1BQ1RK1 w kq - 0 11
+r1b1k2r/3p2pp/pp1bp3/2p2n2/P1P5/1PN2N1P/2PB1PP1/R3K2R w KQkq - 0 15
+r2qk2r/1p1bnppp/p3p3/2bpP3/8/2N2N2/PPP2PPP/R1BQ1RK1 w kq - 2 10
+r1bq1rk1/pp2ppbp/2n2np1/1B1p4/3PP3/5N2/PP3PPP/RNBQR1K1 w - - 0 9
+5rk1/4bp1p/2p2np1/2Pp1b2/QP6/B3P2N/5PPP/qN3RK1 w - - 2 17
+r2q1rk1/2p1bppp/p1p2n2/3p1PB1/8/2N2Q2/PPP2PPP/R4RK1 w - - 0 13
+r1b1k2r/pp2bpp1/2qppn1p/2p5/4P3/2NP1N1P/PPP2PP1/R1BQK2R w KQkq - 1 10
+r1b2rk1/ppqn1ppp/2pb1n2/3pp3/3PP3/2NQ2P1/PPP1NPBP/R1B1K2R w KQ - 1 9
+r2q1rk1/pbpnppbp/1p1p1np1/3P4/4P3/2NB1N2/PPP1QPPP/R1B2RK1 w - - 6 9
+r1bq1rk1/ppp1nppp/1bnp4/1B6/3PP3/5N1P/PP3PP1/RNBQ1RK1 w - - 1 9
+2rbk2r/p3npp1/2n1p1b1/1p1pP2p/q1pP1PP1/2P1BN1P/PP1NQ1B1/R3R1K1 w k - 0 17
+rn1qr1k1/pp2ppbp/2p3p1/8/2pP4/1P1QPN1P/PB3PP1/R4RK1 w - - 0 14
+rn2kb1r/1b1p1ppp/pq2p1n1/1pp5/4P3/P2P1N2/NPPBBPPP/R2Q1RK1 w kq - 10 12
+r5k1/ppr2ppp/4p3/3pPn2/3P4/qP3N1P/P1bQBPP1/R4RK1 w - - 9 18
+2kr3r/pp1bq2p/1np1p1p1/3pPp2/3Pn2P/2PBPNP1/PP4Q1/R1B1K2R w KQ - 1 15
+r2q1rk1/3nbpp1/2pp1n1p/1p2p3/4P2B/1Q1P1N2/1PPN1PPP/R4RK1 w - - 0 14
+rnb2rk1/pp3ppp/5n2/3p4/P2Pp3/NP2PP2/3q2PP/2R1KBNR w K - 0 12
+r3k2r/pp3ppp/2p2n2/q3p3/3n2b1/PPb2N2/1BPPBPPP/R2Q1RK1 w kq - 0 12
+3r1rk1/ppp1ppbp/6p1/8/2Pnq3/1Q2BN2/PP3PPP/2R2RK1 w - - 0 14
+r2qkb1r/5ppp/bpn1pn2/p2p4/3P4/P2B1P2/1PP1N1PP/RNBQ1RK1 w kq - 1 10
+r1b1kb1r/3q2p1/p1n4p/1pp5/3ppPn1/NP4PN/PBPQP1BP/R4RK1 w kq - 0 16
+r2q1rk1/ppp2pp1/2n2b1p/3p3b/3P4/2PB1N1P/PP3PP1/RN1QR1K1 w - - 0 12
+r1q2rk1/1b1n1pbp/p3pnp1/1p1p4/3P1PPB/P2BPN2/1P5P/RN1Q1RK1 w - - 1 14
+r1b1k2r/ppq1bp2/2p2nnp/4p1p1/2B1P3/2N1BN2/PPPRQPPP/3R2K1 w kq - 2 13
+r1bq1rk1/p1p1bppn/2pp3p/8/3PP3/2N2N2/PP3PPP/R1BQR1K1 w - - 2 11
+r1bq1rk1/pppn1pbp/3p1np1/3Pp1B1/4P3/2N2N2/PPP2PPP/R1Q1KB1R w KQ - 3 10
+rn2k2r/5p2/2pp2pp/ppb1p3/4P3/PB1P1P2/1PP2P1P/R1B1K1R1 w Qkq - 0 14
+r2qk2r/1p3pp1/1np1p1p1/p2nP1b1/P1pP4/2N2B1P/1P3PP1/R1BQ1RK1 w kq - 0 15
+2rq1rk1/1p3pp1/p2pbn1p/4p3/2P1P3/5P2/n1PNBBPP/1R1QK2R w K - 0 16
+3q1rk1/2pp1pbp/2n3p1/1r1Bp3/8/4P3/1P1P1PPP/R1BQ1RK1 w - - 0 17
+r2q1rk1/pppb1ppp/2nbpn2/3p4/8/P1NPPN2/1PPBBPPP/R2Q1RK1 w - - 3 9
+r3k1nr/pb1qpp1p/1ppp2p1/1B6/3bP3/PPN5/1BPPQPPP/R3K2R w KQkq - 0 11
+3rr1k1/pppq1ppp/2n2b2/3np3/8/2PPBNNP/PP3PP1/R2Q1RK1 w - - 4 15
+r2q1rk1/pp2bppp/3pbn2/2p3B1/3QP3/2NB4/PPP2PPP/R4RK1 w - - 0 11
+r2q1rk1/ppp1b1pn/2np3p/1B2pb2/8/2PP1N1P/PP1N1PP1/R1BQR1K1 w - - 0 11
+rnb2rk1/2q2ppp/p4n2/2pp4/8/2PBBN2/P1Q2PPP/R3R1K1 w - - 0 18
+r1bqk2r/bppp1ppp/p1n2n2/3Np3/1P2P3/P2B1N2/2PP1PPP/R1BQ1RK1 w kq - 1 9
+rn2k1nr/pp2q1pp/2p1p3/2Pp1p2/4bP2/3BP3/PPP3PP/RNBQ1RK1 w kq - 1 11
+r2q1rk1/pp2bpp1/4bn1p/3pn3/3P4/2N3P1/PP3PBP/R1BQ1R1K w - - 0 13
+r4rk1/ppp1npp1/5q1p/2bpp3/PPB1P3/2PP1P2/5P1P/R1BQ1RK1 w - - 0 13
+2kr3r/pp2np2/1q2p2b/n2pP2p/2pP2pN/P1P5/1P2QPPP/R1B1RNK1 w - - 4 17
+r2qk2r/pbppbppp/1pn1p3/4P3/2BP4/2P2N2/P1P2PPP/R1BQ1RK1 w kq - 2 9
+r1b2rk1/pp3ppp/2n2B2/8/8/2P2q2/P1N1B1PP/R3K2R w KQ - 0 15
+rn1q1rk1/ppp1bpp1/5n1p/3p2B1/3P2b1/3B1N2/PPP2PPP/RN1QR1K1 w - - 0 9
+r1bqkb1r/ppp4p/2np4/4pp2/8/3PBP2/PPP1N1PP/R2QKB1R w KQkq - 0 9
+r3kbnr/ppp3p1/3pp2p/8/3qP3/2N1B3/PPP2PPP/2KR3R w kq - 0 11
+r2q1rk1/pp3ppp/2n1pn2/8/2P5/P4N2/P2PQPPP/R1B1K2R w KQ - 1 10
+r1q2r2/pp2ppbk/3p2pp/2pP4/3n4/P2P1NPb/1PPB1PBP/R1Q2RK1 w - - 1 15
+rn1qk2r/1bp1bppp/p3pn2/1p6/3P4/1BN1PN2/PP3PPP/R1BQ1RK1 w kq - 6 9
+r1bq1rk1/pp1n1pbp/3p1np1/2p5/1P1B4/P3PNP1/2PN1P1P/R2QKB1R w KQ - 0 10
+r1bqkb1r/5p1p/p1np1p2/1p2p3/4P3/N1N5/PPP2PPP/R2QKB1R w KQkq - 0 10
+rn1qkb1r/1p3ppp/p3pn2/3p4/N2P4/3Q4/PPP2PPP/R1B1K1NR w KQkq - 0 9
+r1bqk2r/3n1ppp/p2b1n2/2pp4/1p1P4/2N1PN2/PPB2PPP/R1BQK2R w KQkq - 0 11
+r4rk1/1p2bppp/p1np1n2/2p5/8/2NP1N1P/PPP2PP1/R1B1K2R w KQ - 0 12
+r1bq1rk1/3n1pp1/1p2pn1p/p2p4/1b1P4/1P2PN2/PBQNBPPP/R4RK1 w - - 0 12
+r1b2rk1/pp1np1bp/2p2np1/3pNpB1/3P1P1P/q2BPN2/2P3P1/1R1Q1RK1 w - - 1 13
+r1b2rk1/ppqn1pbp/2pp1np1/3Pp3/2P5/2N1PNP1/PP3PBP/R1BQ1RK1 w - - 1 10
+r2q1r2/3n1pkp/p3p1p1/1ppnN3/8/2NP4/PPP2PPP/R1Q1R1K1 w - - 1 15
+rn1q1rk1/pp2bppp/2p1pn2/5bB1/3P4/5B2/PPP1NPPP/RN1Q1RK1 w - - 4 9
+r2q1rk1/1p2ppbp/p1np1np1/2p5/4PPb1/2PP1NP1/PP2Q1BP/RNB2RK1 w - - 2 10
+r1b2rk1/1p3p1p/p3pnp1/4q3/P2n4/2N2Q2/BP1P1PPP/R1B2RK1 w - - 2 16
+r2qk2r/pb1pnpbp/1pn1p1p1/2p5/2P1P3/2NP2PP/PP2NPB1/R1BQK2R w KQkq - 2 9
+r1bq1rk1/3nppbp/p2p1np1/2p5/3P4/P3PNP1/1BPN1PBP/R2QK2R w KQ - 0 11
+r3k2r/5ppp/p1npbb2/qp1Np3/2P1P3/N7/PP3PPP/R2QKB1R w KQkq - 1 13
+r2qkb1r/ppp2ppp/2np4/8/4P1b1/2P2N2/PP3PPP/RNBQK2R w KQkq - 2 9
+r1bqk2r/1p3pbp/2n1pnp1/p2p4/3P4/BP2PN2/P3BPPP/RN1Q1RK1 w kq - 0 10
+r1b2rk1/ppq2pbp/1n1p1np1/2pPp3/QPP1P3/3B1N2/P2N1PPP/R1B2RK1 w - - 1 12
+r1b2rk1/pp1nqppp/2p1p3/8/2BPn3/5N2/PPP2PPP/R2QR1K1 w - - 0 12
+r2qr1k1/pbpp1p1p/1p1b1npB/8/4P3/2NB1P1P/PPP2P2/R2QK1R1 w Q - 2 12
+r2qk2r/pbpn1pbp/1p1ppnp1/8/2PP1B2/2NBPN2/PPQ2PPP/R3K2R w KQkq - 2 9
+rnb2rk1/ppq3pp/2pbpn2/3p1pB1/3P4/2P2NP1/PP2PPBP/RN1QR1K1 w - - 5 9
+r1b2rk1/ppq3pp/2nb1n2/3p4/2PPpp2/1P4P1/PB1NNPBP/R2Q1RK1 w - - 0 13
+r1bq1rk1/2b3pp/p2p1p2/1p1Pp1P1/3pP2P/P2P4/1P1B1P2/R2QKB1R w KQ - 0 16
+r1bq1rk1/1p1nbppp/p1p1pn2/3p4/1P1P4/P3PNP1/1BPN1P1P/R2QKB1R w KQ - 1 9
+r4rk1/1pbn1pp1/p1p1pn1p/2Pp1bB1/1P1P4/2N1PN2/1P1K1PPP/2R2B1R w - - 0 14
+r2q1rk1/ppp1npb1/3p1npp/3Pp1B1/4P1b1/3B1N2/PPPN1PPP/R3QRK1 w - - 0 11
+rnb2rk1/6pp/1npbpp2/pp6/3PB3/P3BN2/1PPN1PPP/R3R1K1 w - - 7 14
+rnb2rk1/ppp2ppp/8/8/1bPN4/4B3/PP2BPPP/R3K2R w KQ - 5 12
+r1b1k1nr/pppp1ppp/8/3N4/5b2/8/PPP1PPPP/R3KB1R w KQkq - 0 9
+r2qkb1r/pQ4pp/3p1n2/3pp3/4P3/2P2P2/PP5P/RNB1K2R w KQkq - 0 13
+r1b1k2r/pp1p2pp/2n1p3/q1p2p2/2PP4/2P3P1/P2QPPBP/R3K1NR w KQkq - 1 11
+r1b1kbnr/p4ppp/2p1q3/2pp4/4P3/2N2NR1/PPPP1P1P/R1BQK3 w Qkq - 0 10
+2kr3r/p1pbqpb1/Npn1p1pp/2P1P3/3P4/3n1N2/PP4PP/R1BQK2R w KQ - 0 16
+r2q1rk1/ppp2ppp/2nb4/3pp3/1P1P2n1/P1P1PN2/5PPP/RNBQ1RK1 w - - 0 11
+r2qk2r/1pp2pp1/p2p1n1p/2b1p3/2bnP3/P1NPBN1P/1PPQ1PP1/2KR3R w kq - 0 11
+r2qkbnr/1p2ppp1/p1n3bp/3p4/1P4P1/P1NP1N1P/4PP2/R1BQKB1R w KQkq - 0 10
+r3k1r1/1p1nbp2/p1p1pp1p/2Pp4/1P1P3N/2N5/1Pb1PPPP/R3KB1R w KQq - 3 15
+r4rk1/pbp2pp1/1p2pq1p/3n4/3P4/P1PB1N2/2PQ1PPP/R3R1K1 w - - 1 15
+rn1qk2r/pp5p/2p1pnp1/3pp3/4P3/3PQ3/PPP2PPP/RN2K1NR w KQkq - 0 11
+rn1qk1nr/4bppp/p1b1p3/1pp5/2P5/P2P1N2/BP3PPP/RNBQ1RK1 w kq - 3 10
+rn1q1rk1/pp2npbp/2p1b1p1/3p4/3P4/1PN1PN2/PB2BPPP/R2Q1RK1 w - - 3 11
+r2qk1nr/pp2bppp/2pp4/4n3/4P3/1BN5/PPP1QP1P/R1B2K1R w kq - 2 14
+r1bqk2r/pp3pp1/5n1p/2bpN3/2Bn4/2NP4/PPP2PPP/R1BQK2R w KQkq - 0 10
+rnb2rk1/pp3ppp/2p1p3/q7/2BP4/2b1PN2/PPQ2PPP/R4RK1 w - - 0 12
+rnbq1rk1/ppp3bp/4ppp1/3pPn2/3P4/2P1BN1P/PP1Q1PP1/RN2KB1R w KQ - 2 9
+r2q1rk1/ppp2pbp/2np1np1/4p3/3PP1b1/3B1N2/PPP1NPPP/R1BQR1K1 w - - 2 9
+r2q1rk1/1p1n1pp1/p1pbpn1p/5b2/1PBP4/PN2PN1P/1B3PP1/R2QK2R w KQ - 5 12
+r2q1rk1/pppb1ppn/3p3p/8/4Pb2/1PNP2QP/1PP3PN/R4RK1 w - - 0 15
+r1bqr1k1/pp3pp1/3p1nnp/2pP4/2P1PP2/2PN4/P5BP/R1BQ1RK1 w - - 1 15
+r3k1nr/pbpn1pbp/1p1qp1p1/8/2BP4/5N2/PPP2PPP/RNBQ1RK1 w kq - 0 9
+r1bqk2r/pp2bppp/2n1p3/3n4/2BP4/2N2N2/PP3PPP/R1BQK2R w KQkq - 2 9
+r3k1nr/ppp2ppp/2bp4/8/4P3/2qB1P2/PPP3PP/RN3RK1 w kq - 0 12
+rnb1kb1r/pppq3p/3ppp2/8/2P1P3/3B4/PP3PPP/RN1QK1NR w KQkq - 0 9
+r2qkb1r/pp3ppp/2n1pn2/1B1p2B1/3P4/2NQ1b2/PPP2PPP/R3K2R w KQkq - 0 9
+r2qk2r/pp3ppp/2nbpn2/3p1b2/3P4/1BP2N2/PP3PPP/RNBQ1RK1 w kq - 4 9
+r4rk1/p2b1pp1/1p1qpn1p/3p4/3P4/4P3/PP1B1PPP/R2QKB1R w KQ - 0 13
+r1bqk2r/pp3ppp/2n2n2/3p4/1b1N4/1P2P3/PB3PPP/RN1QKB1R w KQkq - 1 9
+r4rk1/1p2bppp/p1b1p3/3n4/3P4/2N2B1P/PP3PP1/R1B2RK1 w - - 6 16
+1rbq1rk1/pp3ppp/3p1b2/3Bp1B1/3pP3/3P1Q1P/PPP2PP1/R3R1K1 w - - 5 14
+1rbq1rk1/2pn1ppp/p4n2/4p3/P1Pp4/R2P1NP1/3NPPBP/3Q1RK1 w - - 0 14
+r4rk1/1pqbbppp/p1nppn2/8/3NP3/2PB1N1P/PP2QPP1/R1B2RK1 w - - 1 12
+r1b1k2r/ppppnppp/5q2/8/3bP3/2P5/PP2BPPP/RN1QK2R w KQkq - 0 9
+r2qk2r/3n1ppp/p2bpn2/1p1p4/3P1Pb1/P1NBPN2/1P4PP/R1BQ1RK1 w kq - 2 11
+r3k2r/2p1q1p1/p2ppn1p/1p2p3/1P1bP3/P1NP2QP/2P1KPP1/1RB4R w kq - 1 17
+rnb1kb1r/3n1p2/2pp2pp/pp2p3/1P2P3/1B1P4/PBP2PPP/RN2K1NR w KQkq - 0 11
+r1b1k2r/ppp1qppp/4p3/4n3/3P4/2nB3P/PP1Q1PP1/R1B1R1K1 w kq - 0 16
+r2q1rk1/pppb1pp1/2nbpn1p/3p4/1P1P4/P1NBPN2/2PB1PPP/R2QK2R w KQ - 1 9
+r2qk2r/1b3ppp/p3pn2/1pb5/8/3BPN2/PP3PPP/R1BQ1RK1 w kq - 0 13
+1rbq1rk1/pp1pnpbp/2n1p1p1/2p5/2P5/2NPP1P1/PP2NPBP/R1BQ1RK1 w - - 3 9

src/controller/ai_vs_ai.cpp

@@ -0,0 +1,38 @@
+#include "ai_vs_ai.hpp"
+
+#include "controller.hpp"
+
+#include <thread>
+
+AIvsAIController::AIvsAIController(Board b, View& v, ai::AI& p1, ai::AI& p2)
+    : Controller(b, v),
+      p1(p1),
+      p2(p2) {}
+
+void AIvsAIController::start() {
+    std::thread view_thread([&]() { view.show(); });
+    ai::AI* current_player;
+    while (!board.is_terminal()) {
+        current_player = board.white_to_play ? &p1 : &p2;
+        std::cout << typeid(*current_player).name() << " to play" << std::endl;
+        Move move = current_player->search(board);
+        make_move(move);
+    }
+
+    view_thread.join();
+}
+
+void AIvsAIController::make_move(Move move) {
+    board = board.make_move(move);
+    std::cout << "Made move: " << move << std::endl;
+    view.update_board(board, -1, {});
+
+    Colour current_colour = board.white_to_play ? White : Black;
+    if (board.is_checkmate())
+        view.notify_checkmate(current_colour);
+
+    if (board.is_stalemate())
+        view.notify_stalemate(current_colour);
+}
+
+void AIvsAIController::on_tile_selected(int, int) {}

src/controller/ai_vs_ai.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../model/ais/ai.hpp"
+#include "../model/utils/coords.hpp"
+#include "../model/utils/move.hpp"
+#include "../view/view.hpp"
+#include "controller.hpp"
+
+class AIvsAIController : public Controller {
+    ai::AI &p1, &p2;
+
+  protected:
+    void make_move(Move) override;
+
+  public:
+    AIvsAIController(Board, View&, ai::AI&, ai::AI&);
+    void on_tile_selected(int, int) override;
+    void start() override;
+};

src/controller/controller.cpp

@@ -0,0 +1,7 @@
+#include "controller.hpp"
+
+#include "../view/view.hpp"
+
+Controller::Controller(Board b, View& v): board(b), view(v) {
+    v.set_controller(this);
+}

src/controller/controller.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../model/board/board.hpp"
+
+class View;
+
+class Controller {
+  protected:
+    Board board;
+    View& view;
+    virtual void make_move(Move) = 0;
+
+  public:
+    Controller(Board, View&);
+    virtual void start() = 0;
+    virtual void on_tile_selected(int, int) = 0;
+};

src/controller/human_vs_ai.cpp

@@ -0,0 +1,29 @@
+#include "human_vs_ai.hpp"
+
+#include <algorithm>
+
+HumanVsAIController::HumanVsAIController(Board b, View& v, ai::AI& ai)
+    : ManualController(b, v),
+      ai(ai) {}
+
+void HumanVsAIController::on_tile_selected(int x, int y) {
+    Coords c{x, y};
+    Piece piece = board.piece_at(c);
+
+    if (selected_index == -1
+        || (piece != Piece::None && piece != selected_piece
+            && (piece & 0b11000) != (selected_piece & 0b11000))) {
+        show_legal_moves(c);
+    } else {
+        auto boh = std::find(targets.begin(), targets.end(), c.to_index());
+        if (boh != targets.end()) {
+            make_move(Move{selected_index, c.to_index()});
+
+            if (board.is_terminal())
+                return;
+            Move ai_move = ai.search(board);
+            make_move(ai_move);
+        } else
+            reset_selection();
+    }
+}

src/controller/human_vs_ai.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../model/ais/ai.hpp"
+#include "../view/view.hpp"
+#include "manual.hpp"
+
+class HumanVsAIController : public ManualController {
+  protected:
+    ai::AI& ai;
+
+  public:
+    HumanVsAIController(Board, View&, ai::AI&);
+    void on_tile_selected(int, int) override;
+};

src/controller/manual.cpp

@@ -0,0 +1,74 @@
+#include "manual.hpp"
+
+#include "../model/utils/utils.hpp"
+
+#include <algorithm>
+
+ManualController::ManualController(Board b, View& v): Controller(b, v) {
+    reset_selection();
+}
+
+void ManualController::start() {
+    reset_selection();
+    view.show();
+}
+
+void ManualController::on_tile_selected(int x, int y) {
+    Coords c{x, y};
+    Piece piece = board.piece_at(c);
+
+    if (selected_index == -1
+        || (piece != Piece::None && piece != selected_piece
+            && (piece & 0b11000) != (selected_piece & 0b11000))) {
+        show_legal_moves(c);
+    } else {
+        auto boh = std::find(targets.begin(), targets.end(), c.to_index());
+        if (boh != targets.end())
+            make_move(Move{selected_index, c.to_index()});
+        else
+            reset_selection();
+    }
+}
+
+void ManualController::reset_selection() {
+    selected_index = -1;
+    selected_piece = Piece::None;
+    targets = {};
+    view.update_board(board, selected_index, targets);
+}
+
+void ManualController::show_legal_moves(Coords xy) {
+    Colour colour = board.colour_at(xy);
+    if (colour) {
+        Colour to_play = board.white_to_play ? White : Black;
+        if (colour != to_play)
+            return;
+        selected_index = xy.to_index();
+        selected_piece = board.piece_at(xy);
+        targets = to_target_square(legal_moves(selected_piece, board, xy));
+        view.update_board(board, xy.to_index(), targets);
+    }
+}
+
+void ManualController::make_move(Move move) {
+    // handle promotion before making the move
+    Colour colour = board.white_to_play ? White : Black;
+    Coords source = Coords::from_index(move.source_square);
+    if (board.piece_at(move.source_square) == Piece::Pawn
+        && board.colour_at(move.source_square) == White && source.y == 6) {
+        Piece promotion_piece = (Piece) (colour | view.ask_about_promotion());
+        move.promoting_to = promotion_piece;
+    }
+
+    std::cout << "Move made: " << move << std::endl;
+
+    board = board.make_move(move);
+    reset_selection();
+
+    Colour current_colour = board.white_to_play ? White : Black;
+    if (board.is_checkmate())
+        view.notify_checkmate(current_colour);
+
+    if (board.is_stalemate())
+        view.notify_stalemate(current_colour);
+}

src/controller/manual.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "../model/utils/coords.hpp"
+#include "../model/utils/move.hpp"
+#include "../view/view.hpp"
+#include "controller.hpp"
+
+class ManualController : public Controller {
+  protected:
+    int8_t selected_index;
+    Piece selected_piece;
+    std::vector<int8_t> targets;
+
+    void reset_selection();
+    void show_legal_moves(Coords);
+    void make_move(Move) override;
+
+  public:
+    ManualController(Board, View&);
+    void on_tile_selected(int, int) override;
+    void start() override;
+};

src/main.cpp

@@ -0,0 +1,81 @@
+#include "controller/ai_vs_ai.hpp"
+#include "controller/controller.hpp"
+#include "controller/human_vs_ai.hpp"
+#include "controller/manual.hpp"
+#include "model/ais/ai.hpp"
+#include "model/perft/perft.hpp"
+#include "view/gui.hpp"
+#include "view/noop.hpp"
+#include "view/view.hpp"
+
+#include <chrono>
+#include <iostream>
+#include <string>
+
+void print_usage() {
+    std::cout << "Usage: chess_ai [OPTIONS]\n";
+    std::cout << "Options:\n";
+    std::cout
+        << "  --mode <human_vs_ai|ai_vs_ai|human_vs_human|perft>  Choose the "
+           "game mode.\n";
+    std::cout << "  --ai1 <version>  Choose the first AI version (for ai_vs_ai "
+                 "mode).\n";
+    std::cout << "  --ai2 <version>  Choose the second AI version (for "
+                 "ai_vs_ai mode).\n";
+    std::cout << "  --fen <FEN_STRING>  Set a custom FEN position.\n";
+    std::cout << "  --help  Show this help message.\n";
+}
+
+int main(int argc, char* argv[]) {
+    std::string mode = "human_vs_ai";
+    std::string ai1_version = "v0_random";
+    std::string ai2_version = "v6_iterative_deepening";
+    std::string fen =
+        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "--mode" && i + 1 < argc) {
+            mode = argv[++i];
+        } else if (arg == "--ai1" && i + 1 < argc) {
+            ai1_version = argv[++i];
+        } else if (arg == "--ai2" && i + 1 < argc) {
+            ai2_version = argv[++i];
+        } else if (arg == "--fen" && i + 1 < argc) {
+            fen = argv[++i];
+        } else if (arg == "--help") {
+            print_usage();
+            return 0;
+        } else {
+            std::cerr << "Unknown option: " << arg << "\n";
+            print_usage();
+            return 1;
+        }
+    }
+
+    Board board = Board::setup_fen_position(fen);
+    GUI gui;
+    Controller* controller = nullptr;
+
+    if (mode == "human_vs_ai") {
+        ai::v6_iterative_deepening ai(false, std::chrono::milliseconds(2000));
+        controller = new HumanVsAIController(board, gui, ai);
+    } else if (mode == "ai_vs_ai") {
+        ai::v0_random p1(true, std::chrono::milliseconds(1000));
+        ai::v6_iterative_deepening p2(false, std::chrono::milliseconds(2000));
+        controller = new AIvsAIController(board, gui, p1, p2);
+    } else if (mode == "human_vs_human") {
+        controller = new ManualController(board, gui);
+    } else if (mode == "perft") {
+        perft();
+        return 0;
+    } else {
+        std::cerr << "Invalid mode selected!\n";
+        print_usage();
+        return 1;
+    }
+
+    controller->start();
+    delete controller;
+    return 0;
+}

src/model/ais/ai.cpp

@@ -0,0 +1,62 @@
+#include "ai.hpp"
+
+#include <condition_variable>
+#include <ostream>
+#include <thread>
+
+static long int position_counter = 0;
+
+Move ai::AI::search(const Board& b) {
+    position_counter = 0;
+    Move result;
+
+    std::condition_variable cv;
+    std::mutex cv_mutex;
+    double elapsed;
+    stop_computation = false;
+
+
+    // Start computation in a separate thread
+    std::thread computation_thread([&]() {
+        auto start = std::chrono::steady_clock::now();
+        result = _search(b);
+        auto end = std::chrono::steady_clock::now();
+        elapsed =
+            std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
+                .count();
+
+        // Notify the timer thread that computation is done
+        {
+            std::lock_guard<std::mutex> lock(cv_mutex);
+            stop_computation = true;
+            cv.notify_one();
+        }
+    });
+
+    // Start a timer thread to stop computation after given time
+    std::thread timer_thread([&]() {
+        std::unique_lock<std::mutex> lock(cv_mutex);
+        if (!cv.wait_for(lock, thinking_time, [&] {
+                return stop_computation.load();
+            })) {
+            // Timeout reached; set stop flag
+            stop_computation = true;
+        }
+    });
+
+    // Wait for computation thread to finish
+    computation_thread.join();
+
+    // Ensure timer thread is also stopped
+    timer_thread.join();
+
+    std::cout << "Took " << elapsed << " ms, " << "Looked at "
+              << position_counter << " positions" << std::endl;
+    return result;
+}
+
+int ai::AI::eval(const Board& b) {
+    int ret = _eval(b);
+    position_counter++;
+    return ret;
+}

src/model/ais/ai.hpp

@@ -0,0 +1,104 @@
+#pragma once
+
+#include "../board/board.hpp"
+
+#include <atomic>
+#include <chrono>
+
+namespace ai {
+    class AI {
+      protected:
+        bool am_white;
+        std::chrono::milliseconds thinking_time;
+        virtual Move _search(const Board&) = 0;
+
+      public:
+        AI(bool am_white, std::chrono::milliseconds tt)
+            : am_white(am_white),
+              thinking_time(tt) {}
+
+        std::atomic<bool> stop_computation = false;
+
+        Move search(const Board& b);
+        int eval(const Board&);
+
+        virtual int _eval(const Board&) = 0;
+    };
+
+    struct v0_random : public AI {
+        v0_random(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
+
+        Move _search(const Board&) override;
+
+        int _eval(const Board&) override {
+            return 0;
+        };
+    };
+
+    class v1_pure_minimax : public AI { // looks two moves ahead
+        int _search(const Board&, int);
+
+      public:
+        v1_pure_minimax(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
+
+        Move _search(const Board&) override;
+        int _eval(const Board&) override;
+    };
+
+    class v2_alpha_beta : public AI {
+        // looks two moves ahead, with alpha-beta pruning (no move ordering)
+        virtual int _search(const Board&, int, int, int);
+
+      public:
+        v2_alpha_beta(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
+
+        virtual Move _search(const Board&) override;
+        virtual int _eval(const Board&) override;
+    };
+
+    class v3_AB_ordering : public AI {
+        // looks two moves ahead, with alpha-beta pruning, with move ordering
+        virtual int _ab_search(const Board&, int, int, int);
+
+      public:
+        v3_AB_ordering(bool w, std::chrono::milliseconds tt): AI(w, tt) {}
+
+        virtual Move _search(const Board&) override;
+        virtual int _eval(const Board&) override;
+    };
+
+    class v4_search_captures : public v3_AB_ordering {
+      protected:
+        // same as v3, but looking at only at captures when leaf is reached,
+        // until no captures are left
+        virtual int _ab_search(const Board&, int, int, int) override;
+        virtual int _search_captures(const Board&, int, int);
+
+      public:
+        v4_search_captures(bool w, std::chrono::milliseconds tt)
+            : v3_AB_ordering(w, tt) {}
+    };
+
+    class v5_better_endgame : public v4_search_captures {
+        // same as v4, but with a better evaluation function, that forces the
+        // king towards the corner of the board for endgames
+
+      public:
+        v5_better_endgame(bool w, std::chrono::milliseconds tt)
+            : v4_search_captures(w, tt) {}
+
+        virtual int _eval(const Board&) override;
+    };
+
+    class v6_iterative_deepening : public v5_better_endgame {
+        // same as v5, but instead of just looking 2 moves ahead, it does
+        // iterative depening until and keeps on searching until the thinking
+        // time runs out
+
+      public:
+        v6_iterative_deepening(bool w, std::chrono::milliseconds tt)
+            : v5_better_endgame(w, tt) {}
+
+        virtual Move _search(const Board&) override;
+    };
+} // namespace ai

src/model/ais/v0_random.cpp

@@ -0,0 +1,13 @@
+#include "ai.hpp"
+
+#include <thread>
+
+Move ai::v0_random::_search(const Board& b) {
+    std::vector<Move> moves = b.all_legal_moves();
+
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(thinking_time)
+    ); // Simulate work
+
+    return moves[rand() % moves.size()];
+}

src/model/ais/v1_pure_minimax.cpp

@@ -0,0 +1,86 @@
+#include "../pieces/piece.hpp"
+#include "../utils/threadpool.hpp"
+#include "../utils/utils.hpp"
+#include "ai.hpp"
+
+#include <map>
+
+#define MULTITHREADED 1
+
+Move ai::v1_pure_minimax::_search(const Board& b) {
+    std::vector<Move> moves = b.all_legal_moves();
+
+    Move best_move;
+    int best_eval = -INFINITY;
+#if MULTITHREADED
+    ThreadPool pool(std::thread::hardware_concurrency());
+
+    std::cout << "Have to look at " << moves.size() << " moves" << std::endl;
+
+    std::map<Move, std::future<int>> futures;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        futures.insert({move, pool.enqueue([&, tmp_board]() {
+                            return _search(tmp_board, 3);
+                        })});
+    }
+
+    int counter = 0;
+    for (auto& [move, future] : futures) {
+        int eval = future.get();
+        counter++;
+        if (!am_white)
+            eval *= -1;
+        if (eval > best_eval) {
+            best_eval = eval;
+            best_move = move;
+        }
+    }
+#else
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        std::cout << "Looking at " << move << std::endl;
+        int eval = _search(tmp_board, 3);
+        if (!am_white)
+            eval *= -1;
+        if (eval > best_eval) {
+            best_eval = eval;
+            best_move = move;
+        }
+    }
+#endif
+    return best_move;
+}
+
+int ai::v1_pure_minimax::_search(const Board& b, int depth) {
+    if (depth == 0 || stop_computation)
+        return eval(b);
+
+    if (b.no_legal_moves()) {
+        if (b.is_check())
+            return -INFINITY;
+        return 0;
+    }
+
+    std::vector<Move> moves = b.all_legal_moves();
+
+    int best_evaluation = -INFINITY;
+    Move best_move;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        int tmp_eval = -_search(tmp_board, depth - 1);
+        best_evaluation = std::max(best_evaluation, tmp_eval);
+    }
+    return best_evaluation;
+}
+
+int ai::v1_pure_minimax::_eval(const Board& b) {
+    int white_eval = count_material(b, Colour::White);
+    int black_eval = count_material(b, Colour::Black);
+
+    int evaluation = white_eval - black_eval;
+
+    int perspective = b.white_to_play ? 1 : -1;
+
+    return perspective * evaluation;
+}

src/model/ais/v2_alpha_beta.cpp

@@ -0,0 +1,86 @@
+#include "../pieces/piece.hpp"
+#include "../utils/threadpool.hpp"
+#include "../utils/utils.hpp"
+#include "ai.hpp"
+
+#include <map>
+
+#define MULTITHREADED 1
+
+Move ai::v2_alpha_beta::_search(const Board& b) {
+    std::vector<Move> moves = b.all_legal_moves();
+
+    Move best_move;
+    int best_eval = -INFINITY;
+#if MULTITHREADED
+    ThreadPool pool(std::thread::hardware_concurrency());
+
+    std::cout << "Have to look at " << moves.size() << " moves" << std::endl;
+
+    std::map<Move, std::future<int>> futures;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        futures.insert({move, pool.enqueue([&, tmp_board]() {
+                            return _search(tmp_board, 3, -INFINITY, INFINITY);
+                        })});
+    }
+
+    int counter = 0;
+    for (auto& [move, future] : futures) {
+        int eval = future.get();
+        counter++;
+        if (!am_white)
+            eval *= -1;
+        if (eval > best_eval) {
+            best_eval = eval;
+            best_move = move;
+        }
+    }
+#else
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        std::cout << "Looking at " << move << std::endl;
+        int eval = _search(tmp_board, 3);
+        if (!am_white)
+            eval *= -1;
+        if (eval > best_eval) {
+            best_eval = eval;
+            best_move = move;
+        }
+    }
+#endif
+    return best_move;
+}
+
+int ai::v2_alpha_beta::_search(const Board& b, int depth, int alpha, int beta) {
+    if (depth == 0 || stop_computation)
+        return eval(b);
+
+    if (b.no_legal_moves()) {
+        if (b.is_check())
+            return -INFINITY;
+        return 0;
+    }
+
+    std::vector<Move> moves = b.all_legal_moves();
+
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        int tmp_eval = -_search(tmp_board, depth - 1, -beta, -alpha);
+        if (tmp_eval >= beta)
+            return beta;
+        alpha = std::max(alpha, tmp_eval);
+    }
+    return alpha;
+}
+
+int ai::v2_alpha_beta::_eval(const Board& b) {
+    int white_eval = count_material(b, Colour::White);
+    int black_eval = count_material(b, Colour::Black);
+
+    int evaluation = white_eval - black_eval;
+
+    int perspective = b.white_to_play ? 1 : -1;
+
+    return perspective * evaluation;
+}

src/model/ais/v3_AB_ordering.cpp

@@ -0,0 +1,104 @@
+#include "../pieces/piece.hpp"
+#include "../utils/threadpool.hpp"
+#include "../utils/utils.hpp"
+#include "ai.hpp"
+
+#include <algorithm>
+#include <map>
+
+#define MULTITHREADED 1
+
+Move ai::v3_AB_ordering::_search(const Board& b) {
+    std::vector<Move> moves = b.all_legal_moves();
+    std::sort(moves.begin(), moves.end(), [&](Move& m1, Move& m2) {
+        int score = m1.score_guess(b) - m2.score_guess(b);
+        if (!am_white)
+            score *= -1;
+        return score < 0;
+    });
+
+    Move best_move;
+    int best_eval = -INFINITY;
+#if MULTITHREADED
+    ThreadPool pool(std::thread::hardware_concurrency());
+
+    std::cout << "Have to look at " << moves.size() << " moves" << std::endl;
+
+    std::map<Move, std::future<int>> futures;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        futures.insert(
+            {move, pool.enqueue([&, tmp_board]() {
+                 return _ab_search(tmp_board, 3, -INFINITY, INFINITY);
+             })}
+        );
+    }
+
+    int counter = 0;
+    for (auto& [move, future] : futures) {
+        int eval = future.get();
+        counter++;
+        if (!am_white)
+            eval *= -1;
+        if (eval > best_eval) {
+            best_eval = eval;
+            best_move = move;
+        }
+    }
+#else
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        std::cout << "Looking at " << move << std::endl;
+        int eval = _search(tmp_board, 3);
+        if (!am_white)
+            eval *= -1;
+        if (eval > best_eval) {
+            best_eval = eval;
+            best_move = move;
+        }
+    }
+#endif
+    return best_move;
+}
+
+int ai::v3_AB_ordering::_ab_search(
+    const Board& b, int depth, int alpha, int beta
+) {
+    if (depth == 0 || stop_computation)
+        return eval(b);
+
+    if (b.no_legal_moves()) {
+        if (b.is_check())
+            return -INFINITY;
+        return 0;
+    }
+
+    std::vector<Move> moves = b.all_legal_moves();
+    std::sort(moves.begin(), moves.end(), [&](Move& m1, Move& m2) {
+        int score = m1.score_guess(b) - m2.score_guess(b);
+        if (!am_white)
+            score *= -1;
+        return score < 0;
+    });
+
+    Move best_move;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        int tmp_eval = -_ab_search(tmp_board, depth - 1, -beta, -alpha);
+        if (tmp_eval >= beta)
+            return beta;
+        alpha = std::max(alpha, tmp_eval);
+    }
+    return alpha;
+}
+
+int ai::v3_AB_ordering::_eval(const Board& b) {
+    int white_eval = count_material(b, Colour::White);
+    int black_eval = count_material(b, Colour::Black);
+
+    int evaluation = white_eval - black_eval;
+
+    int perspective = b.white_to_play ? 1 : -1;
+
+    return perspective * evaluation;
+}

src/model/ais/v4_search_captures.cpp

@@ -0,0 +1,58 @@
+#include "../pieces/piece.hpp"
+#include "../utils/utils.hpp"
+#include "ai.hpp"
+
+#include <algorithm>
+
+#define MULTITHREADED 1
+
+int ai::v4_search_captures::_ab_search(
+    const Board& b, int depth, int alpha, int beta
+) {
+    if (depth == 0 || stop_computation)
+        return _search_captures(b, alpha, beta);
+
+    if (b.no_legal_moves()) {
+        if (b.is_check())
+            return -INFINITY;
+        return 0;
+    }
+
+    std::vector<Move> moves = b.all_legal_moves();
+    std::sort(moves.begin(), moves.end(), [&](Move& m1, Move& m2) {
+        return m1.score_guess(b) > m2.score_guess(b);
+    });
+
+    Move best_move;
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        int tmp_eval = -_ab_search(tmp_board, depth - 1, -beta, -alpha);
+        if (tmp_eval >= beta)
+            return beta;
+        alpha = std::max(alpha, tmp_eval);
+    }
+    return alpha;
+}
+
+int ai::v4_search_captures::_search_captures(
+    const Board& b, int alpha, int beta
+) {
+    int evaluation = eval(b);
+    if (evaluation >= beta)
+        return beta;
+    alpha = std::max(evaluation, alpha);
+
+    std::vector<Move> moves = b.all_capturing_moves();
+    std::sort(moves.begin(), moves.end(), [&](Move& m1, Move& m2) {
+        return m1.score_guess(b) > m2.score_guess(b);
+    });
+
+    for (const Move& move : moves) {
+        Board tmp_board = b.make_move(move);
+        int tmp_eval = -_search_captures(tmp_board, -beta, -alpha);
+        if (tmp_eval >= beta)
+            return beta;
+        alpha = std::max(alpha, tmp_eval);
+    }
+    return alpha;
+}

src/model/ais/v5_better_endgames.cpp

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

src/model/ais/v6_iterative_deepening.cpp

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

src/model/board/board.cpp

@@ -1,12 +1,15 @@
 #include "board.hpp"
 
-#include "coords.hpp"
-#include "move.hpp"
-#include "pieces/piece.hpp"
+#include "../pieces/piece.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
+#include "../utils/utils.hpp"
 
+#include <SFML/Graphics/BlendMode.hpp>
 #include <algorithm>
 #include <cctype>
 #include <map>
+#include <sstream>
 #include <stdexcept>
 
 Board Board::setup_fen_position(std::string fen) {
@@ -91,6 +94,8 @@ Board Board::setup_fen_position(std::string fen) {
     index = fen.find(' ', index) + 1;
     board.n_full_moves = std::stoi(fen.substr(index));
 
+    board.check = board._is_check_for(board.white_to_play ? White : Black);
+    board.nlm = board._no_legal_moves_for(board.white_to_play ? White : Black);
 
     return board;
 }
@@ -110,14 +115,14 @@ std::string Board::to_fen() const {
     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) {
+            if (piece_at({file, rank}) == 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});
+            Colour colour = colour_at({file, rank});
 
             if (empty_cell_counter > 0) {
                 ret += std::to_string(empty_cell_counter);
@@ -168,7 +173,14 @@ std::string Board::to_fen() const {
     return ret;
 }
 
-Board Board::make_move(Move move) const {
+Board Board::skip_turn() const {
+    Board ret = *this;
+    ret.white_to_play = !ret.white_to_play;
+    ret.check = ret._is_check_for(ret.white_to_play ? White : Black);
+    return ret;
+}
+
+Board Board::make_move(Move move, bool recurse_call) const {
     Board ret;
     std::copy(
         std::begin(this->squares),
@@ -181,10 +193,12 @@ Board Board::make_move(Move move) const {
     ret.squares[move.source_square] = Piece::None;
     ret.squares[move.target_square] = this->squares[move.source_square];
 
+    Piece source_piece = piece_at(move.source_square);
+    Piece target_piece = piece_at(move.target_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)
+    if (en_passant_target != -1 && source_piece == Piece::Pawn
+        && target_piece == Piece::None)
         ret.squares[move.target_square + (white_to_play ? -8 : 8)] =
             Piece::None;
 
@@ -193,7 +207,7 @@ Board Board::make_move(Move move) const {
         ret.squares[move.target_square] = move.promoting_to;
 
     // -- Set en passant target if need
-    if ((squares[move.source_square] & 0b111) == Piece::Pawn
+    if (source_piece == Piece::Pawn
         && std::abs(move.target_square - move.source_square) == 16) {
         if (white_to_play)
             ret.en_passant_target = move.target_square - 8;
@@ -205,7 +219,7 @@ Board Board::make_move(Move move) const {
 
     // -- Handle castling (just move the rook over)
     Coords c = Coords::from_index(move.source_square);
-    if ((squares[move.source_square] & 0b111) == Piece::King) {
+    if (source_piece == 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()];
@@ -226,10 +240,10 @@ Board Board::make_move(Move move) const {
     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)
+        if (source_piece == King)
             ret.w_castle_rights = NeitherSide;
 
-        if ((squares[move.source_square] & 0b111) == Rook) {
+        if (source_piece == Rook) {
             if (c.x == 0 && (ret.w_castle_rights & QueenSide))
                 ret.w_castle_rights &= ~(QueenSide);
             if (c.x == 7 && (ret.w_castle_rights & KingSide))
@@ -237,18 +251,17 @@ Board Board::make_move(Move move) const {
         }
 
         Coords target = Coords::from_index(move.target_square);
-        if (is_capturing && target.y == 7
-            && (squares[move.target_square] & 0b111) == Rook) {
+        if (is_capturing && target.y == 7 && target_piece == 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)
+        if (source_piece == King)
             ret.b_castle_rights = NeitherSide;
 
-        if ((squares[move.source_square] & 0b111) == Rook) {
+        if (source_piece == Rook) {
             if (c.x == 0 && (ret.b_castle_rights & QueenSide))
                 ret.b_castle_rights &= ~(QueenSide);
             if (c.x == 7 && (ret.b_castle_rights & KingSide))
@@ -256,8 +269,7 @@ Board Board::make_move(Move move) const {
         }
 
         Coords target = Coords::from_index(move.target_square);
-        if (is_capturing && target.y == 0
-            && (squares[move.target_square] & 0b111) == Rook) {
+        if (is_capturing && target.y == 0 && target_piece == Rook) {
             if (target.x == 0 && (ret.w_castle_rights & QueenSide))
                 ret.w_castle_rights &= ~(QueenSide);
             if (target.x == 7 && (ret.w_castle_rights & KingSide))
@@ -265,32 +277,65 @@ Board Board::make_move(Move move) const {
         }
     }
 
+    ret.n_half_moves = n_half_moves + 1;
+    if (is_capturing || piece_at(move.source_square) == Piece::Pawn)
+        ret.n_half_moves = 0;
+    if (!white_to_play)
+        ret.n_full_moves = n_full_moves + 1;
+
+    if (ret.n_half_moves > 150) {
+        std::cerr << "too many recursions" << std::endl;
+        exit(1);
+    }
+
+    if (recurse_call) {
+        ret.check = ret._is_check_for(ret.white_to_play ? White : Black);
+        ret.nlm = ret._no_legal_moves_for(ret.white_to_play ? White : Black);
+    }
     return ret;
 }
 
+bool Board::insufficient_material_for(Colour current_colour) const {
+    int n_bishop = 0, n_knight = 0;
+
+    for (int i = 0; i < 64; i++) {
+        Colour colour = colour_at(i);
+        if (colour != current_colour)
+            continue;
+
+        Piece piece = piece_at(i);
+        if (piece == Piece::Pawn || piece == Piece::Queen
+            || piece == Piece::Rook)
+            return false;
+
+        if (piece == Piece::Bishop)
+            n_bishop++;
+        if (piece == Piece::Knigt && colour == Colour::White)
+            n_knight++;
+    }
+    return (n_bishop == 0 && n_knight == 0) || (n_bishop == 1 && n_knight == 0)
+        || (n_bishop == 0 && n_knight == 1);
+}
+
 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::stringstream ss;
+    ss << "Apparently there no kings of the such color in this board: "
+       << std::endl;
+    ss << to_fen();
+    throw std::domain_error(ss.str());
 }
 
-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 {
+bool Board::_is_check_for(Colour colour) const {
     int8_t king_idx = this->get_king_of(colour);
-    for (int i = 0; i < 64; i++) {
+    std::vector<Move> all_moves;
+    all_moves.reserve(50);
+    for (int8_t 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) {
+        if (piece_at(i) == 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);
@@ -298,7 +343,7 @@ bool Board::is_check_for(int8_t colour) const {
                 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());
+                        all_moves.push_back(Move{i, c.to_index()});
                 }
             }
         } else {
@@ -308,27 +353,51 @@ bool Board::is_check_for(int8_t colour) const {
                 Coords::from_index(i),
                 true
             );
-            targets = to_target_square(moves);
+
+            all_moves.insert(all_moves.end(), moves.begin(), moves.end());
         }
-        if (std::find(targets.begin(), targets.end(), king_idx)
-            != targets.end())
-            return true;
+
+        for (const Move& move : all_moves)
+            if (move.target_square == king_idx)
+                return true;
+        all_moves.clear();
     }
     return false;
 }
 
-bool Board::no_legal_moves_for(int8_t colour) const {
+bool Board::_no_legal_moves_for(Colour 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;
-        }
+        if (squares[i] == Piece::None || colour_at(i) != colour)
+            continue;
+        std::vector<Move> moves;
+        moves = legal_moves(squares[i], *this, Coords::from_index(i));
+        if (moves.size() > 0)
+            return false;
     }
     return true;
 }
 
+bool Board::no_legal_moves() const {
+    return nlm;
+}
+
+bool Board::is_check() const {
+    return check;
+}
+
+bool Board::is_checkmate() const {
+    return check && nlm;
+}
+
+bool Board::is_stalemate() const {
+    return !check && nlm;
+}
+
+bool Board::is_terminal() const {
+    return n_half_moves == 100 || insufficient_material() || is_checkmate()
+        || is_stalemate();
+}
+
 std::vector<Move> Board::all_legal_moves() const {
     std::vector<Move> ret;
     for (int i = 0; i < 64; i++) {
@@ -341,3 +410,28 @@ std::vector<Move> Board::all_legal_moves() const {
     }
     return ret;
 }
+
+std::vector<Move> Board::all_capturing_moves() const {
+    std::vector<Move> moves = all_legal_moves();
+    std::vector<Move> ret;
+    ret.reserve(moves.size());
+    for (const Move& move : moves)
+        if (piece_at(move.target_square) != Piece::None)
+            ret.push_back(move);
+
+    return ret;
+}
+
+std::vector<int8_t> Board::opponent_pawn_attack_map() const {
+    std::vector<int8_t> ret;
+    for (int i = 0; i < 64; i++) {
+        if (piece_at(i) == Piece::Pawn
+            && ((colour_at(i) == White && !white_to_play)
+                || (colour_at(i) == Black && white_to_play))) {
+            std::vector<int8_t> attack_map =
+                pawn_attack_map(*this, Coords::from_index(i));
+            ret.insert(ret.end(), attack_map.begin(), attack_map.end());
+        }
+    }
+    return ret;
+}

src/model/board/board.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "../pieces/piece.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
+
+#include <string>
+
+struct Board {
+  private:
+    bool _no_legal_moves_for(Colour) const;
+    bool _is_check_for(Colour) const;
+    bool nlm = false, check = false;
+
+  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;
+    int n_half_moves = 0;
+    int n_full_moves = 0;
+
+
+    static Board setup_fen_position(std::string fen);
+
+    int8_t get_king_of(int8_t) const;
+    Board skip_turn() const;
+    Board make_move(Move, bool = true) const;
+    std::string to_fen() const;
+    bool no_legal_moves() const;
+    bool is_check() const;
+    bool insufficient_material_for(Colour) const;
+
+    bool insufficient_material() const {
+        return insufficient_material_for(White)
+            && insufficient_material_for(Black);
+    };
+
+    std::vector<Move> all_legal_moves() const;
+    std::vector<Move> all_capturing_moves() const;
+    std::vector<int8_t> opponent_pawn_attack_map() const;
+
+    bool is_checkmate() const;
+
+    bool is_stalemate() const;
+
+    bool is_terminal() const;
+
+    inline Piece piece_at(int8_t idx) const {
+        return (Piece) (squares[idx] & 0b00111);
+    }
+
+    inline Piece piece_at(Coords xy) const {
+        return piece_at(xy.to_index());
+    }
+
+    inline Colour colour_at(int8_t idx) const {
+        return (Colour) (squares[idx] & 0b11000);
+    }
+
+    inline Colour colour_at(Coords xy) const {
+        return colour_at(xy.to_index());
+    }
+};
+
+inline bool operator<(const Board& m1, const Board& m2) {
+    return m1.to_fen() < m2.to_fen(
+           ); // TODO: make this the comparison between the hash of the board
+}

src/model/perft/perft.cpp

@@ -1,8 +1,8 @@
 #include "perft.hpp"
 
-#include "board.hpp"
-#include "move.hpp"
-#include "threadpool.hpp"
+#include "../board/board.hpp"
+#include "../utils/move.hpp"
+#include "../utils/threadpool.hpp"
 
 #include <chrono>
 #include <map>
@@ -47,7 +47,7 @@ static std::map<std::string, std::map<int, int>> pos2expected{
             {3, 2812},   // 11
             {4, 43238},  // 157
             {5, 674624}, // 2199
-            // {6, 11030083},
+            {6, 11030083},
         },
     },
 
@@ -55,11 +55,11 @@ static std::map<std::string, std::map<int, int>> pos2expected{
     {
         "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
+            {1, 6},        // 0
+            {2, 264},      // 1
+            {3, 9467},     // 69
+            {4, 422333},   // 3085
+            {5, 15833292}, // 124452
         },
     },
 
@@ -67,11 +67,11 @@ static std::map<std::string, std::map<int, int>> pos2expected{
     {
         "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
+            {1, 6},        // 0
+            {2, 264},      // 2
+            {3, 9467},     // 104
+            {4, 422333},   // 3742
+            {5, 15833292}, // 136784
         },
     },
 
@@ -79,10 +79,10 @@ static std::map<std::string, std::map<int, int>> pos2expected{
     {
         "rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 6",
         {
-            {1, 44},    // 0
-            {2, 1486},  // 12
-            {3, 62379}, // 357
-            // {4, 2103487}, // 13804
+            {1, 44},      // 0
+            {2, 1486},    // 12
+            {3, 62379},   // 357
+            {4, 2103487}, // 13804
             // {5, 89941194}, // 1230428
         },
     },
@@ -92,10 +92,10 @@ static std::map<std::string, std::map<int, int>> pos2expected{
         "r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 "
         "7",
         {
-            {1, 46},    // 0
-            {2, 2079},  // 16
-            {3, 89890}, // 602
-            // {4, 3894594}, // 26612
+            {1, 46},      // 0
+            {2, 2079},    // 16
+            {3, 89890},   // 602
+            {4, 3894594}, // 26612
             // {5, 164075551}, // 1230428
         },
     },
@@ -141,6 +141,7 @@ int move_generation_test(
     } else {
         // Regular sequential execution
         for (const Move& move : moves) {
+            // std::cout << "Looking at " << move << std::endl;
             Board tmp_board = b.make_move(move);
             int n = move_generation_test(tmp_board, depth - 1, max_depth, pool);
             if (depth == max_depth)

src/model/pieces/bishop.cpp

@@ -1,6 +1,6 @@
-#include "../board.hpp"
-#include "../coords.hpp"
-#include "../move.hpp"
+#include "../board/board.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
 #include "piece.hpp"
 
 #include <vector>

src/model/pieces/king.cpp

@@ -1,5 +1,6 @@
-#include "../board.hpp"
-#include "../coords.hpp"
+#include "../board/board.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
 #include "piece.hpp"
 
 static bool is_clear_king_side(const Board& b, const Coords xy) {
@@ -9,8 +10,9 @@ static bool is_clear_king_side(const Board& b, const Coords xy) {
             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)))
+        Board board_after_move = b.make_move(move.value(), false);
+        board_after_move = board_after_move.skip_turn();
+        if (board_after_move.is_check())
             return false;
     }
     return true;
@@ -23,8 +25,9 @@ static bool is_clear_queen_side(const Board& b, const Coords xy) {
             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)))
+        Board board_after_move = b.make_move(move.value(), false);
+        board_after_move = board_after_move.skip_turn();
+        if (dx < 3 && board_after_move.is_check())
             return false;
     }
     return true;
@@ -45,7 +48,8 @@ std::vector<Move> king_moves(const Board& b, const Coords xy) {
         }
     }
 
-    if (b.is_check_for(b.colour_at(xy)))
+
+    if (b.is_check())
         return keep_only_blocking(ret, b);
 
     // -- Castles

src/model/pieces/knight.cpp

@@ -1,6 +1,6 @@
-#include "../board.hpp"
-#include "../coords.hpp"
-#include "../move.hpp"
+#include "../board/board.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
 #include "piece.hpp"
 
 #include <vector>

src/model/pieces/pawn.cpp

@@ -0,0 +1,102 @@
+#include "../board/board.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
+#include "piece.hpp"
+
+std::vector<Move> pawn_moves(const Board& b, const Coords xy) {
+    std::vector<Move> ret{};
+    Colour 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 && 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(),
+                        (Piece) (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 && 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(),
+                        (Piece) (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(),
+                    (Piece) (my_colour | piece)
+                });
+        else
+            ret.push_back(Move{
+                xy.to_index(),
+                new_xy.to_index(),
+            });
+    }
+
+    return ret;
+}
+
+std::vector<int8_t> pawn_attack_map(const Board& b, Coords xy) {
+    std::vector<int8_t> ret{};
+    Colour 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};
+        ret.push_back(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};
+        ret.push_back(right.to_index());
+    }
+
+    return ret;
+}

src/model/pieces/piece.cpp

@@ -1,18 +1,20 @@
 #include "piece.hpp"
 
-#include "../board.hpp"
-#include "../coords.hpp"
+#include "../board/board.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.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))
+        Board board_after_move = board.make_move(move, false);
+        board_after_move = board_after_move.skip_turn();
+
+        if (!board_after_move.is_check())
             ret.push_back(move);
     }
     return ret;

src/model/pieces/piece.hpp

@@ -20,7 +20,42 @@ enum Colour : int8_t {
     Black = 16,
 };
 
-inline std::ostream& operator<<(std::ostream& os, const int8_t& i) {
+inline const char* to_string(Colour c) {
+    switch (c) {
+    case White:
+        return "White";
+    case Black:
+        return "Black";
+    default:
+        return "[Unknown Colour]";
+    }
+}
+
+inline const char* to_string(Piece c) {
+    switch (c) {
+    case Pawn:
+        return "Pawn";
+    case Rook:
+        return "Rook";
+    case Bishop:
+        return "Bishop";
+    case Knigt:
+        return "Knight";
+    case Queen:
+        return "Queen";
+    case King:
+        return "King";
+    default:
+        return "[Unknown Colour]";
+    }
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Colour& i) {
+    os << std::to_string(i);
+    return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Piece& i) {
     os << std::to_string(i);
     return os;
 }
@@ -34,6 +69,7 @@ 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<int8_t> pawn_attack_map(const Board&, const Coords);
 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);

src/model/pieces/queen.cpp

@@ -1,6 +1,6 @@
-#include "../board.hpp"
-#include "../coords.hpp"
-#include "../move.hpp"
+#include "../board/board.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
 #include "piece.hpp"
 
 #include <vector>

src/model/pieces/rook.cpp

@@ -1,6 +1,6 @@
-#include "../board.hpp"
-#include "../coords.hpp"
-#include "../move.hpp"
+#include "../board/board.hpp"
+#include "../utils/coords.hpp"
+#include "../utils/move.hpp"
 #include "piece.hpp"
 
 #include <vector>

src/model/utils/move.cpp

@@ -0,0 +1,54 @@
+#include "move.hpp"
+
+#include "../board/board.hpp"
+#include "utils.hpp"
+
+#include <algorithm>
+
+int Move::score_guess(const Board& b) const {
+    int ret = 0;
+
+    Piece me_piece = b.piece_at(source_square);
+    Piece captured_piece = b.piece_at(target_square);
+
+    if (captured_piece != Piece::None)
+        ret += 10 * piece_value(captured_piece) - piece_value(me_piece);
+
+    if (promoting_to != Piece::None)
+        ret += piece_value(promoting_to);
+
+    std::vector<int8_t> pawn_attack_map = b.opponent_pawn_attack_map();
+    if (std::find(pawn_attack_map.begin(), pawn_attack_map.end(), target_square)
+        != pawn_attack_map.end())
+        ret -= me_piece;
+
+    return ret;
+}
+
+Move Move::from_string(std::string move) {
+    if (!(4 <= move.size() && move.size() <= 5))
+        throw std::invalid_argument("Move must be 4 or 5 characters long");
+    Move ret;
+    ret.source_square = Coords::from_algebraic(move.substr(0, 2)).to_index();
+    ret.target_square = Coords::from_algebraic(move.substr(2, 2)).to_index();
+    if (move.size() == 5)
+        switch (move[4]) {
+        case 'n':
+            ret.promoting_to = Knigt;
+            break;
+        case 'b':
+            ret.promoting_to = Bishop;
+            break;
+        case 'r':
+            ret.promoting_to = Rook;
+            break;
+        case 'q':
+            ret.promoting_to = Queen;
+            break;
+        default:
+            throw std::invalid_argument("Promotion piece must be one of 'nbrq'"
+            );
+        }
+    ret.target_square = Coords::from_algebraic(move.substr(2, 2)).to_index();
+    return ret;
+}

src/model/utils/move.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "castle_side.hpp"
+#include "../board/castle_side.hpp"
+#include "../pieces/piece.hpp"
 #include "coords.hpp"
-#include "pieces/piece.hpp"
 
 #include <cstdint>
 #include <sstream>
@@ -11,7 +11,11 @@ struct Move {
     int8_t source_square;
     int8_t target_square;
 
-    int8_t promoting_to = Piece::None;
+    Piece promoting_to = Piece::None;
+
+    int score_guess(const Board&) const;
+
+    static Move from_string(std::string);
 
     std::string to_string() const {
         std::stringstream ss;
@@ -39,6 +43,10 @@ struct Move {
     }
 };
 
+inline bool operator<(const Move& m1, const Move& m2) {
+    return m1.to_string() < m2.to_string();
+}
+
 inline std::ostream& operator<<(std::ostream& os, const Move& m) {
     os << m.to_string();
     return os;

src/model/utils/utils.cpp

@@ -0,0 +1,38 @@
+#include "utils.hpp"
+
+#include "../board/board.hpp"
+
+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;
+}
+
+int piece_value(Piece p) {
+    switch (p) {
+    case Piece::Pawn:
+        return PawnValue;
+    case Piece::Knigt:
+        return KnightValue;
+    case Piece::Bishop:
+        return BishopValue;
+    case Piece::Rook:
+        return RookValue;
+    case Piece::Queen:
+        return QueenValue;
+    default:
+        return 0;
+    }
+}
+
+int count_material(const Board& b, int8_t colour, bool count_pawns) {
+    int ret = 0;
+    for (int i = 0; i < 64; i++) {
+        if (b.piece_at(i) == Pawn && !count_pawns)
+            continue;
+        if (b.colour_at(i) == colour)
+            ret += piece_value(b.piece_at(i));
+    }
+    return ret;
+}

src/model/utils/utils.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "move.hpp"
+
+#include <cstdint>
+#include <limits>
+#include <vector>
+
+std::vector<int8_t> to_target_square(std::vector<Move>);
+int count_material(const Board&, int8_t, bool = true);
+int piece_value(Piece);
+
+const int INFINITY = std::numeric_limits<int>::max();
+
+const int PawnValue = 100;
+const int KnightValue = 300;
+const int BishopValue = 320;
+const int RookValue = 500;
+const int QueenValue = 900;

src/view/gui.cpp

@@ -0,0 +1,215 @@
+#include "gui.hpp"
+
+#include "../model/utils/utils.hpp"
+
+#include <SFML/Graphics/Color.hpp>
+#include <SFML/System/Vector2.hpp>
+
+GUI::GUI() {
+    window.create(sf::VideoMode(WINDOW_SIZE, WINDOW_SIZE), "Chess Board");
+    load_textures();
+
+    font.loadFromFile("res/arial.ttf");
+}
+
+void GUI::update_board(
+    const Board& b, int8_t selected_square, std::vector<int8_t> targets
+) {
+    window.clear();
+    draw_board(selected_square, targets);
+    draw_pieces(b);
+    window.display();
+}
+
+void GUI::notify_stalemate(Colour col) {
+    std::cout << "Stalemate for " << to_string(col) << std::endl;
+}
+
+void GUI::notify_checkmate(Colour col) {
+    std::cout << "Checkmate for " << to_string(col) << std::endl;
+}
+
+void GUI::handle_events() {
+    sf::Event event;
+    while (window.pollEvent(event))
+        if (event.type == sf::Event::Closed)
+            window.close();
+        else if (event.type == sf::Event::MouseButtonPressed)
+            handle_click(event.mouseButton.x, event.mouseButton.y);
+}
+
+void GUI::load_textures() {
+    const std::string names[6] =
+        {"rook", "knight", "bishop", "queen", "king", "pawn"
+        }; // don't touch the order, it's reflecting the one in the Piece enum
+    for (int i = 0; i < 6; ++i) {
+        textures[i][0].loadFromFile("res/pieces/white-" + names[i] + ".png");
+        textures[i][1].loadFromFile("res/pieces/black-" + names[i] + ".png");
+    }
+}
+
+void GUI::handle_click(int x, int y) {
+    int file = x / TILE_SIZE;
+    int rank = 7 - (y / TILE_SIZE);
+    controller->on_tile_selected(file, rank);
+}
+
+void GUI::draw_annotation(int file, int rank) {
+    if (file == 0) {
+        sf::Text annotation(std::to_string(rank + 1), font);
+        annotation.setStyle(sf::Text::Bold);
+        annotation.setCharacterSize(16);
+        annotation.setFillColor(rank % 2 == 0 ? colours[1] : colours[0]);
+        annotation.setPosition(
+            (file + .05) * TILE_SIZE,
+            (7 - rank + .05) * TILE_SIZE
+        );
+        window.draw(annotation);
+    }
+
+    if (rank == 0) {
+        sf::Text annotation("abcdefgh"[file], font);
+        annotation.setCharacterSize(16);
+        annotation.setOrigin(16, 16);
+        annotation.setStyle(sf::Text::Bold);
+        annotation.setFillColor(file % 2 == 0 ? colours[1] : colours[0]);
+        annotation.setPosition(
+            (file + 1) * TILE_SIZE,
+            (7 - rank + .95) * TILE_SIZE
+        );
+        window.draw(annotation);
+    }
+}
+
+void GUI::draw_board(int selected_square, std::vector<int8_t> targets) {
+    sf::RectangleShape square(sf::Vector2f(TILE_SIZE, TILE_SIZE));
+    for (int rank = 0; rank < 8; ++rank) {
+        for (int file = 0; file < 8; ++file) {
+            int8_t index = Coords{file, rank}.to_index();
+            square.setPosition(file * TILE_SIZE, (7 - rank) * TILE_SIZE);
+            if (index == selected_square)
+                square.setFillColor(
+                    (file + rank) % 2 == 0 ? alt_colours[0] : alt_colours[1]
+                );
+            else
+                square.setFillColor(
+                    (file + rank) % 2 == 0 ? colours[0] : colours[1]
+                );
+            window.draw(square);
+            draw_annotation(file, rank);
+
+            if (std::find(targets.begin(), targets.end(), index)
+                != targets.end()) {
+                float r = .15 * TILE_SIZE;
+                sf::CircleShape circle{r};
+                sf::Color c(0x00000055);
+                circle.setFillColor(c);
+                circle.setOrigin(r, r);
+                circle.setPosition(
+                    (file + .5) * TILE_SIZE,
+                    (7 - rank + .5) * TILE_SIZE
+                );
+                window.draw(circle);
+            }
+        }
+    }
+}
+
+void GUI::draw_pieces(const Board& board) {
+    for (int i = 0; i < 64; ++i) {
+        int piece = board.piece_at(i);
+        if (piece != Piece::None) {
+            int colour = board.colour_at(i) == Colour::White ? 0 : 1;
+            pieces[i].setTexture(textures[piece - 1][colour]);
+
+            sf::Vector2 center = textures[piece - 1][colour].getSize() / 2u;
+            pieces[i].setOrigin(center.x, center.y);
+
+            pieces[i].setPosition(
+                (i % 8 + .5) * TILE_SIZE,
+                (7 - (int) (i / 8) + .5) * TILE_SIZE
+            );
+            window.draw(pieces[i]);
+        }
+    }
+}
+
+int GUI::show_popup(
+    const std::string& message, const std::vector<std::string>& options
+) {
+    sf::RenderWindow popup(sf::VideoMode(300, 200), "Choice");
+    sf::Font font;
+
+    if (!font.loadFromFile("res/arial.ttf")) {
+        std::cerr << "Error: Could not load font!" << std::endl;
+        return -1;
+    }
+
+    sf::Text text(message, font, 20);
+    text.setPosition(20, 20);
+    text.setFillColor(sf::Color::Black);
+
+    std::vector<sf::RectangleShape> buttonShapes;
+    std::vector<sf::Text> buttonTexts;
+
+    for (size_t i = 0; i < options.size(); ++i) {
+        sf::RectangleShape button(sf::Vector2f(200, 30));
+        button.setPosition(50, 70 + i * 40);
+        button.setFillColor(sf::Color(150, 150, 150));
+        buttonShapes.push_back(button);
+
+        sf::Text buttonText(options[i], font, 18);
+        buttonText.setPosition(60, 75 + i * 40);
+        buttonText.setFillColor(sf::Color::Black);
+        buttonTexts.push_back(buttonText);
+    }
+
+    while (popup.isOpen()) {
+        sf::Event event;
+        while (popup.pollEvent(event)) {
+            if (event.type == sf::Event::Closed)
+                popup.close();
+            else if (event.type == sf::Event::MouseButtonPressed) {
+                for (size_t i = 0; i < buttonShapes.size(); ++i) {
+                    if (buttonShapes[i].getGlobalBounds().contains(
+                            event.mouseButton.x,
+                            event.mouseButton.y
+                        )) {
+                        popup.close();
+                        return i;
+                    }
+                }
+            }
+        }
+
+        popup.clear(sf::Color::White);
+        popup.draw(text);
+        for (size_t i = 0; i < buttonShapes.size(); ++i) {
+            popup.draw(buttonShapes[i]);
+            popup.draw(buttonTexts[i]);
+        }
+        popup.display();
+    }
+    return -1;
+}
+
+Piece GUI::ask_about_promotion() {
+    std::vector<std::string> options = {"Queen", "Rook", "Bishop", "Knight"};
+    int idx = show_popup("Please choose a promotion for your pawn", options);
+    switch (idx) {
+    case 0:
+        return Queen;
+    case 1:
+        return Rook;
+    case 2:
+        return Bishop;
+    case 3:
+        return Knigt;
+    };
+    return Piece::None;
+}
+
+void GUI::show() {
+    while (window.isOpen())
+        handle_events();
+}

src/view/gui.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "../model/board/board.hpp"
+#include "view.hpp"
+
+#include <SFML/Graphics.hpp>
+
+
+const int TILE_SIZE = 80;
+const int BOARD_SIZE = 8;
+const int WINDOW_SIZE = TILE_SIZE * BOARD_SIZE;
+
+class GUI : public View {
+  public:
+    GUI();
+
+    void show() override;
+    Piece ask_about_promotion();
+    void update_board(const Board&, int8_t, std::vector<int8_t>) override;
+    void notify_checkmate(Colour) override;
+    void notify_stalemate(Colour) override;
+
+  private:
+    sf::RenderWindow window;
+    sf::Texture textures[6][2];
+    sf::Sprite pieces[64];
+    sf::Font font;
+    sf::Color colours[2] = {sf::Color(0xB88762FF), sf::Color(0xEDD6B0FF)};
+    sf::Color alt_colours[2] = {sf::Color(0xDCC34BFF), sf::Color(0xF6EB72FF)};
+
+
+    int show_popup(
+        const std::string& message, const std::vector<std::string>& options
+    );
+    void load_textures();
+    void handle_events();
+    void handle_click(int, int);
+    void draw_board(int, std::vector<int8_t>);
+    void draw_pieces(const Board&);
+    void draw_annotation(int, int);
+};

src/view/noop.hpp

@@ -0,0 +1,16 @@
+#include "../model/board/board.hpp"
+#include "view.hpp"
+
+class NoOpView : public View {
+  public:
+    NoOpView() {};
+
+    void show() override {};
+    void update_board(const Board&, int8_t, std::vector<int8_t>) override {};
+    void notify_checkmate(Colour) override{};
+    void notify_stalemate(Colour) override{};
+
+    Piece ask_about_promotion() override {
+        return Queen;
+    };
+};

src/view/view.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "../controller/controller.hpp"
+#include "../model/board/board.hpp"
+#include "../model/pieces/piece.hpp"
+#include "../model/utils/move.hpp"
+
+class View {
+  protected:
+    Controller* controller;
+
+  public:
+    void set_controller(Controller* c) {
+        controller = c;
+    }
+
+    virtual void show() = 0;
+    virtual Piece ask_about_promotion() = 0;
+    virtual void update_board(const Board&, int8_t, std::vector<int8_t>) = 0;
+    virtual void notify_checkmate(Colour) = 0;
+    virtual void notify_stalemate(Colour) = 0;
+};

tests/fen.cpp

@@ -1,4 +1,4 @@
-#include "../src/board.hpp"
+#include "../src/model/board/board.hpp"
 #include "lib.hpp"
 
 int main() {

tests/move.cpp

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

tests/positions.cpp

@@ -1,4 +1,4 @@
-#include "../src/coords.hpp"
+#include "../src/model/utils/coords.hpp"
 #include "lib.hpp"
 
 int main() {