Init project

.gitignore

@@ -0,0 +1 @@
+build

.gitlab-ci.yml

@@ -0,0 +1,6 @@
+archlinux:
+  image: "archlinux:latest"
+  before_script:
+    - pacman -Sy base-devel cmake --noconfirm --needed
+  script:
+    - mkdir build && cd build && cmake ../ && make && ctest

CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.10)
+project(chessarbiter)
+
+# Shared library
+add_library(chessarbiter SHARED src/Piece.cpp src/Board.cpp src/Fen.cpp src/ChessArbiter.cpp)
+include_directories(src/)
+
+# Includes
+set(CHESSARBITER_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/includes) # For conveniance
+set(CHESSARBITER_INCLUDE_DIR ${CHESSARBITER_INCLUDE_DIR} PARENT_SCOPE) # To be used by other projects with add_subdirectory()
+file(MAKE_DIRECTORY ${CHESSARBITER_INCLUDE_DIR})
+configure_file(src/Piece.hpp ${CHESSARBITER_INCLUDE_DIR}/pgnp.hpp COPYONLY)
+configure_file(src/Board.hpp ${CHESSARBITER_INCLUDE_DIR} COPYONLY)
+configure_file(src/Fen.hpp ${CHESSARBITER_INCLUDE_DIR} COPYONLY)
+configure_file(src/ChessArbiter.hpp ${CHESSARBITER_INCLUDE_DIR} COPYONLY)
+
+# Unit tests
+enable_testing()
+add_subdirectory(./tests)

Makefile

@@ -0,0 +1,6 @@
+
+
+
+main: main.cpp
+	g++ $^ -o $@
+	

README.md

@@ -0,0 +1,47 @@
+# ChessArbiter
+ChessArbiter is a library that allow you to play chess games in C++. It ensures that all the rules of classical chess are followed.
+
+# Features
+- No external dependencies
+- Simple/Minimal API
+- FEN parsing/serializing
+- Setup a position a play moves
+- Perform various tests on a position:
+  - Material
+  - Players in check
+  - Players captures
+  - Castle
+  - Attacked squares
+  - Checkmate
+  - ...
+- More features are coming soon!
+
+# How to setup ChessArbiter
+ChessArbiter can be used as a shared library in your project.
+You only need to include `ChessArbiter.hpp` and linking the .so file to your executable.
+
+# Example
+Somewhere at the beginning of the file:
+
+    #include "ChessArbiter.hpp"
+
+Start playing:
+
+    ChessArbiter arbiter;
+    arbiter.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+    // Now start playing!
+    if(!arbiter.Play("e2e4")){
+        // Handle illegal moves
+    }
+    if(arbiter.IsCheckmate()){
+        // Game ends
+    }
+
+See `ChessArbiter.hpp` for more informations on the API.
+
+# CMake Integration
+By using the `add_subdirectory()` directive on this repository, you will be able to use the following cmake calls in your project:
+
+    include_directories(${CHESSARBITER_INCLUDE_DIR})
+    target_link_libraries(<YOUR_TARGET> chessarbiter)
+

src/Board.cpp

@@ -0,0 +1,196 @@
+#include "Board.hpp"
+
+namespace chessarbiter {
+
+bool Board::IsEmpty(std::string coord) {
+  for (Piece &p : pieces) {
+    if (p.coord == coord) {
+      return (false);
+    }
+  }
+  return (true);
+}
+
+bool Board::AddPiece(char p, std::string coord) {
+  if (IsEmpty(coord)) {
+    Piece piece(p, coord);
+    pieces.push_back(piece);
+    return (true);
+  }
+  return (false);
+}
+
+bool Board::RemovePiece(std::string coord) {
+  for (char i = 0; i < pieces.size(); i++) {
+    if (pieces[i].coord == coord) {
+      pieces.erase(pieces.begin() + i);
+      return (true);
+    }
+  }
+  return false;
+}
+
+Piece Board::GetPieceAt(std::string coord) {
+  for (Piece &p : pieces) {
+    if (p.coord == coord)
+      return p;
+  }
+  throw NoPieceFound();
+}
+
+std::vector<Piece> Board::GetPlayerPieces(bool isBlack) {
+  std::vector<Piece> pp;
+  for (Piece &p : pieces) {
+    if (p.isBlack == isBlack) {
+      pp.push_back(p);
+    }
+  }
+  return (pp);
+}
+
+short Board::CountPiece(char c) {
+  char count = 0;
+  for (Piece &p : pieces) {
+    if (p.piece == c) {
+      count++;
+    }
+  }
+  return (count);
+}
+
+void Board::Clear() { pieces.clear(); }
+
+std::string Board::GetKingLocation(bool isBlack) {
+  for (Piece &p : pieces) {
+    if (p.isBlack == isBlack) {
+      if (p.piece == 'k' || p.piece == 'K') {
+        return (p.coord);
+      }
+    }
+  }
+  throw NoPieceFound();
+}
+
+void Board::Move(std::string move) {
+  std::string src(move.substr(0, 2));
+  std::string dst(move.substr(2, 2));
+  if (!IsEmpty(src)) {
+    if (!IsEmpty(dst)) {
+      RemovePiece(dst);
+    }
+    for (Piece &p : pieces) {
+      if (p.coord == src) {
+        p.coord = dst;
+      }
+    }
+  }
+}
+
+std::string Board::Serialize() {
+  std::string s;
+  for (short i = 0; i < 8; i++) {
+    for (short j = 0; j < 8; j++) {
+      try {
+        Piece p = GetPieceAt((char)('a' + j) + std::string() + (char)('8' - i));
+        s += p.piece;
+      } catch (...) {
+        s += " ";
+      }
+    }
+  }
+  return (s);
+}
+
+bool Board::IsMovePossible(std::string move) {
+  std::string src(move.substr(0, 2));
+  std::string dst(move.substr(2, 2));
+  if (src == dst) {
+    return (false);
+  }
+  Piece srcp = GetPieceAt(src);
+
+  // Check move is possible
+  std::vector<std::string> srcm = srcp.GetMoves();
+  if (find(srcm.begin(), srcm.end(), dst) == srcm.end()) {
+    return (false);
+  }
+
+  // Check colors on dst square
+  if (!IsEmpty(dst)) {
+    Piece dstp = GetPieceAt(dst);
+    if (srcp.isBlack == dstp.isBlack)
+      return (false);
+  }
+
+  // Check if no piece in between
+  if (src[0] == dst[0] || src[1] == dst[1]) { // Rook like moves
+    if (src[0] == dst[0]) {                   // Vertical
+      char side = 1;
+      if (src[1] > dst[1]) {
+        side = -1;
+      }
+      char r = src[1] + 1 * side;
+      while (r != dst[1]) {
+        if (!IsEmpty(src[0] + std::string() + r)) {
+          return (false);
+        }
+        r += 1 * side;
+      }
+    } else { // Horizontal
+      char side = 1;
+      if (src[0] > dst[0]) {
+        side = -1;
+      }
+      char f = src[0] + 1 * side;
+      while (f != dst[0]) {
+        if (!IsEmpty(f + std::string() + src[1])) {
+          return (false);
+        }
+        f += 1 * side;
+      }
+    }
+  } else if ((src[0] - dst[0] == src[1] - dst[1]) ||
+             (dst[0] - src[0] == src[1] - dst[1])) { // Bishop like moves
+    // That code if for diagonal 1 (bottom left to up right)
+    // Using the d2 variable allow to reuse the same code for the 2 diagonals
+    char d2 = 1; // d2 stand for diagonal 2 (bottom right to up left)
+    if ((dst[0] - src[0] == src[1] - dst[1])) { // If move is for diagonal 2
+      d2 = -1;
+    }
+
+    // Move direction check
+    char side = 1;
+    if (src[0] > dst[0]) {
+      side = -1;
+    }
+
+    // Setup variables
+    char f = src[0] + 1 * side;
+    char r = src[1] + d2 * side;
+
+    // Perform empty square checks
+    while (f != dst[0], r != dst[1]) {
+      if (!IsEmpty(f + std::string() + r)) {
+        return (false);
+      }
+      f += 1 * side;
+      r += d2 * side;
+    }
+  }
+  return (true);
+}
+
+std::vector<std::string> Board::ListPossibleMoves(bool isBlack) {
+  std::vector<std::string> moves;
+  for (Piece &p : pieces) {
+    if (p.isBlack == isBlack) {
+      for (std::string &m : p.GetMoves()) {
+        if (IsMovePossible(p.coord + m)) {
+          moves.push_back(p.coord + m);
+        }
+      }
+    }
+  }
+  return (moves);
+}
+} // namespace chessarbiter

src/Board.hpp

@@ -0,0 +1,44 @@
+#include "Piece.hpp"
+#include <algorithm>
+#include <exception>
+#include <iostream>
+#include <string>
+
+namespace chessarbiter {
+
+class Board {
+  std::vector<Piece> pieces;
+
+public:
+  /// @brief Check if a square is empty
+  bool IsEmpty(std::string);
+  /// @brief Add a piece (no checks are performed on coord)
+  bool AddPiece(char p, std::string);
+  /// @brief Remove a piece from a square
+  bool RemovePiece(std::string);
+  /// @brief Get piece at a specific coordinate
+  Piece GetPieceAt(std::string);
+  /// @brief Get the pieces of a player
+  std::vector<Piece> GetPlayerPieces(bool);
+  /// @brief Count the number of a specific piece on the board
+  short CountPiece(char);
+  /// @brief Get the location of the first king found on the board
+  std::string GetKingLocation(bool);
+  /// @brief Check if a move is technically possible (does not means it is
+  /// legal)
+  bool IsMovePossible(std::string);
+  /// @brief Clear the board
+  void Clear();
+  /// @brief Move a piece somewhere no matter what
+  void Move(std::string);
+  /// @brief Get a serialize version of the board
+  std::string Serialize();
+  /// @brief List all the technically possible moves of a player
+  std::vector<std::string> ListPossibleMoves(bool);
+};
+
+struct NoPieceFound : public std::exception {
+  const char *what() const throw() { return "No piece found"; }
+};
+
+} // namespace chessarbiter

src/ChessArbiter.cpp

@@ -0,0 +1,309 @@
+#include "ChessArbiter.hpp"
+
+namespace chessarbiter {
+ChessArbiter::ChessArbiter()
+    : wPawn(1), wRook(5), wKnight(3), wBishop(3), wQueen(9), wKing(0) {}
+
+void ChessArbiter::Setup(std::string fen) {
+  SetFEN(fen);
+  fen_last = this->fen;
+}
+
+void ChessArbiter::SetFEN(FEN fen) { SetFEN(FENParser::Serialize(fen)); }
+
+void ChessArbiter::SetFEN(std::string newfen) {
+  fen = FENParser::Parse(newfen);
+
+  board.Clear();
+  for (int i = 0; i < 64; i++) {
+    if (fen.board[i] != ' ') {
+      char f = 'a' + ((i) % 8);
+      char r = '8' - ((i) / 8);
+      board.AddPiece(fen.board[i], f + std::string() + r);
+    }
+  }
+}
+
+std::string ChessArbiter::GetFEN() { return (FENParser::Serialize(fen)); }
+
+std::string ChessArbiter::GetBoard() { return (fen.board); }
+
+bool ChessArbiter::IsBlackTurn() { return (fen.player == 'b'); }
+
+bool ChessArbiter::IsCheck(bool isBlack) {
+  std::string kingloc = board.GetKingLocation(isBlack);
+  return (IsAttacked(kingloc, !isBlack));
+}
+
+bool ChessArbiter::Play(std::string move) {
+  std::vector<std::string> moves = ListLegalMoves(fen.player);
+  if (find(moves.begin(), moves.end(), move) != moves.end()) {
+    Piece moved = board.GetPieceAt(move.substr(0, 2)); // This call never fail
+    std::string src = move.substr(0, 2);
+    std::string dst = move.substr(2, 2);
+    bool IsCapture = !board.IsEmpty(dst);
+    FEN newFen = fen;
+
+    // Perform the move
+    if (move == "O-O" || move == "O-O-O") {
+      if (fen.player && move == "O-O") {
+        board.Move("e8g8");
+        board.Move("h8e8");
+      } else if (fen.player && move == "O-O") {
+        board.Move("e8c8");
+        board.Move("a8d8");
+      } else if (!fen.player && move == "O-O") {
+        board.Move("e1g1");
+        board.Move("h1e1");
+      } else {
+        board.Move("e1c1");
+        board.Move("a1d1");
+      }
+    } else {
+      board.Move(move);
+    }
+
+    // Update halfmove
+    newFen.halfmove++;
+    // Check enpassant
+    newFen.en_passant = "-";
+    if (moved.piece == 'p' || moved.piece == 'P') {
+      if (fen.player && (dst[1] - src[1] == 2)) {
+        newFen.en_passant = src[0] + std::string() + (char)(src[1] - 1);
+      } else if (!fen.player && (dst[1] - src[1] == 2)) {
+        newFen.en_passant = src[0] + std::string() + (char)(src[1] + 1);
+      }
+      newFen.halfmove = 0; // Pawn moves reset half moves
+    }
+    // Captures reset half moves
+    if (IsCapture) {
+      newFen.halfmove = 0;
+    }
+    if (newFen.player) {
+      newFen.move++;
+    }
+    newFen.board = board.Serialize();
+    newFen.player = !newFen.player;
+    // Castle update if one is true
+    if (newFen.white_castle_long || newFen.white_castle_short ||
+        newFen.black_castle_long || newFen.black_castle_short) {
+      if (moved.piece == 'R' && src == "a1") {
+        newFen.white_castle_long = false;
+      } else if (moved.piece == 'R' && src == "h1") {
+        newFen.white_castle_short = false;
+      } else if (moved.piece == 'r' && src == "a8") {
+        newFen.black_castle_long = false;
+      } else if (moved.piece == 'r' && src == "h8") {
+        newFen.black_castle_short = false;
+      } else if (moved.piece == 'K' || (!fen.player && src == "O-")) {
+        newFen.white_castle_long = false;
+        newFen.white_castle_short = false;
+      } else if (moved.piece == 'k' || (fen.player && src == "O-")) {
+        newFen.black_castle_long = false;
+        newFen.black_castle_short = false;
+      }
+    }
+
+    // Update fen!
+    fen_last = fen;
+    fen = newFen;
+
+    // Check for illegal move
+    if (IsCheck(!fen.player)) {
+      SetFEN(fen_last);
+      return (false);
+    }
+
+    return (true);
+  }
+  return (false);
+}
+
+bool ChessArbiter::IsAttacked(std::string square, bool by) {
+  std::vector<std::string> moves = board.ListPossibleMoves(by);
+  for (std::string &m : moves) {
+    std::string src = m.substr(0, 2);
+    std::string dst = m.substr(2, 2);
+
+    if (dst == square) {
+      // Pawn do not attack forward
+      Piece p = board.GetPieceAt(src);
+      if (p.piece == 'p' || p.piece == 'P') {
+        if (src[0] != dst[0]) {
+          return (true);
+        }
+      } else {
+        return (true);
+      }
+    }
+  }
+  return (false);
+}
+
+bool ChessArbiter::IsCastlePossible(bool isBlack, bool isLong) {
+
+  if (isBlack && isLong && fen.black_castle_long) {
+    if (board.IsEmpty("d8") && board.IsEmpty("c8") && board.IsEmpty("b8")) {
+      if (!IsAttacked("d8", false) && !IsAttacked("c8", false)) {
+        return (true);
+      }
+    }
+  } else if (isBlack && !isLong && fen.black_castle_short) {
+    if (board.IsEmpty("f8") && board.IsEmpty("g8")) {
+      if (!IsAttacked("f8", false) && !IsAttacked("g8", false)) {
+        return (true);
+      }
+    }
+  } else if (!isBlack && isLong && fen.white_castle_long) {
+    if (board.IsEmpty("d1") && board.IsEmpty("c1") && board.IsEmpty("b1")) {
+      if (!IsAttacked("d1", true) && !IsAttacked("c1", true)) {
+        return (true);
+      }
+    }
+  } else if (!isBlack && !isLong && fen.white_castle_short) {
+    if (board.IsEmpty("f1") && board.IsEmpty("g1")) {
+      if (!IsAttacked("f1", true) && !IsAttacked("g1", true)) {
+        return (true);
+      }
+    }
+  }
+
+  return (false);
+}
+
+int ChessArbiter::GetMaterialScore() {
+  int whiteScore = 0;
+  int blackScore = 0;
+  for (char i = 0; i < 2; i++) {
+    int *score = &whiteScore;
+    if (i > 0) {
+      score = &blackScore;
+    }
+    for (Piece &p : board.GetPlayerPieces((bool)i)) {
+      switch (tolower(p.piece)) {
+      case 'p':
+        (*score) += wPawn;
+        break;
+      case 'r':
+        (*score) += wRook;
+        break;
+      case 'n':
+        (*score) += wKnight;
+        break;
+      case 'b':
+        (*score) += wBishop;
+        break;
+      case 'q':
+        (*score) += wQueen;
+        break;
+      default:
+        (*score) += wKing;
+      }
+    }
+  }
+  return (whiteScore - blackScore);
+}
+
+std::string ChessArbiter::GetCaptures(bool isBlack) {
+  std::string captures;
+  // Pawn
+  char p = 'P';
+  if (!isBlack)
+    p = 'p';
+  for (char i = 8 - board.CountPiece(p); i > 0; i--) {
+    captures += p;
+  }
+  // Rook
+  p = 'R';
+  if (!isBlack)
+    p = 'r';
+  for (char i = 2 - board.CountPiece(p); i > 0; i--) {
+    captures += p;
+  }
+  // Knight
+  p = 'N';
+  if (!isBlack)
+    p = 'n';
+  for (char i = 2 - board.CountPiece(p); i > 0; i--) {
+    captures += p;
+  }
+  // Bishop
+  p = 'B';
+  if (!isBlack)
+    p = 'b';
+  for (char i = 2 - board.CountPiece(p); i > 0; i--) {
+    captures += p;
+  }
+  // Queen
+  p = 'Q';
+  if (!isBlack)
+    p = 'q';
+  for (char i = 1 - board.CountPiece(p); i > 0; i--) {
+    captures += p;
+  }
+  // King :D
+  p = 'K';
+  if (!isBlack)
+    p = 'k';
+  for (char i = 1 - board.CountPiece(p); i > 0; i--) {
+    captures += p;
+  }
+  return (captures);
+}
+
+std::vector<std::string> ChessArbiter::ListLegalMoves(bool isBlack) {
+  std::vector<std::string> moves;
+  for (std::string &move : board.ListPossibleMoves(isBlack)) {
+    std::string src = move.substr(0, 2);
+    std::string dst = move.substr(2, 2);
+    Piece srcp = board.GetPieceAt(src); // This call never fail
+    bool IsDstEmpty = board.IsEmpty(dst);
+
+    // Pawns side  moves
+    if ((srcp.piece == 'p' || srcp.piece == 'P') && (src[0] != dst[0])) {
+      if (!IsDstEmpty) {
+        Piece attacked = board.GetPieceAt(dst);
+        if (srcp.isBlack != attacked.isBlack)
+          moves.push_back(move);
+      } else if (dst == fen.en_passant) {
+        moves.push_back(move);
+      }
+    } else {
+      moves.push_back(move);
+    }
+  }
+
+  // Casling
+  if (IsCastlePossible(isBlack, false))
+    moves.push_back("O-O");
+  if (IsCastlePossible(isBlack, true))
+    moves.push_back("O-O-O");
+
+  return (moves);
+}
+
+bool ChessArbiter::IsPlayable() {
+  char nK = board.CountPiece('K');
+  if (nK == 1 && nK == board.CountPiece('k')) {
+    if (!IsCheck(!fen.player)) {
+      return (true);
+    }
+  }
+  return (false);
+}
+
+bool ChessArbiter::IsCheckMate() {
+  if (IsCheck(fen.player)) {
+    std::vector<std::string> moves = ListLegalMoves(fen.player);
+    for(std::string &move: moves){
+      if(Play(move)){
+        SetFEN(fen_last);
+        return(false);
+      }
+    }
+    return(true);
+  }
+  return (false);
+}
+
+} // namespace chessarbiter

src/ChessArbiter.hpp

@@ -0,0 +1,40 @@
+#include "Board.hpp"
+#include "Fen.hpp"
+#include <iostream>
+
+namespace chessarbiter {
+class ChessArbiter {
+  Board board;
+  FEN fen;
+  FEN fen_last; // To undo a move
+  int wPawn, wRook, wKnight, wBishop, wQueen, wKing;
+
+public:
+  ChessArbiter();
+  void Setup(std::string);
+  void SetFEN(std::string);
+  void SetFEN(FEN);
+  std::string GetFEN();
+  /// @brief Check which player is going to play
+  bool IsBlackTurn();
+  /// @brief Check if a side is in check
+  bool IsCheck(bool);
+  /// @brief Play a move (return false if it's illegal)
+  bool Play(std::string);
+  /// @brief Check if a square is attacked by a particular player
+  bool IsAttacked(std::string, bool);
+  /// @brief Get the serialized board
+  std::string GetBoard();
+  /// @brief Get current position evaluation according to player's material
+  int GetMaterialScore();
+  /// @brief Check if position is legal
+  bool IsPlayable();
+  /// @brief Get pieces captures by a player
+  std::string GetCaptures(bool);
+  /// @brief List all the legal moves of a player
+  std::vector<std::string> ListLegalMoves(bool);
+  /// @brief Check if a specific castle is possible by a player
+  bool IsCastlePossible(bool, bool);
+  bool IsCheckMate();
+};
+} // namespace chessarbiter

src/Fen.cpp

@@ -0,0 +1,170 @@
+#include "Fen.hpp"
+
+namespace chessarbiter {
+
+std::string FENParser::normalize_rank(std::string fen_rank) {
+  std::string normalized;
+  for (char &c : fen_rank) {
+    if (IS_DIGIT(c)) {
+      for (char i = 0; i < (c - '0'); i++) {
+        normalized += ' ';
+      }
+    } else {
+      normalized += c;
+    }
+  }
+  return (normalized);
+}
+
+char FENParser::NextToken(std::string fen, char loc) {
+  while (loc < fen.size() && IS_BLANK(fen[loc])) {
+    loc++;
+  }
+  return (loc);
+}
+
+char FENParser::NextRank(std::string fen, char loc) {
+  loc++;
+  while (loc < fen.size() && fen[loc] != '/' && fen[loc] != ' ') {
+    loc++;
+  }
+  return (loc);
+}
+
+std::string FENParser::Serialize(FEN fen) {
+  std::string s;
+  char skip = 0;
+  char rank = 0;
+  for (char &c : fen.board) {
+    rank++;
+    if (c == ' ') {
+      skip++;
+    } else {
+      if (skip > 0) {
+        s += std::to_string(skip);
+        skip = 0;
+      }
+      s += c;
+    }
+    if (rank == 8) {
+      if (skip != 0) {
+        s += std::to_string(skip);
+        skip = 0;
+      }
+      s += '/';
+      rank = 0;
+    }
+  }
+
+  // Remove last /
+  s = s.substr(0, s.size() - 1);
+  s += " ";
+
+  // Player
+  if (fen.player) {
+    s += "b ";
+  } else {
+    s += "w ";
+  }
+
+  // Castle
+  if (!(fen.white_castle_short || fen.white_castle_long ||
+        fen.black_castle_short || fen.black_castle_long)) {
+    s += "-";
+  } else {
+    if (fen.white_castle_short) {
+      s += "K";
+    }
+    if (fen.white_castle_long) {
+      s += "Q";
+    }
+    if (fen.black_castle_short) {
+      s += "k";
+    }
+    if (fen.black_castle_long) {
+      s += "q";
+    }
+  }
+
+  // Remaining
+  s += " " + fen.en_passant + " " + std::to_string(fen.halfmove) + " " +
+       std::to_string(fen.move);
+
+  return (s);
+}
+
+FEN FENParser::Parse(std::string fen) {
+  FEN parsed;
+
+  // Parse board
+  char loc = 0;
+  for (char rank = 0; rank < 8; rank++) {
+    char newloc = NextRank(fen, loc);
+    parsed.board += normalize_rank(fen.substr(loc, newloc - loc));
+    loc = newloc + 1;
+  }
+
+  // Parse player to move
+  loc = NextToken(fen, loc);
+  parsed.player = fen[loc] == 'b';
+
+  // Parse castling
+  loc = NextToken(fen, loc + 1);
+  char length = 0;
+  char cur_loc = loc;
+  while (!IS_BLANK(fen[cur_loc])) {
+    length++;
+    cur_loc++;
+  }
+  parsed.white_castle_short = false;
+  parsed.white_castle_long = false;
+  parsed.black_castle_short = false;
+  parsed.black_castle_long = false;
+  std::string castle = fen.substr(loc, length);
+  for (char i = 0; i < length; i++) {
+    switch (fen[loc + i]) {
+    case 'K':
+      parsed.white_castle_short = true;
+      break;
+    case 'Q':
+      parsed.white_castle_long = true;
+      break;
+    case 'k':
+      parsed.black_castle_short = true;
+      break;
+    case 'q':
+      parsed.black_castle_long = true;
+      break;
+    }
+  }
+
+  // Parse en passant
+  loc = NextToken(fen, loc + length);
+  if (fen[loc] != '-') {
+    parsed.en_passant = fen.substr(loc, 2);
+    loc++;
+  }
+  loc++;
+
+  // Parse half move counter
+  loc = NextToken(fen, loc);
+  std::string halfmove;
+  while (!IS_BLANK(fen[loc])) {
+    halfmove += fen[loc];
+    loc++;
+  }
+  parsed.halfmove = stoi(halfmove);
+
+  // Parse move counter
+  loc = NextToken(fen, loc);
+  std::string move;
+  while (loc < fen.size() && !IS_BLANK(fen[loc])) {
+    move += fen[loc];
+    loc++;
+  }
+  parsed.move = stoi(move);
+
+  return (parsed);
+}
+
+} // namespace chessarbiter

src/Fen.hpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#define IS_DIGIT(c)                                                            \
+  (c == '0' || c == '1' || c == '2' || c == '3' || c == '4' || c == '5' ||     \
+   c == '6' || c == '7' || c == '8' || c == '9')
+#define IS_BLANK(c) (c == ' ' || c == '\n' || c == '\t' || c == '\r')
+
+namespace chessarbiter {
+
+class FEN {
+public:
+  std::string board;
+  bool player;
+  bool white_castle_short;
+  bool white_castle_long;
+  bool black_castle_short;
+  bool black_castle_long;
+  std::string en_passant;
+  short halfmove;
+  short move;
+  FEN()
+      : board(""), player(false), white_castle_short(true),
+        white_castle_long(true), black_castle_short(true),
+        black_castle_long(true), en_passant("-"), halfmove(0), move(1) {}
+};
+
+class FENParser {
+private:
+  static std::string normalize_rank(std::string fen_rank);
+  static char NextToken(std::string fen, char loc);
+  static char NextRank(std::string fen, char loc);
+
+public:
+  /// @brief Parse a FEN from a string
+  static FEN Parse(std::string);
+  /// @brief Generate a fen string from the FEN object
+  static std::string Serialize(FEN fen);
+};
+} // namespace chessarbiter

src/Piece.cpp

@@ -0,0 +1,103 @@
+#include "Piece.hpp"
+
+namespace chessarbiter {
+Piece::Piece(char c, std::string coord)
+    : piece(c), isBlack(!isupper(c)), coord(coord) {}
+
+std::vector<std::string> Piece::GetMoves() {
+  std::vector<std::string> moves;
+  char f = coord[0]; // File
+  char r = coord[1]; // Rank
+  if (piece == 'p' || piece == 'P') {
+    char side = 1;
+    if (piece == 'p') {
+      side = -1;
+    }
+    // First two steps
+    if ((r == '2' && piece == 'P') || (r == '7' && piece == 'p')) {
+      moves.push_back(std::string() + f + (char)(r + 2 * side));
+    }
+    if ((piece == 'P' && r < '8') || (piece == 'p' && r > '1')) {
+      moves.push_back(std::string() + f + (char)(r + 1 * side));
+    }
+    PIECE__ADD_MOVE(f - 1, r + 1 * side);
+    PIECE__ADD_MOVE(f + 1, r + 1 * side);
+  } else if (piece == 'k' || piece == 'K') {
+    PIECE__ADD_MOVE(f, r - 1);
+    PIECE__ADD_MOVE(f, r + 1);
+    PIECE__ADD_MOVE(f + 1, r);
+    PIECE__ADD_MOVE(f - 1, r);
+    PIECE__ADD_MOVE(f + 1, r + 1);
+    PIECE__ADD_MOVE(f - 1, r - 1);
+    PIECE__ADD_MOVE(f + 1, r - 1);
+    PIECE__ADD_MOVE(f - 1, r + 1);
+  } else if (piece == 'n' || piece == 'N') {
+    PIECE__ADD_MOVE(f + 1, r + 2);
+    PIECE__ADD_MOVE(f - 1, r + 2);
+    PIECE__ADD_MOVE(f + 1, r - 2);
+    PIECE__ADD_MOVE(f - 1, r - 2);
+    PIECE__ADD_MOVE(f + 2, r + 1);
+    PIECE__ADD_MOVE(f - 2, r + 1);
+    PIECE__ADD_MOVE(f + 2, r - 1);
+    PIECE__ADD_MOVE(f - 2, r - 1);
+  } else {
+    if (piece == 'b' || piece == 'B' || piece == 'Q' || piece == 'q') {
+      char rtmp = r;
+      char ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        ftmp++;
+        rtmp++;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+      rtmp = r;
+      ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        ftmp--;
+        rtmp--;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+      rtmp = r;
+      ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        ftmp--;
+        rtmp++;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+      rtmp = r;
+      ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        ftmp++;
+        rtmp--;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+    }
+    if (piece == 'r' || piece == 'R' || piece == 'Q' || piece == 'q') {
+      char rtmp = r;
+      char ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        rtmp++;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+      rtmp = r;
+      ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        rtmp--;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+      rtmp = r;
+      ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        ftmp++;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+      rtmp = r;
+      ftmp = f;
+      while (PIECE__IS_VALID(ftmp, rtmp)) {
+        ftmp--;
+        PIECE__ADD_MOVE(ftmp, rtmp);
+      }
+    }
+  }
+  return (moves);
+}
+} // namespace chessarbiter

src/Piece.hpp

@@ -0,0 +1,27 @@
+#include <string>
+#include <vector>
+
+#define PIECE__IS_VALID(f, r) ((f) >= 'a' && (f) <= 'h' && (r) >= '1' && (r) <= '8')
+#define PIECE__ADD_MOVE(f, r)                                                         \
+  {                                                                            \
+    if (PIECE__IS_VALID(f, r)) {                                                      \
+      moves.push_back(std::string() + (char)((f)) + (char)((r)));              \
+    }                                                                          \
+  }
+
+namespace chessarbiter {
+
+/**
+ * Member are public for conveniance
+ */
+class Piece {
+public:
+  bool isBlack;
+  std::string coord;
+  char piece;
+  Piece(char c, std::string coord);
+  /// @brief Get all possible moves according to the type of piece and its position
+  std::vector<std::string> GetMoves();
+};
+
+} // namespace chessarbiter

tests/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Configure catch3
+include_directories(./catch3/)
+add_library(catch3 SHARED ./catch3/catch_amalgamated.cpp)
+
+# Add tests
+add_executable(fen_tests fen.cpp)
+target_link_libraries(fen_tests chessarbiter catch3)
+add_test(Fen_Test fen_tests)
+
+add_executable(board_tests board.cpp)
+target_link_libraries(board_tests chessarbiter catch3)
+add_test(Board_Test board_tests)
+
+add_executable(chessarbiter_tests chessarbiter.cpp)
+target_link_libraries(chessarbiter_tests chessarbiter catch3)
+add_test(ChessArbiter_Test chessarbiter_tests)
+

tests/board.cpp

@@ -0,0 +1,418 @@
+#include "Board.hpp"
+#include <catch_amalgamated.hpp>
+
+using namespace chessarbiter;
+
+TEST_CASE("IsEmpty/AddPiece", "[board/IsEmpty/AddPiece]") {
+  Board b;
+  b.AddPiece('K', "a1");
+  b.AddPiece('K', "a8");
+  b.AddPiece('K', "c8");
+
+  CHECK_FALSE(b.IsEmpty("a1"));
+  CHECK_FALSE(b.IsEmpty("a8"));
+  CHECK_FALSE(b.IsEmpty("c8"));
+
+  CHECK(b.IsEmpty("a2"));
+  CHECK(b.IsEmpty("a3"));
+  CHECK(b.IsEmpty("a4"));
+}
+
+TEST_CASE("Clear", "[board/Clear]") {
+  Board b;
+  b.AddPiece('K', "a1");
+  b.AddPiece('A', "a8");
+  b.AddPiece('Q', "c8");
+
+  b.Clear();
+
+  CHECK(b.IsEmpty("a1"));
+  CHECK(b.IsEmpty("a8"));
+  CHECK(b.IsEmpty("c8"));
+}
+
+TEST_CASE("GetPieceAt", "[board/GetPieceAt]") {
+  Board b;
+  b.AddPiece('K', "a1");
+  b.AddPiece('A', "a8");
+  b.AddPiece('Q', "c8");
+
+  CHECK((b.GetPieceAt("a1")).piece == 'K');
+  CHECK((b.GetPieceAt("a8")).piece == 'A');
+  CHECK((b.GetPieceAt("c8")).piece == 'Q');
+
+  CHECK_THROWS_AS(b.GetPieceAt("a5"), chessarbiter::NoPieceFound);
+}
+
+TEST_CASE("CountPiece", "[board/CountPiece]") {
+  Board b;
+  b.AddPiece('K', "a1");
+  b.AddPiece('K', "a3");
+
+  CHECK(b.CountPiece('K') == 2);
+
+  b.AddPiece('k', "b1");
+  b.AddPiece('k', "b5");
+
+  CHECK(b.CountPiece('k') == 2);
+
+  b.AddPiece('b', "h8");
+  b.AddPiece('b', "h7");
+
+  CHECK(b.CountPiece('b') == 2);
+  CHECK(b.CountPiece('p') == 0);
+}
+
+TEST_CASE("GetKingLocation", "[board/GetKingLocation]") {
+  Board b;
+
+  b.AddPiece('k', "a1");
+  CHECK(b.GetKingLocation(true) == "a1");
+
+  b.AddPiece('K', "h1");
+  CHECK(b.GetKingLocation(false) == "h1");
+
+  b.Clear();
+  CHECK_THROWS_AS(b.GetKingLocation(true), NoPieceFound);
+}
+
+TEST_CASE("RemovePiece", "[board/RemovePiece]") {
+  Board b;
+
+  b.AddPiece('k', "a1");
+  b.AddPiece('p', "a2");
+
+  REQUIRE(!b.IsEmpty("a1"));
+  REQUIRE(!b.IsEmpty("a2"));
+
+  b.RemovePiece("a1");
+
+  REQUIRE(b.IsEmpty("a1"));
+  REQUIRE(!b.IsEmpty("a2"));
+}
+
+TEST_CASE("Move", "[board/Move]") {
+  Board b;
+
+  b.AddPiece('k', "a1");
+  b.AddPiece('p', "a2");
+
+  REQUIRE(!b.IsEmpty("a1"));
+  REQUIRE(!b.IsEmpty("a2"));
+
+  // Nothing should happend since no piece on a3 (not even a throw)
+  CHECK_NOTHROW(b.Move("a3c4"));
+  REQUIRE(!b.IsEmpty("a1"));
+  REQUIRE(!b.IsEmpty("a2"));
+
+  b.Move("a1a2");
+  REQUIRE(b.IsEmpty("a1"));
+  REQUIRE(!b.IsEmpty("a2"));
+
+  b.Move("a2h8");
+  REQUIRE(b.IsEmpty("a2"));
+  REQUIRE(!b.IsEmpty("h8"));
+}
+
+TEST_CASE("GetPlayerPieces", "[board/GetPlayerPieces]") {
+  Board b;
+  b.AddPiece('P', "a2");
+  b.AddPiece('B', "b2");
+  b.AddPiece('k', "c2");
+
+  std::vector<Piece> pieces = b.GetPlayerPieces(false);
+  REQUIRE(pieces.size() == 2);
+  REQUIRE(b.GetPlayerPieces(true).size() == 1);
+
+  bool found = false;
+  for (Piece &p : pieces) {
+    if (p.coord == "a2" && p.piece == 'P') {
+      found = true;
+    }
+  }
+  CHECK(found);
+  found = false;
+
+  for (Piece &p : pieces) {
+    if (p.coord == "b2" && p.piece == 'B') {
+      found = true;
+    }
+  }
+  CHECK(found);
+  found = false;
+}
+
+TEST_CASE("IsMovePossible", "[board/IsMovePossible]") {
+  Board b;
+  b.AddPiece('P', "a2");
+
+  // Pawn white
+  CHECK(b.IsMovePossible("a2a3"));
+  CHECK_FALSE(b.IsMovePossible("a2a1")); // Can't go backward
+  CHECK(b.IsMovePossible(
+      "a2b3")); // Not that Board is not in charge of pawn singularities
+  CHECK(b.IsMovePossible("a2a4"));
+  b.AddPiece('p', "a3");
+  CHECK_FALSE(b.IsMovePossible("a2a4")); // Now we can't
+  b.AddPiece('P', "b3");
+  CHECK_FALSE(b.IsMovePossible("a2b3")); // Now we can't
+  b.Clear();
+  b.AddPiece('P', "a2");
+  b.AddPiece('p', "b3");           // Opposite color!
+  CHECK(b.IsMovePossible("a2b3")); // Now we can
+
+  // Pawn black
+  b.Clear();
+  b.AddPiece('p', "a7");
+  CHECK(b.IsMovePossible("a7a6"));
+  CHECK_FALSE(b.IsMovePossible("a7a8")); // Can't go backward
+  CHECK(b.IsMovePossible(
+      "a7b6")); // Not that Board is not in charge of pawn singularities
+  CHECK(b.IsMovePossible("a7a5"));
+  b.AddPiece('p', "a6");
+  CHECK_FALSE(b.IsMovePossible("a7a5")); // Now we can't
+  b.AddPiece('p', "b6");
+  CHECK_FALSE(b.IsMovePossible("a7b6")); // Now we can't
+  b.Clear();
+  b.AddPiece('p', "a7");
+  b.AddPiece('P', "b6");           // Opposite color!
+  CHECK(b.IsMovePossible("a7b6")); // Now we can
+
+  // Bishop
+  b.Clear();
+  b.AddPiece('b', "d5");
+  CHECK(b.IsMovePossible("d5h1"));
+  CHECK(b.IsMovePossible("d5a8"));
+  CHECK(b.IsMovePossible("d5a2"));
+  CHECK(b.IsMovePossible("d5g8"));
+  b.AddPiece('q', "b7"); // We block the piece in every directions
+  b.AddPiece('q', "g2");
+  b.AddPiece('q', "b3");
+  b.AddPiece('q', "f7");
+  CHECK_FALSE(b.IsMovePossible("d5h1"));
+  CHECK_FALSE(b.IsMovePossible("d5a8"));
+  CHECK_FALSE(b.IsMovePossible("d5a2"));
+  CHECK_FALSE(b.IsMovePossible("d5g8"));
+  // No rook moves
+  CHECK_FALSE(b.IsMovePossible("d5a5"));
+  CHECK_FALSE(b.IsMovePossible("d5h5"));
+  CHECK_FALSE(b.IsMovePossible("d5d8"));
+  CHECK_FALSE(b.IsMovePossible("d5d1"));
+
+  // Rook
+  b.Clear();
+  b.AddPiece('r', "d5");
+  CHECK(b.IsMovePossible("d5a5"));
+  CHECK(b.IsMovePossible("d5h5"));
+  CHECK(b.IsMovePossible("d5d8"));
+  CHECK(b.IsMovePossible("d5d1"));
+  b.AddPiece('q', "b5"); // We block the piece in every directions
+  b.AddPiece('q', "g5");
+  b.AddPiece('q', "d7");
+  b.AddPiece('q', "d2");
+  CHECK_FALSE(b.IsMovePossible("d5a5"));
+  CHECK_FALSE(b.IsMovePossible("d5h5"));
+  CHECK_FALSE(b.IsMovePossible("d5d8"));
+  CHECK_FALSE(b.IsMovePossible("d5d1"));
+  // No bishop moves
+  CHECK_FALSE(b.IsMovePossible("d5h1"));
+  CHECK_FALSE(b.IsMovePossible("d5a8"));
+  CHECK_FALSE(b.IsMovePossible("d5a2"));
+  CHECK_FALSE(b.IsMovePossible("d5g8"));
+
+  // Queen like bishop
+  b.Clear();
+  b.AddPiece('q', "d5");
+  CHECK(b.IsMovePossible("d5h1"));
+  CHECK(b.IsMovePossible("d5a8"));
+  CHECK(b.IsMovePossible("d5a2"));
+  CHECK(b.IsMovePossible("d5g8"));
+  b.AddPiece('q', "b7"); // We block the piece in every directions
+  b.AddPiece('q', "g2");
+  b.AddPiece('q', "b3");
+  b.AddPiece('q', "f7");
+  CHECK_FALSE(b.IsMovePossible("d5h1"));
+  CHECK_FALSE(b.IsMovePossible("d5a8"));
+  CHECK_FALSE(b.IsMovePossible("d5a2"));
+  CHECK_FALSE(b.IsMovePossible("d5g8"));
+
+  // Queen like rook
+  b.Clear();
+  b.AddPiece('q', "d5");
+  CHECK(b.IsMovePossible("d5a5"));
+  CHECK(b.IsMovePossible("d5h5"));
+  CHECK(b.IsMovePossible("d5d8"));
+  CHECK(b.IsMovePossible("d5d1"));
+  b.AddPiece('q', "b5"); // We block the piece in every directions
+  b.AddPiece('q', "g5");
+  b.AddPiece('q', "d7");
+  b.AddPiece('q', "d2");
+  CHECK_FALSE(b.IsMovePossible("d5a5"));
+  CHECK_FALSE(b.IsMovePossible("d5h5"));
+  CHECK_FALSE(b.IsMovePossible("d5d8"));
+  CHECK_FALSE(b.IsMovePossible("d5d1"));
+
+  // Knight
+  b.Clear();
+  b.AddPiece('n', "d5");
+  CHECK(b.IsMovePossible("d5e7"));
+  CHECK(b.IsMovePossible("d5c7"));
+  CHECK(b.IsMovePossible("d5b6"));
+  CHECK(b.IsMovePossible("d5b4"));
+  CHECK(b.IsMovePossible("d5c3"));
+  CHECK(b.IsMovePossible("d5e3"));
+  CHECK(b.IsMovePossible("d5f4"));
+  CHECK(b.IsMovePossible("d5f6"));
+  // Not possible
+  CHECK_FALSE(b.IsMovePossible("d5d7"));
+  CHECK_FALSE(b.IsMovePossible("d5d3"));
+  CHECK_FALSE(b.IsMovePossible("d5b5"));
+  CHECK_FALSE(b.IsMovePossible("d5f5"));
+
+  // King
+  b.Clear();
+  b.AddPiece('k', "d5");
+  CHECK(b.IsMovePossible("d5d6"));
+  CHECK(b.IsMovePossible("d5c6"));
+  CHECK(b.IsMovePossible("d5e6"));
+  CHECK(b.IsMovePossible("d5c5"));
+  CHECK(b.IsMovePossible("d5e5"));
+  CHECK(b.IsMovePossible("d5d4"));
+  CHECK(b.IsMovePossible("d5c4"));
+  CHECK(b.IsMovePossible("d5e4"));
+
+  // Moving a piece at the same place is not possible
+  CHECK_FALSE(b.IsMovePossible("d5d5"));
+}
+
+TEST_CASE("ListPossibleMoves", "[board/ListPossibleMoves]") {
+  Board b;
+  b.AddPiece('K', "a1");
+  b.AddPiece('K', "a8");
+  b.AddPiece('K', "h1");
+  b.AddPiece('K', "h8");
+  b.AddPiece('k', "d5"); // Black piece
+
+  std::vector<std::string> moves = b.ListPossibleMoves(false);
+  REQUIRE(moves.size() == 12);
+  CHECK(std::find(moves.begin(), moves.end(), "a1a2") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a1b2") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a1b1") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a8a7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a8b8") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a8b7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h8g7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h8g8") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h8h7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h1h2") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h1g1") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h1g2") != moves.end());
+
+  b.Clear();
+  b.AddPiece('k', "a1");
+  b.AddPiece('k', "a8");
+  b.AddPiece('k', "h1");
+  b.AddPiece('k', "h8");
+  b.AddPiece('K', "d5"); // White piece
+
+  moves = b.ListPossibleMoves(true);
+  REQUIRE(moves.size() == 12);
+  CHECK(std::find(moves.begin(), moves.end(), "a1a2") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a1b2") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a1b1") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a8a7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a8b8") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "a8b7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h8g7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h8g8") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h8h7") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h1h2") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h1g1") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "h1g2") != moves.end());
+}
+
+TEST_CASE("Serialize", "[board/Serialize]") {
+  Board b;
+  b.AddPiece('p', "a8");
+  CHECK(b.Serialize() == "p       "
+                         "        "
+                         "        "
+                         "        "
+                         "        "
+                         "        "
+                         "        "
+                         "        ");
+  b.AddPiece('P', "a1");
+  CHECK(b.Serialize() == "p       "
+                         "        "
+                         "        "
+                         "        "
+                         "        "
+                         "        "
+                         "        "
+                         "P       ");
+  b.AddPiece('k', "d5");
+  CHECK(b.Serialize() == "p       "
+                         "        "
+                         "        "
+                         "   k    "
+                         "        "
+                         "        "
+                         "        "
+                         "P       ");
+  b.AddPiece('Q', "d7");
+  CHECK(b.Serialize() == "p       "
+                         "   Q    "
+                         "        "
+                         "   k    "
+                         "        "
+                         "        "
+                         "        "
+                         "P       ");
+  b.AddPiece('p', "h2");
+  CHECK(b.Serialize() == "p       "
+                         "   Q    "
+                         "        "
+                         "   k    "
+                         "        "
+                         "        "
+                         "       p"
+                         "P       ");
+  b.AddPiece('k', "h8");
+  CHECK(b.Serialize() == "p      k"
+                         "   Q    "
+                         "        "
+                         "   k    "
+                         "        "
+                         "        "
+                         "       p"
+                         "P       ");
+  b.AddPiece('N', "b2");
+  CHECK(b.Serialize() == "p      k"
+                         "   Q    "
+                         "        "
+                         "   k    "
+                         "        "
+                         "        "
+                         " N     p"
+                         "P       ");
+  b.AddPiece('n', "c2");
+  CHECK(b.Serialize() == "p      k"
+                         "   Q    "
+                         "        "
+                         "   k    "
+                         "        "
+                         "        "
+                         " Nn    p"
+                         "P       ");
+  b.AddPiece('b', "c3");
+  CHECK(b.Serialize() == "p      k"
+                         "   Q    "
+                         "        "
+                         "   k    "
+                         "        "
+                         "  b     "
+                         " Nn    p"
+                         "P       ");
+}
+

tests/chessarbiter.cpp

@@ -0,0 +1,302 @@
+#include "ChessArbiter.hpp"
+#include <catch_amalgamated.hpp>
+
+using namespace chessarbiter;
+
+TEST_CASE("Setup/GetBoard", "[chessarbiter/Setup/GetBoard]") {
+  ChessArbiter a;
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetBoard() == "rnbqkbnr"
+                        "pppppppp"
+                        "        "
+                        "        "
+                        "        "
+                        "        "
+                        "PPPPPPPP"
+                        "RNBQKBNR");
+
+  a.Setup("RnbqkbnR/pppppppp/8/8/8/8/PPPPPPPP/rNBQKBNr w KQkq - 0 1");
+  CHECK(a.GetBoard() == "RnbqkbnR"
+                        "pppppppp"
+                        "        "
+                        "        "
+                        "        "
+                        "        "
+                        "PPPPPPPP"
+                        "rNBQKBNr");
+}
+
+TEST_CASE("GetMaterialScore", "[chessarbiter/GetMaterialScore]") {
+  ChessArbiter a;
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 0);
+
+  // White better
+  a.Setup("1nbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 5);
+  a.Setup("r1bqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 3);
+  a.Setup("rnbqkbnr/1ppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 1);
+  a.Setup("rnb1kbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 9);
+  a.Setup("rnbqk1nr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 3);
+  a.Setup("rnbq1bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 0);
+
+  // Black better
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/1NBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == -5);
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKB1R w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == -3);
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPP1/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == -1);
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB1KBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == -9);
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RN1QKBNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == -3);
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQ1BNR w KQkq - 0 1");
+  CHECK(a.GetMaterialScore() == 0);
+}
+
+TEST_CASE("GetCaptures", "[board/GetCaptures]") {
+  ChessArbiter a;
+
+  // White captures
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "");
+  a.Setup("rnbqkbnr/8/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "pppppppp");
+  a.Setup("1nbqkbn1/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "rr");
+  a.Setup("r1bqkb1r/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "nn");
+  a.Setup("rnbqk1nr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "b");
+  a.Setup("rnb1kbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "q");
+  a.Setup("rnbq1bnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "k"); // :D
+
+  // Black captures
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/8/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(true) == "PPPPPPPP");
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/1NBQKBN1 w KQkq - 0 1");
+  CHECK(a.GetCaptures(true) == "RR");
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R1BQKB1R w KQkq - 0 1");
+  CHECK(a.GetCaptures(true) == "NN");
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNbQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(true) == "B");
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB1KBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(true) == "Q");
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQ1BNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(true) == "K"); // :D
+
+  // Just because we know the order of the implementation
+  a.Setup("11bqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.GetCaptures(false) == "rn");
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKB11 w KQkq - 0 1");
+  CHECK(a.GetCaptures(true) == "RN");
+}
+
+TEST_CASE("IsAttacked", "[chessarbiter/IsAttacked]") {
+  ChessArbiter a;
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+
+  // White third rank attacked by white
+  CHECK(a.IsAttacked("a3", false));
+  CHECK(a.IsAttacked("b3", false));
+  CHECK(a.IsAttacked("c3", false));
+  CHECK(a.IsAttacked("d3", false));
+  CHECK(a.IsAttacked("e3", false));
+  CHECK(a.IsAttacked("f3", false));
+  CHECK(a.IsAttacked("g3", false));
+  CHECK(a.IsAttacked("h3", false));
+  // White third rank attacked by black
+  CHECK_FALSE(a.IsAttacked("a3", true));
+  CHECK_FALSE(a.IsAttacked("b3", true));
+  CHECK_FALSE(a.IsAttacked("c3", true));
+  CHECK_FALSE(a.IsAttacked("d3", true));
+  CHECK_FALSE(a.IsAttacked("e3", true));
+  CHECK_FALSE(a.IsAttacked("f3", true));
+  CHECK_FALSE(a.IsAttacked("g3", true));
+  CHECK_FALSE(a.IsAttacked("h3", true));
+
+  // Black sixth rank attacked by black
+  CHECK(a.IsAttacked("a6", true));
+  CHECK(a.IsAttacked("b6", true));
+  CHECK(a.IsAttacked("c6", true));
+  CHECK(a.IsAttacked("d6", true));
+  CHECK(a.IsAttacked("e6", true));
+  CHECK(a.IsAttacked("f6", true));
+  CHECK(a.IsAttacked("g6", true));
+  CHECK(a.IsAttacked("h6", true));
+  // Black sixth rank attacked by white
+  CHECK_FALSE(a.IsAttacked("a6", false));
+  CHECK_FALSE(a.IsAttacked("b6", false));
+  CHECK_FALSE(a.IsAttacked("c6", false));
+  CHECK_FALSE(a.IsAttacked("d6", false));
+  CHECK_FALSE(a.IsAttacked("e6", false));
+  CHECK_FALSE(a.IsAttacked("f6", false));
+  CHECK_FALSE(a.IsAttacked("g6", false));
+  CHECK_FALSE(a.IsAttacked("h6", false));
+
+  // Remove a pawn for black
+  a.Setup("rnbqkbnr/1ppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.IsAttacked("a3", false));
+  CHECK(a.IsAttacked("a3", true));
+  CHECK_FALSE(a.IsAttacked("a4", false));
+  CHECK(a.IsAttacked("a4", true));
+
+  // Remove another pawn for black
+  a.Setup("rnbqkbnr/pppp1ppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.IsAttacked("a3", true));
+  CHECK(a.IsAttacked("h4", true));
+  CHECK(a.IsAttacked("a3", false));
+  CHECK_FALSE(a.IsAttacked("h4", false));
+
+  // Add a crazy black knight
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/4n3/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.IsAttacked("d1", true));
+  CHECK_FALSE(a.IsAttacked("e1", true));
+  CHECK(a.IsAttacked("f1", true));
+  CHECK_FALSE(a.IsAttacked("f2", true));
+  CHECK_FALSE(a.IsAttacked("d1", false)); // White can't attack is own pieces
+}
+
+TEST_CASE("ListLegalMoves", "[chessarbiter/ListLegalMoves]") {
+  ChessArbiter a;
+
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  std::vector<std::string> moves = a.ListLegalMoves(false);
+  REQUIRE(moves.size() == 20);
+  CHECK(std::find(moves.begin(), moves.end(), "e2e4") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "e2e3") != moves.end());
+  CHECK(std::find(moves.begin(), moves.end(), "b1c3") != moves.end());
+  CHECK_FALSE(std::find(moves.begin(), moves.end(), "d1d3") != moves.end());
+
+  // White Short Castle possible
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK11R w KQkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  REQUIRE(moves.size() == 22);
+  CHECK(std::find(moves.begin(), moves.end(), "O-O") != moves.end());
+
+  // White Short Castle impossible
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK11R w Qkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  CHECK_FALSE(std::find(moves.begin(), moves.end(), "O-O") != moves.end());
+
+  // White Short Castle impossible 2
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK1NR w KQkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  CHECK_FALSE(std::find(moves.begin(), moves.end(), "O-O") != moves.end());
+
+  // White Short Castle impossible 3 (queen attacks by black)
+  a.Setup("rnbqkbnr/pppppqpp/8/8/8/8/PPPPP1PP/RNBQK11R w KQkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  CHECK_FALSE(std::find(moves.begin(), moves.end(), "O-O") != moves.end());
+
+  // White Long Castle possible
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3KNBR w KQkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  REQUIRE(moves.size() == 23);
+  CHECK(find(moves.begin(), moves.end(), "O-O-O") != moves.end());
+
+  // White Long Castle impossible
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3KBNR w Kkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  CHECK_FALSE(std::find(moves.begin(), moves.end(), "O-O-O") != moves.end());
+
+  // White Long Castle impossible 2
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RN2KBNR w KQkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  CHECK_FALSE(std::find(moves.begin(), moves.end(), "O-O-O") != moves.end());
+
+  // White Long Castle impossible 3 (rook attacks by black)
+  a.Setup("rnbqkbnr/pprppppp/8/8/8/8/PP1PPPPP/R3KBNR w KQkq - 0 1");
+  moves = a.ListLegalMoves(false);
+  CHECK_FALSE(std::find(moves.begin(), moves.end(), "O-O-O") != moves.end());
+}
+
+TEST_CASE("IsPlayable", "[chessarbiter/IsPlayable]") {
+  ChessArbiter a;
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK(a.IsPlayable());
+
+  a.Setup("8/8/1q1k4/8/8/8/5K2/8 w - - 0 1");
+  CHECK(a.IsPlayable());
+
+  a.Setup("8/8/3k4/3q4/8/8/3K4/8 b - - 0 1");
+  CHECK_FALSE(a.IsPlayable());
+
+  a.Setup("8/8/3k4/3q4/8/8/3R4/8 b - - 0 1");
+  CHECK_FALSE(a.IsPlayable());
+
+  a.Setup("8/8/3k4/3q4/8/8/5K2/4K3 b - - 0 1");
+  CHECK_FALSE(a.IsPlayable());
+
+  a.Setup("1k6/8/3k4/3q4/8/8/5K2/8 b - - 0 1");
+  CHECK_FALSE(a.IsPlayable());
+}
+
+TEST_CASE("Play Basic", "[chessarbiter/Play]") {
+  ChessArbiter a;
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+
+  // White turn
+  CHECK(a.Play("e2e3"));
+  CHECK(a.GetFEN() ==
+        "rnbqkbnr/pppppppp/8/8/8/4P3/PPPP1PPP/RNBQKBNR b KQkq - 0 1");
+  CHECK_FALSE(a.Play("d2d3")); // Black turn
+  CHECK(a.GetFEN() ==
+        "rnbqkbnr/pppppppp/8/8/8/4P3/PPPP1PPP/RNBQKBNR b KQkq - 0 1");
+
+  // Black turn
+  CHECK(a.Play("e7e5"));
+  CHECK(a.GetFEN() ==
+        "rnbqkbnr/pppp1ppp/8/4p3/8/4P3/PPPP1PPP/RNBQKBNR w KQkq - 0 2");
+  CHECK_FALSE(a.Play("d7d6")); // White turn
+  CHECK(a.GetFEN() ==
+        "rnbqkbnr/pppp1ppp/8/4p3/8/4P3/PPPP1PPP/RNBQKBNR w KQkq - 0 2");
+
+  // White turn
+  CHECK(a.Play("b1c3"));
+  CHECK(a.GetFEN() ==
+        "rnbqkbnr/pppp1ppp/8/4p3/8/2N1P3/PPPP1PPP/R1BQKBNR b KQkq - 1 2");
+}
+
+TEST_CASE("IsCheckmate", "[chessarbiter/IsCheckmate]") {
+  ChessArbiter a;
+
+  // There is no checkmate
+  a.Setup("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  CHECK_FALSE(a.IsCheckMate());
+  // Ensure fen did not change
+  CHECK(a.GetFEN() ==
+        "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+
+  // There is a checkmate
+  a.Setup("r1bqkbnr/1ppp1Qpp/p1n5/4p3/2B1P3/8/PPPP1PPP/RNB1K1NR b KQkq - 0 4");
+  CHECK(a.IsCheckMate());
+  CHECK(a.GetFEN() ==
+        "r1bqkbnr/1ppp1Qpp/p1n5/4p3/2B1P3/8/PPPP1PPP/RNB1K1NR b KQkq - 0 4");
+
+  // There is a checkmate
+  a.Setup("1nb1kbnr/1p3ppp/2p1p3/3p4/2P4B/2qP4/3RPPPP/1r2KBNR w Kk - 0 19");
+  CHECK(a.IsCheckMate());
+  CHECK(a.GetFEN() ==
+        "1nb1kbnr/1p3ppp/2p1p3/3p4/2P4B/2qP4/3RPPPP/1r2KBNR w Kk - 0 19");
+
+  // There is no checkmate
+  a.Setup("1nb1kbnr/1p3ppp/2p1p3/3p4/1QP4B/2qP4/3RPPPP/r3KBNR w Kk - 2 18");
+  CHECK_FALSE(a.IsCheckMate());
+  CHECK(a.GetFEN() ==
+        "1nb1kbnr/1p3ppp/2p1p3/3p4/1QP4B/2qP4/3RPPPP/r3KBNR w Kk - 2 18");
+
+  // There is a checkmate
+  a.Setup("r3qbr1/p1p1pkp1/1p2p1p1/8/8/8/PPPPP1PP/RNBQ1RK1 b - - 1 1");
+  CHECK(a.IsCheckMate());
+  CHECK(a.GetFEN() ==
+        "r3qbr1/p1p1pkp1/1p2p1p1/8/8/8/PPPPP1PP/RNBQ1RK1 b - - 1 1");
+}

tests/fen.cpp

@@ -0,0 +1,91 @@
+#include "Fen.hpp"
+#include <catch_amalgamated.hpp>
+
+using namespace chessarbiter;
+
+TEST_CASE("Serializer", "[fen/serialize]") {
+  FEN f;
+  f.board = "p    p p"
+            "p      p"
+            "        "
+            "QQQQQQQQ"
+            "kpkpkpkp"
+            "        "
+            "p p r b "
+            "       R";
+  REQUIRE(FENParser::Serialize(f) ==
+          "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R w KQkq - 0 1");
+
+  f.white_castle_short = false;
+  f.white_castle_long = false;
+  f.black_castle_short = false;
+  f.black_castle_long = false;
+  REQUIRE(FENParser::Serialize(f) ==
+          "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R w - - 0 1");
+
+  f.en_passant = "a3";
+  REQUIRE(FENParser::Serialize(f) ==
+          "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R w - a3 0 1");
+
+  f.player = true;
+  REQUIRE(FENParser::Serialize(f) ==
+          "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b - a3 0 1");
+
+  f.halfmove = 5;
+  REQUIRE(FENParser::Serialize(f) ==
+          "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b - a3 5 1");
+
+  f.move = 5;
+  REQUIRE(FENParser::Serialize(f) ==
+          "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b - a3 5 5");
+}
+
+TEST_CASE("Parse", "[fen/parse]") {
+  FEN f;
+  f = FENParser::Parse(
+      "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b - a3 5 5");
+
+  REQUIRE(f.board == "p    p p"
+                     "p      p"
+                     "        "
+                     "QQQQQQQQ"
+                     "kpkpkpkp"
+                     "        "
+                     "p p r b "
+                     "       R");
+  CHECK(f.white_castle_short == false);
+  CHECK(f.white_castle_long == false);
+  CHECK(f.black_castle_short == false);
+  CHECK(f.black_castle_long == false);
+  CHECK(f.move == 5);
+  CHECK(f.halfmove == 5);
+  CHECK(f.player == true);
+
+  f = FENParser::Parse(
+      "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b k a3 5 5");
+  CHECK(f.white_castle_short == false);
+  CHECK(f.white_castle_long == false);
+  CHECK(f.black_castle_short == true);
+  CHECK(f.black_castle_long == false);
+
+  f = FENParser::Parse(
+      "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b qk a3 5 5");
+  CHECK(f.white_castle_short == false);
+  CHECK(f.white_castle_long == false);
+  CHECK(f.black_castle_short == true);
+  CHECK(f.black_castle_long == true);
+
+  f = FENParser::Parse(
+      "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b Kqk a3 5 5");
+  CHECK(f.white_castle_short == true);
+  CHECK(f.white_castle_long == false);
+  CHECK(f.black_castle_short == true);
+  CHECK(f.black_castle_long == true);
+
+  f = FENParser::Parse(
+      "p4p1p/p6p/8/QQQQQQQQ/kpkpkpkp/8/p1p1r1b1/7R b KQqk a3 5 5");
+  CHECK(f.white_castle_short == true);
+  CHECK(f.white_castle_long == true);
+  CHECK(f.black_castle_short == true);
+  CHECK(f.black_castle_long == true);
+}