chessboard.h

Go to the documentation of this file.

// Hoover Chess Utilities / PGN reader
// Copyright (C) 2024-2025  Sami Kiminki
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef HOOVER_CHESS_UTILS__PGN_READER__CHESSBOARD_H_INCLUDED
#define HOOVER_CHESS_UTILS__PGN_READER__CHESSBOARD_H_INCLUDED
 
#include "pgnreader-types.h"
#include "chessboard-types.h"
#include "chessboard-types-squareset.h"
 
#include <array>
#include <cassert>
#include <cinttypes>
#include <type_traits>
 
namespace hoover_chess_utils::pgn_reader
{
 
// forward declarations
class ChessBoard;
struct MoveGenFunctions;
class MoveGenFunctionTables;
 
 
using ArrayBoard = std::array<PieceAndColorCompact, 64U>;
 
struct BitBoard
{
    SquareSet pawns;
 
    SquareSet knights;
 
    SquareSet bishops;
 
    SquareSet rooks;
 
    SquareSet queens;
 
    SquareSet kings;
 
    SquareSet whitePieces;
};
 
using MoveTypeAndPromotionUnderlyingType = std::uint_fast8_t;
 
enum class MoveTypeAndPromotion : MoveTypeAndPromotionUnderlyingType
{
    REGULAR_PAWN_MOVE    = 0U,
 
    REGULAR_KNIGHT_MOVE  = 1U,
 
    REGULAR_BISHOP_MOVE  = 2U,
 
    REGULAR_ROOK_MOVE    = 3U,
 
    REGULAR_QUEEN_MOVE   = 4U,
 
    REGULAR_KING_MOVE    = 5U,
 
    CASTLING_SHORT       = 6U,
 
    CASTLING_LONG        = 7U,
 
    PROMO_KNIGHT         = 8U,
 
    PROMO_BISHOP         = 9U,
 
    PROMO_ROOK           = 10U,
 
    PROMO_QUEEN          = 11U,
 
    EN_PASSANT           = 12U,
 
    ILLEGAL              = 15U
};
 
class CompactMove;
 
class Move
{
private:
    std::uint_fast16_t m_encoded { };
 
    static constexpr std::uint_fast16_t getMoveTypeAndPromotionMask(
        MoveTypeAndPromotionUnderlyingType mask) noexcept
    {
        assert(mask <= 0x0FU);
        return std::uint_fast16_t(mask) << 6U;
    }
 
public:
    constexpr Move() noexcept = default;
 
    constexpr Move(Square src, Square dst, MoveTypeAndPromotion typeAndPromo) noexcept :
        m_encoded(
            (static_cast<std::uint16_t>(src)) |
            (static_cast<std::uint16_t>(typeAndPromo) << 6) |
            (static_cast<std::uint16_t>(dst) << 10U)
            )
    {
        assert(isValidSquare(src));
        assert(isValidSquare(dst));
        assert((typeAndPromo <= MoveTypeAndPromotion::EN_PASSANT) ||
               (typeAndPromo == MoveTypeAndPromotion::ILLEGAL));
    }
 
    constexpr Move(const Move &) noexcept = default;
 
    constexpr Move(Move &&) noexcept = default;
 
    Move &operator = (const Move &) noexcept = default;
 
    Move &operator = (Move &&) noexcept = default;
 
    constexpr inline Move(const CompactMove &m) noexcept;
 
    ~Move() noexcept = default;
 
    constexpr Square getSrc() const noexcept
    {
        return static_cast<Square>(m_encoded & 63U);
    }
 
    constexpr Square getDst() const noexcept
    {
        return static_cast<Square>(m_encoded >> 10U);
    }
 
    constexpr MoveTypeAndPromotion getTypeAndPromotion() const noexcept
    {
        return static_cast<MoveTypeAndPromotion>((m_encoded >> 6U) & 0xFU);
    }
 
    constexpr bool isRegularMove() const noexcept
    {
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::REGULAR_PAWN_MOVE)   == 0U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::REGULAR_KNIGHT_MOVE) == 1U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::REGULAR_BISHOP_MOVE) == 2U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::REGULAR_ROOK_MOVE)   == 3U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::REGULAR_QUEEN_MOVE)  == 4U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::REGULAR_KING_MOVE)   == 5U);
 
        constexpr auto fieldMask { getMoveTypeAndPromotionMask(0x0FU) };
        return (m_encoded & fieldMask) <= getMoveTypeAndPromotionMask(0x05U);
 
        //return getTypeAndPromotion() <= MoveTypeAndPromotion::REGULAR_KING_MOVE;
    }
 
    constexpr bool isEnPassantMove() const noexcept
    {
        return getTypeAndPromotion() == MoveTypeAndPromotion::EN_PASSANT;
    }
 
    constexpr bool isPromotionMove() const noexcept
    {
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::PROMO_KNIGHT) == 8U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::PROMO_BISHOP) == 9U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::PROMO_ROOK)   == 10U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::PROMO_QUEEN)  == 11U);
 
        constexpr auto fieldMask { getMoveTypeAndPromotionMask(0x0CU) };
        return (m_encoded & fieldMask) == getMoveTypeAndPromotionMask(0x08U);
    }
 
    constexpr bool isCastlingMove() const noexcept
    {
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::CASTLING_SHORT) == 6U);
        static_assert(static_cast<MoveTypeAndPromotionUnderlyingType>(MoveTypeAndPromotion::CASTLING_LONG) == 7U);
 
        constexpr auto fieldMask { getMoveTypeAndPromotionMask(0x0EU) };
        return (m_encoded & fieldMask) == getMoveTypeAndPromotionMask(0x06U);
    }
 
    constexpr Piece getPromotionPiece() const noexcept
    {
        assert(isPromotionMove());
 
        using UnderlyingType = PieceUnderlyingType;
        static_assert(std::is_same_v<UnderlyingType, PieceUnderlyingType>);
 
        constexpr UnderlyingType bias =
            static_cast<UnderlyingType>(MoveTypeAndPromotion::PROMO_KNIGHT) -
            static_cast<UnderlyingType>(Piece::KNIGHT);
 
        static_assert(
            (static_cast<UnderlyingType>(Piece::KNIGHT) + bias) ==
            static_cast<UnderlyingType>(MoveTypeAndPromotion::PROMO_KNIGHT));
        static_assert(
            (static_cast<UnderlyingType>(Piece::BISHOP) + bias) ==
            static_cast<UnderlyingType>(MoveTypeAndPromotion::PROMO_BISHOP));
        static_assert(
            (static_cast<UnderlyingType>(Piece::ROOK) + bias) ==
            static_cast<UnderlyingType>(MoveTypeAndPromotion::PROMO_ROOK));
        static_assert(
            (static_cast<UnderlyingType>(Piece::KNIGHT) + bias) ==
            static_cast<UnderlyingType>(MoveTypeAndPromotion::PROMO_KNIGHT));
 
        return Piece(static_cast<UnderlyingType>(getTypeAndPromotion()) - bias);
    }
 
    constexpr bool isIllegal() const noexcept
    {
        // this is slightly faster than extracting and comparing the
        // MoveTypeAndPromotion field
        return m_encoded >= 0xFFC0U;
    }
 
    constexpr std::uint_fast16_t getEncodedValue() const noexcept
    {
        return m_encoded;
    }
 
    constexpr bool operator == (const Move &o) const noexcept
    {
        return m_encoded == o.m_encoded;
    }
 
    static constexpr Move illegalNoMove() noexcept
    {
        return Move { Square::A1, Square::H8, MoveTypeAndPromotion::ILLEGAL };
    }
 
    static constexpr Move illegalAmbiguousMove() noexcept
    {
        return Move { Square::A2, Square::H8, MoveTypeAndPromotion::ILLEGAL };
    }
};
 
class CompactMove
{
private:
    std::uint16_t m_encoded { };
 
public:
    CompactMove() = default;
 
    CompactMove(const CompactMove &) = default;
 
    CompactMove(CompactMove &&) = default;
 
    CompactMove &operator = (const CompactMove &) & = default;
 
    CompactMove &operator = (CompactMove &&) & = default;
 
    ~CompactMove() = default;
 
    constexpr CompactMove(const Move &m) noexcept :
        m_encoded(m.getEncodedValue())
    {
        assert(m.getEncodedValue() <= 0xFFFFU);
    }
 
    constexpr std::uint16_t getEncodedValue() const noexcept
    {
        return m_encoded;
    }
};
 
constexpr Move::Move(const CompactMove &m) noexcept :
    m_encoded { m.getEncodedValue() }
{
}
 
using MoveList = std::array<CompactMove, 256U>;
 
using ShortMoveList = std::array<CompactMove, 8U>;
 
enum class MoveGenType
{
    NO_CHECK = 0U,
 
    CHECK,
 
    DOUBLE_CHECK,
};
 
 
class ChessBoard final
{
public:
 
    ChessBoard() noexcept;
 
    ChessBoard(const ChessBoard &) noexcept = default;
 
    ChessBoard(ChessBoard &&) noexcept = default;
 
    ChessBoard &operator = (const ChessBoard &) noexcept = default;
 
    ChessBoard &operator = (ChessBoard &&) noexcept = default;
 
    ~ChessBoard() noexcept = default;
 
    void setBoard(
        const ArrayBoard &board,
        Square whiteLongCastleRook, Square whiteShortCastleRook,
        Square blackLongCastleRook, Square blackShortCastleRook,
        Square epSquare,
        std::uint_fast8_t halfMoveClock, std::uint_fast32_t plyNum);
 
    void getArrayBoard(ArrayBoard &out_board) const noexcept;
 
    void setBoard(
        const BitBoard &board,
        Square whiteLongCastleRook, Square whiteShortCastleRook,
        Square blackLongCastleRook, Square blackShortCastleRook,
        Square epSquare,
        std::uint_fast8_t halfMoveClock, std::uint_fast32_t plyNum);
 
    void loadFEN(std::string_view fen);
 
    inline PositionStatus determineStatus() const noexcept;
 
    void loadStartPos() noexcept
    {
        *this = ChessBoard { };
    }
 
    void printBoard() const;
 
    Piece getSquarePieceNoColor(Square sq) const noexcept;
 
    PieceAndColor getSquarePiece(Square sq) const noexcept;
 
    inline SquareSet getOccupancyMask() const noexcept
    {
        return m_occupancyMask;
    }
 
    inline SquareSet getWhitePieces() const noexcept
    {
        const std::uint_fast64_t flipBits { getTurn() == Color::WHITE ? UINT64_C(0) : ~UINT64_C(0) };
 
        return m_occupancyMask & (m_turnColorMask ^ SquareSet { flipBits });
    }
 
    inline SquareSet getBlackPieces() const noexcept
    {
        const std::uint_fast64_t flipBits { getTurn() == Color::WHITE ? ~UINT64_C(0) : UINT64_C(0) };
 
        return m_occupancyMask & (m_turnColorMask ^ SquareSet { flipBits });
    }
 
    inline SquareSet getPiecesInTurn() const noexcept
    {
        return m_turnColorMask;
    }
 
    inline SquareSet getPawns() const noexcept
    {
        return m_pawns;
    }
 
    inline SquareSet getKnights() const noexcept
    {
        return m_knights;
    }
 
    inline SquareSet getBishops() const noexcept
    {
        return m_bishops & ~m_rooks;
    }
 
    inline SquareSet getRooks() const noexcept
    {
        return m_rooks & ~m_bishops;
    }
 
    inline SquareSet getQueens() const noexcept
    {
        return m_rooks & m_bishops;
    }
 
    inline SquareSet getBishopsAndQueens() const noexcept
    {
        return m_bishops;
    }
 
    inline SquareSet getRooksAndQueens() const noexcept
    {
        return m_rooks;
    }
 
    inline SquareSet getKings() const noexcept
    {
        return m_kings;
    }
 
    inline Square getKingInTurn() const noexcept
    {
        return m_kingSq;
    }
 
    inline Square getKingNotInTurn() const noexcept
    {
        return m_oppKingSq;
    }
 
    inline bool isInCheck() const noexcept
    {
        return m_checkers != SquareSet::none();
    }
 
    inline SquareSet getCheckers() const noexcept
    {
        return m_checkers;
    }
 
    inline SquareSet getPinnedPieces() const noexcept
    {
        return m_pinnedPieces;
    }
 
    inline Square getWhiteLongCastleRook() const noexcept
    {
        return getCastlingRook(Color::WHITE, false);
    }
 
    inline Square getWhiteShortCastleRook() const noexcept
    {
        return getCastlingRook(Color::WHITE, true);
    }
 
    inline Square getBlackLongCastleRook() const noexcept
    {
        return getCastlingRook(Color::BLACK, false);
    }
 
    inline Square getBlackShortCastleRook() const noexcept
    {
        return getCastlingRook(Color::BLACK, true);
    }
 
    inline Square getCastlingRook(Color c, bool shortCastling) const noexcept
    {
        return m_castlingRooks[getCastlingRookIndex(c, shortCastling)];
    }
 
    inline Square getEpSquare() const noexcept
    {
        return m_epSquare;
    }
 
    inline std::uint_fast8_t getHalfMoveClock() const noexcept
    {
        return m_halfMoveClock;
    }
 
    inline std::uint_fast32_t getCurrentPlyNum() const noexcept
    {
        return m_plyNum;
    }
 
    inline Color getTurn() const noexcept
    {
        return Color { static_cast<std::uint_fast8_t>((m_plyNum & 1U) * 8U) };
    }
 
    inline Move generateSingleMoveForPawnAndDestNoCapture(SquareSet srcSqMask, Square dst) const noexcept;
 
    inline Move generateSingleMoveForPawnAndDestCapture(SquareSet srcSqMask, Square dst) const noexcept;
 
    inline Move generateSingleMoveForPawnAndDestPromoNoCapture(SquareSet srcSqMask, Square dst, Piece promo) const noexcept;
 
    inline Move generateSingleMoveForPawnAndDestPromoCapture(SquareSet srcSqMask, Square dst, Piece promo) const noexcept;
 
    inline Move generateSingleMoveForKnightAndDest(SquareSet srcSqMask, Square dst) const noexcept;
 
    inline Move generateSingleMoveForBishopAndDest(SquareSet srcSqMask, Square dst) const noexcept;
 
    inline Move generateSingleMoveForRookAndDest(SquareSet srcSqMask, Square dst) const noexcept;
 
    inline Move generateSingleMoveForQueenAndDest(SquareSet srcSqMask, Square dst) const noexcept;
 
    inline Move generateSingleMoveForKingAndDest(SquareSet srcSqMask, Square dst) const noexcept;
 
    inline Move generateSingleMoveForShortCastling() const noexcept;
 
    inline Move generateSingleMoveForLongCastling() const noexcept;
 
    inline std::size_t generateMovesForPawnAndDestNoCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept;
 
    inline std::size_t generateMovesForPawnAndDestCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept;
 
    inline std::size_t generateMovesForPawnAndDestPromoNoCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst, Piece promo) const noexcept;
 
    inline std::size_t generateMovesForPawnAndDestPromoCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst, Piece promo) const noexcept;
 
    inline std::size_t generateMovesForKnightAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept;
 
    inline std::size_t generateMovesForBishopAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept;
 
    inline std::size_t generateMovesForRookAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept;
 
    inline std::size_t generateMovesForQueenAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept;
 
    inline std::size_t generateMovesForKingAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept;
 
    inline std::size_t generateMovesForShortCastling(ShortMoveList &moves) const noexcept;
 
    inline std::size_t generateMovesForLongCastling(ShortMoveList &moves) const noexcept;
 
    inline std::size_t generateMoves(MoveList &moves) const noexcept;
 
    inline std::size_t getNumberOfLegalMoves() const noexcept;
 
    inline bool hasLegalMoves() const noexcept;
 
    void doMove(Move m) noexcept;
 
    bool operator == (const ChessBoard &o) const noexcept;
 
private:
    SquareSet m_occupancyMask { SquareSet::row(0U) | SquareSet::row(1U) | SquareSet::row(6U) | SquareSet::row(7U) };
 
    SquareSet m_turnColorMask { SquareSet::row(0U) | SquareSet::row(1U) };
 
    SquareSet m_pawns { SquareSet::row(1U) | SquareSet::row(6U) };
 
    SquareSet m_knights {
        SquareSet::square(Square::B1) | SquareSet::square(Square::G1) |
        SquareSet::square(Square::B8) | SquareSet::square(Square::G8) };
 
    SquareSet m_kings { SquareSet::square(Square::E1) | SquareSet::square(Square::E8) };
 
    SquareSet m_bishops {
        SquareSet::square(Square::C1) | SquareSet::square(Square::F1) |
        SquareSet::square(Square::C8) | SquareSet::square(Square::F8) |
        SquareSet::square(Square::D1) | SquareSet::square(Square::D8) };
 
    SquareSet m_rooks {
        SquareSet::square(Square::A1) | SquareSet::square(Square::H1) |
        SquareSet::square(Square::A8) | SquareSet::square(Square::H8) |
        SquareSet::square(Square::D1) | SquareSet::square(Square::D8) };
 
    SquareSet m_checkers { };
 
    SquareSet m_pinnedPieces { };
 
    const MoveGenFunctions *m_moveGenFns;
 
    std::uint32_t m_plyNum { };
 
    std::uint8_t m_halfMoveClock { };
 
    Square m_kingSq { Square::E1 };
 
    Square m_oppKingSq { Square::E8 };
 
    Square m_epSquare { Square::NONE };
 
    std::array<Square, 4U> m_castlingRooks { Square::A1, Square::H1, Square::A8, Square::H8 };
 
    void updateCheckersAndPins() noexcept;
 
    void validateBoard();
 
    static constexpr inline std::size_t getCastlingRookIndex(Color c, bool shortCastling) noexcept
    {
        static_assert(static_cast<std::size_t>(Color::WHITE) == 0U);
        static_assert(static_cast<std::size_t>(Color::BLACK) == 8U);
 
        assert((c == Color::WHITE) || (c == Color::BLACK));
        [[assume((c == Color::WHITE) || (c == Color::BLACK))]];
 
        return (static_cast<std::size_t>(c) / 4U) + static_cast<std::size_t>(shortCastling);
    }
 
    inline void setCastlingRook(Color c, bool shortCastling, Square sq) noexcept
    {
        m_castlingRooks[getCastlingRookIndex(c, shortCastling)] = sq;
    }
 
    inline Square &getCastlingRookRef(Color c, bool shortCastling) noexcept
    {
        return m_castlingRooks[getCastlingRookIndex(c, shortCastling)];
    }
 
    void calculateMasks(const ArrayBoard &board) noexcept;
};
 
struct MoveGenFunctions
{
    Move (*generateSingleMoveForPawnAndDestNoCapture)(const ChessBoard &board, SquareSet srcSqMask, Square dst) noexcept;
 
    Move (*generateSingleMoveForPawnAndDestCapture)(const ChessBoard &board, SquareSet srcSqMask, Square dst)noexcept;
 
    Move (*generateSingleMoveForPawnAndDestPromoNoCapture)(const ChessBoard &board, SquareSet srcSqMask, Square dst, Piece promo) noexcept;
 
    Move (*generateSingleMoveForPawnAndDestPromoCapture)(const ChessBoard &board, SquareSet srcSqMask, Square dst, Piece promo) noexcept;
 
    Move (*generateSingleMoveForKnightAndDest)(const ChessBoard &board, SquareSet srcSqMask, Square dst) noexcept;
 
    Move (*generateSingleMoveForBishopAndDest)(const ChessBoard &board, SquareSet srcSqMask, Square dst) noexcept;
 
    Move (*generateSingleMoveForRookAndDest)(const ChessBoard &board, SquareSet srcSqMask, Square dst) noexcept;
 
    Move (*generateSingleMoveForQueenAndDest)(const ChessBoard &board, SquareSet srcSqMask, Square dst) noexcept;
 
    Move (*generateSingleMoveForKingAndDest)(const ChessBoard &board, SquareSet srcSqMask, Square dst) noexcept;
 
    Move (*generateSingleMoveForShortCastling)(const ChessBoard &board) noexcept;
 
    Move (*generateSingleMoveForLongCastling)(const ChessBoard &board) noexcept;
 
    std::size_t (*generateMovesForPawnAndDestNoCapture)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst) noexcept;
 
    std::size_t (*generateMovesForPawnAndDestCapture)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst) noexcept;
 
    std::size_t (*generateMovesForPawnAndDestPromoNoCapture)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst, Piece promo) noexcept;
 
    std::size_t (*generateMovesForPawnAndDestPromoCapture)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst, Piece promo) noexcept;
 
    std::size_t (*generateMovesForKnightAndDest)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst) noexcept;
 
    std::size_t (*generateMovesForBishopAndDest)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst) noexcept;
 
    std::size_t (*generateMovesForRookAndDest)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst) noexcept;
 
    std::size_t (*generateMovesForQueenAndDest)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst) noexcept;
 
    std::size_t (*generateMovesForKingAndDest)(const ChessBoard &board, ShortMoveList &moves, SquareSet srcSqMask, Square dst) noexcept;
 
    std::size_t (*generateMovesForShortCastling)(const ChessBoard &board, ShortMoveList &moves) noexcept;
 
    std::size_t (*generateMovesForLongCastling)(const ChessBoard &board, ShortMoveList &moves) noexcept;
 
    std::size_t (*generateMoves)(const ChessBoard &board, MoveList &moves) noexcept;
 
    std::size_t (*getNumberOfLegalMoves)(const ChessBoard &board) noexcept;
 
    bool (*hasLegalMoves)(const ChessBoard &board) noexcept;
};
 
Move ChessBoard::generateSingleMoveForPawnAndDestNoCapture(SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateSingleMoveForPawnAndDestNoCapture(*this, srcSqMask, dst);
}
 
Move ChessBoard::generateSingleMoveForPawnAndDestCapture(SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateSingleMoveForPawnAndDestCapture(*this, srcSqMask, dst);
}
 
Move ChessBoard::generateSingleMoveForPawnAndDestPromoNoCapture(SquareSet srcSqMask, Square dst, Piece promo) const noexcept
{
    return m_moveGenFns->generateSingleMoveForPawnAndDestPromoNoCapture(*this, srcSqMask, dst, promo);
}
 
Move ChessBoard::generateSingleMoveForPawnAndDestPromoCapture(SquareSet srcSqMask, Square dst, Piece promo) const noexcept
{
    return m_moveGenFns->generateSingleMoveForPawnAndDestPromoCapture(*this, srcSqMask, dst, promo);
}
 
Move ChessBoard::generateSingleMoveForKnightAndDest(SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateSingleMoveForKnightAndDest(*this, srcSqMask, dst);
}
 
Move ChessBoard::generateSingleMoveForBishopAndDest(SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateSingleMoveForBishopAndDest(*this, srcSqMask, dst);
}
 
Move ChessBoard::generateSingleMoveForRookAndDest(SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateSingleMoveForRookAndDest(*this, srcSqMask, dst);
}
 
Move ChessBoard::generateSingleMoveForQueenAndDest(SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateSingleMoveForQueenAndDest(*this, srcSqMask, dst);
}
 
Move ChessBoard::generateSingleMoveForKingAndDest(SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateSingleMoveForKingAndDest(*this, srcSqMask, dst);
}
 
Move ChessBoard::generateSingleMoveForShortCastling() const noexcept
{
    return m_moveGenFns->generateSingleMoveForShortCastling(*this);
}
 
Move ChessBoard::generateSingleMoveForLongCastling() const noexcept
{
    return m_moveGenFns->generateSingleMoveForLongCastling(*this);
}
 
std::size_t ChessBoard::generateMovesForPawnAndDestNoCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateMovesForPawnAndDestNoCapture(*this, moves, srcSqMask, dst);
}
 
std::size_t ChessBoard::generateMovesForPawnAndDestCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateMovesForPawnAndDestCapture(*this, moves, srcSqMask, dst);
}
 
std::size_t ChessBoard::generateMovesForPawnAndDestPromoNoCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst, Piece promo) const noexcept
{
    return m_moveGenFns->generateMovesForPawnAndDestPromoNoCapture(*this, moves, srcSqMask, dst, promo);
}
 
std::size_t ChessBoard::generateMovesForPawnAndDestPromoCapture(ShortMoveList &moves, SquareSet srcSqMask, Square dst, Piece promo) const noexcept
{
    return m_moveGenFns->generateMovesForPawnAndDestPromoCapture(*this, moves, srcSqMask, dst, promo);
}
 
std::size_t ChessBoard::generateMovesForKnightAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateMovesForKnightAndDest(*this, moves, srcSqMask, dst);
}
 
std::size_t ChessBoard::generateMovesForBishopAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateMovesForBishopAndDest(*this, moves, srcSqMask, dst);
}
 
std::size_t ChessBoard::generateMovesForRookAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateMovesForRookAndDest(*this, moves, srcSqMask, dst);
}
 
std::size_t ChessBoard::generateMovesForQueenAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateMovesForQueenAndDest(*this, moves, srcSqMask, dst);
}
 
std::size_t ChessBoard::generateMovesForKingAndDest(ShortMoveList &moves, SquareSet srcSqMask, Square dst) const noexcept
{
    return m_moveGenFns->generateMovesForKingAndDest(*this, moves, srcSqMask, dst);
}
 
std::size_t ChessBoard::generateMovesForShortCastling(ShortMoveList &moves) const noexcept
{
    return m_moveGenFns->generateMovesForShortCastling(*this, moves);
}
 
std::size_t ChessBoard::generateMovesForLongCastling(ShortMoveList &moves) const noexcept
{
    return m_moveGenFns->generateMovesForLongCastling(*this, moves);
}
 
std::size_t ChessBoard::generateMoves(MoveList &moves) const noexcept
{
    return m_moveGenFns->generateMoves(*this, moves);
}
 
std::size_t ChessBoard::getNumberOfLegalMoves() const noexcept
{
    return m_moveGenFns->getNumberOfLegalMoves(*this);
}
 
bool ChessBoard::hasLegalMoves() const noexcept
{
    return m_moveGenFns->hasLegalMoves(*this);
}
 
PositionStatus ChessBoard::determineStatus() const noexcept
{
    static_assert(PositionStatus::NORMAL    == PositionStatus { 0U });
    static_assert(PositionStatus::CHECK     == PositionStatus { 1U });
    static_assert(PositionStatus::STALEMATE == PositionStatus { 2U });
    static_assert(PositionStatus::MATE      == PositionStatus { 3U });
 
    const bool noLegalMoves { !m_moveGenFns->hasLegalMoves(*this) };
    const bool inCheck { m_checkers != SquareSet::none() };
 
    return PositionStatus { static_cast<std::uint_fast8_t>(noLegalMoves * 2U + inCheck) };
}
 
 
static_assert(Move::illegalNoMove().isIllegal());
static_assert(Move::illegalNoMove().getTypeAndPromotion() == MoveTypeAndPromotion::ILLEGAL);
static_assert(Move::illegalAmbiguousMove().isIllegal());
static_assert(Move::illegalAmbiguousMove().getTypeAndPromotion() == MoveTypeAndPromotion::ILLEGAL);
 
}
 
#endif