Position.hpp

Go to the documentation of this file.

/*
 * ======================================================================================
 *
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓███████▓▒░       ░▒▓███████▓▒░ ░▒▓██████▓▒░▒▓████████▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓██████▓▒░ ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░ ░▒▓██████▓▒░  ░▒▓█▓▒░
 *
 * ======================================================================================
 */


 
#pragma once
 
#include <cstdint> // IWYU pragma: keep - for std::uint64_t
#include <libchess/board/Bitboard.hpp>
#include <libchess/board/File.hpp>
#include <libchess/board/Fills.hpp>
#include <libchess/board/Pieces.hpp>
#include <libchess/board/Square.hpp>
#include <libchess/game/CastlingRights.hpp>
#include <libchess/game/Result.hpp>
#include <libchess/game/ThreefoldChecker.hpp>
#include <libchess/moves/Attacks.hpp>
#include <libchess/moves/Patterns.hpp>
#include <libchess/pieces/Colors.hpp>
#include <libchess/pieces/PieceTypes.hpp>
#include <magic_enum/magic_enum.hpp>
#include <optional>
#include <ranges>
#include <string>
 
namespace chess::moves {
struct Move;
} // namespace chess::moves

namespace chess::game {
 
using board::Bitboard;
using board::File;
using board::Pieces;
using board::Square;
using moves::Move;
using pieces::Color;
 
using PieceType = pieces::Type;

struct [[nodiscard]] Position final {
    Position();

    Pieces whitePieces { Color::White };

    Pieces blackPieces { Color::Black };

    Color sideToMove { Color::White };

    CastlingRights whiteCastlingRights;

    CastlingRights blackCastlingRights;

    std::optional<Square> enPassantTargetSquare;

    std::uint_least8_t halfmoveClock { UINT8_C(0) };

    std::uint_least64_t fullMoveCounter { UINT64_C(1) };

    using Hash = std::uint64_t;

    Hash hash { UINT64_C(0) };

    [[nodiscard]] auto operator==(const Position& other) const noexcept -> bool
    {
        return hash == other.hash;
    }


    template <Color Side>
    [[nodiscard]] auto pieces_for() noexcept -> Pieces&
    {
        if constexpr (Side == Color::White)
            return whitePieces;
        else
            return blackPieces;
    }

    template <Color Side>
    [[nodiscard]] auto pieces_for() const noexcept -> const Pieces&
    {
        if constexpr (Side == Color::White)
            return whitePieces;
        else
            return blackPieces;
    }

    template <Color Side>
    [[nodiscard]] auto castling_rights_for() const noexcept -> CastlingRights
    {
        if constexpr (Side == Color::White)
            return whiteCastlingRights;
        else
            return blackCastlingRights;
    }

    [[nodiscard]] auto our_pieces() noexcept -> Pieces&
    {
        if (is_white_to_move())
            return whitePieces;
 
        return blackPieces;
    }

    [[nodiscard]] auto our_pieces() const noexcept -> const Pieces&
    {
        if (is_white_to_move())
            return whitePieces;
 
        return blackPieces;
    }

    [[nodiscard]] auto their_pieces() noexcept -> Pieces&
    {
        if (is_white_to_move())
            return blackPieces;
 
        return whitePieces;
    }

    [[nodiscard]] auto their_pieces() const noexcept -> const Pieces&
    {
        if (is_white_to_move())
            return blackPieces;
 
        return whitePieces;
    }


    [[nodiscard]] auto is_white_to_move() const noexcept -> bool
    {
        return sideToMove == Color::White;
    }

    [[nodiscard]] auto is_black_to_move() const noexcept -> bool
    {
        return sideToMove == Color::Black;
    }

    [[nodiscard]] auto occupied() const noexcept -> Bitboard { return whitePieces.occupied | blackPieces.occupied; }

    [[nodiscard]] auto free() const noexcept -> Bitboard { return occupied().inverse(); }


    [[nodiscard]] auto is_file_open(File file) const noexcept -> bool;

    [[nodiscard]] auto get_open_files() const noexcept;

    [[nodiscard]] auto is_file_half_open(File file) const noexcept -> bool;

    [[nodiscard]] auto get_half_open_files() const noexcept;


    [[nodiscard]] auto is_check() const noexcept -> bool { return is_side_in_check(sideToMove); }

    template <Color Side>
    [[nodiscard]] auto get_passed_pawns() const noexcept -> Bitboard;

    template <Color Side>
    [[nodiscard]] auto get_backward_pawns() const noexcept -> Bitboard;


    [[nodiscard]] auto is_checkmate() const -> bool;

    [[nodiscard]] auto is_stalemate() const -> bool;

    [[nodiscard]] auto is_fifty_move_draw() const -> bool;

    [[nodiscard]] auto is_threefold_repetition() const noexcept -> bool;

    [[nodiscard]] auto is_draw_by_insufficient_material() const noexcept -> bool;

    [[nodiscard]] auto is_draw() const -> bool;

    [[nodiscard]] auto get_result() const -> std::optional<Result>;


    [[nodiscard]] auto is_legal(Move move) const -> bool;

    [[nodiscard]] auto is_en_passant(Move move) const noexcept -> bool;

    [[nodiscard]] auto is_capture(Move move) const noexcept -> bool;

    [[nodiscard]] auto is_quiet(Move move) const noexcept -> bool;

    void make_move(Move move);

    void make_null_move();

    void flip();

    void refresh_zobrist();

    [[nodiscard]] auto is_illegal() const -> std::optional<std::string>;

    [[nodiscard]] static auto empty() -> Position;
 
private:
    [[nodiscard]] auto is_side_in_check(Color side) const noexcept -> bool;
 
    ThreefoldChecker threefoldChecker;
};

[[nodiscard, gnu::const]] auto after_move(
    const Position& starting, Move move)
    -> Position;

[[nodiscard, gnu::const]] auto after_null_move(const Position& starting) -> Position;

[[nodiscard, gnu::const]] auto flipped(const Position& starting) -> Position;

[[nodiscard]] auto print_utf8(const Position& position) -> std::string;

[[nodiscard]] auto print_ascii(const Position& position) -> std::string;
 
/*
                         ___                           ,--,
      ,---,            ,--.'|_                ,--,   ,--.'|
    ,---.'|            |  | :,'             ,--.'|   |  | :
    |   | :            :  : ' :             |  |,    :  : '    .--.--.
    |   | |   ,---.  .;__,'  /    ,--.--.   `--'_    |  ' |   /  /    '
  ,--.__| |  /     \ |  |   |    /       \  ,' ,'|   '  | |  |  :  /`./
 /   ,'   | /    /  |:__,'| :   .--.  .-. | '  | |   |  | :  |  :  ;_
.   '  /  |.    ' / |  '  : |__  \__\/: . . |  | :   '  : |__ \  \    `.
'   ; |:  |'   ;   /|  |  | '.'| ," .--.; | '  : |__ |  | '.'| `----.   \
|   | '/  ''   |  / |  ;  :    ;/  /  ,.  | |  | '.'|;  :    ;/  /`--'  /__  ___  ___
|   :    :||   :    |  |  ,   /;  :   .'   \;  :    ;|  ,   /'--'.     /  .\/  .\/  .\
 \   \  /   \   \  /    ---`-' |  ,     .-./|  ,   /  ---`-'   `--'---'\  ; \  ; \  ; |
  `----'     `----'             `--`---'     ---`-'                     `--" `--" `--"
 
 */
 
inline auto Position::empty() -> Position
{
    Position pos { };
 
    pos.whitePieces = { };
    pos.blackPieces = { };
 
    pos.refresh_zobrist();
 
    return pos;
}
 
inline auto Position::is_threefold_repetition() const noexcept -> bool
{
    return threefoldChecker.is_threefold();
}
 
inline auto Position::is_side_in_check(const Color side) const noexcept -> bool
{
    if (side == Color::White) {
        return moves::squares_attacked<Color::Black>(
            blackPieces, whitePieces.king, whitePieces.occupied);
    }
 
    return moves::squares_attacked<Color::White>(
        whitePieces, blackPieces.king, blackPieces.occupied);
}
 
inline auto Position::is_legal(const Move move) const -> bool
{
    auto copy { *this };
 
    copy.make_move(move);
 
    return not copy.is_side_in_check(sideToMove);
}
 
inline auto Position::is_en_passant(const Move move) const noexcept -> bool
{
    return move.piece() == PieceType::Pawn
       and enPassantTargetSquare.has_value()
       and move.to() == *enPassantTargetSquare;
}
 
inline auto Position::is_capture(const Move move) const noexcept -> bool
{
    return is_en_passant(move) or their_pieces().occupied.test(move.to());
}
 
inline auto Position::is_quiet(const Move move) const noexcept -> bool
{
    return not(move.is_promotion() or is_capture(move));
}
 
inline auto Position::is_file_open(const File file) const noexcept -> bool
{
    return whitePieces.is_file_half_open(file) and blackPieces.is_file_half_open(file);
}
 
inline auto Position::get_open_files() const noexcept
{
    return magic_enum::enum_values<File>()
         | std::views::filter([this](const File file) { return is_file_open(file); });
}
 
inline auto Position::is_file_half_open(const File file) const noexcept -> bool
{
    const bool whiteOpen = whitePieces.is_file_half_open(file);
    const bool blackOpen = blackPieces.is_file_half_open(file);
 
    // boolean XOR
    return whiteOpen != blackOpen;
}
 
inline auto Position::get_half_open_files() const noexcept
{
    return magic_enum::enum_values<File>()
         | std::views::filter([this](const File file) { return is_file_half_open(file); });
}
 
template <Color Side>
auto Position::get_passed_pawns() const noexcept -> Bitboard
{
    static constexpr auto OtherSide = pieces::other_side<Side>();
 
    const auto friendlyPawns = pieces_for<Side>().pawns;
    const auto enemyPawns    = pieces_for<OtherSide>().pawns;
 
    const auto mask = board::fills::pawn_front<OtherSide>(
        enemyPawns | moves::patterns::pawn_attacks<OtherSide>(enemyPawns));
 
    return friendlyPawns & mask.inverse();
}
 
template <Color Side>
auto Position::get_backward_pawns() const noexcept -> Bitboard
{
    static constexpr auto OtherSide = pieces::other_side<Side>();
 
    const auto friendlyPawns = pieces_for<Side>().pawns;
    const auto enemyPawns    = pieces_for<OtherSide>().pawns;
 
    const auto ourAttackSpans = board::fills::pawn_front<Side>(
        moves::patterns::pawn_attacks<Side>(friendlyPawns));
 
    const auto theirAttacks = moves::patterns::pawn_attacks<OtherSide>(enemyPawns);
 
    const auto backwardArea = board::fills::pawn_rear<Side>(
        ourAttackSpans.inverse() & theirAttacks);
 
    return backwardArea & friendlyPawns;
}
 
inline auto after_move(
    const Position& starting, const Move move)
    -> Position
{
    auto copy { starting };
 
    copy.make_move(move);
 
    return copy;
}
 
inline auto after_null_move(const Position& starting) -> Position
{
    auto copy { starting };
 
    copy.make_null_move();
 
    return copy;
}
 
inline auto flipped(const Position& starting) -> Position
{
    auto copy { starting };
 
    copy.flip();
 
    return copy;
}
 
} // namespace chess::game