Pieces.hpp

Go to the documentation of this file.

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

 
#pragma once
 
#include <algorithm>
#include <cassert>
#include <libchess/board/Bitboard.hpp>
#include <libchess/board/File.hpp>
#include <libchess/board/Flips.hpp>
#include <libchess/board/Masks.hpp>
#include <libchess/board/Square.hpp>
#include <libchess/moves/Move.hpp>
#include <libchess/pieces/Colors.hpp>
#include <libchess/pieces/PieceTypes.hpp>
#include <magic_enum/magic_enum.hpp>
#include <optional>
 
namespace chess::board {
 
using pieces::Color;
 
using PieceType = pieces::Type;

struct Pieces final {
    explicit constexpr Pieces(Color color) noexcept;

    consteval Pieces() noexcept = default;

    Bitboard pawns;

    Bitboard knights;

    Bitboard bishops;

    Bitboard rooks;

    Bitboard queens;

    Bitboard king;

    Bitboard occupied {
        pawns | knights | bishops | rooks | queens | king
    };

    [[nodiscard]] constexpr auto operator==(const Pieces&) const noexcept -> bool = default;

    [[nodiscard]] constexpr auto get_type(PieceType type) noexcept -> Bitboard&;

    [[nodiscard]] constexpr auto get_type(PieceType type) const noexcept -> Bitboard;

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

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

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

    [[nodiscard]] constexpr auto get_king_location() const noexcept -> Square;

    [[nodiscard]] constexpr auto get_piece_on(Square square) const noexcept
        -> std::optional<PieceType>;

    constexpr void capture_at(Square square) noexcept;

    constexpr void our_move(moves::Move move, Color ourColor) noexcept;

    constexpr void refresh_occupied() noexcept;

    constexpr void vertical_flip() noexcept;
};
 
/*
                         ___                           ,--,
      ,---,            ,--.'|_                ,--,   ,--.'|
    ,---.'|            |  | :,'             ,--.'|   |  | :
    |   | :            :  : ' :             |  |,    :  : '    .--.--.
    |   | |   ,---.  .;__,'  /    ,--.--.   `--'_    |  ' |   /  /    '
  ,--.__| |  /     \ |  |   |    /       \  ,' ,'|   '  | |  |  :  /`./
 /   ,'   | /    /  |:__,'| :   .--.  .-. | '  | |   |  | :  |  :  ;_
.   '  /  |.    ' / |  '  : |__  \__\/: . . |  | :   '  : |__ \  \    `.
'   ; |:  |'   ;   /|  |  | '.'| ," .--.; | '  : |__ |  | '.'| `----.   \
|   | '/  ''   |  / |  ;  :    ;/  /  ,.  | |  | '.'|;  :    ;/  /`--'  /__  ___  ___
|   :    :||   :    |  |  ,   /;  :   .'   \;  :    ;|  ,   /'--'.     /  .\/  .\/  .\
 \   \  /   \   \  /    ---`-' |  ,     .-./|  ,   /  ---`-'   `--'---'\  ; \  ; \  ; |
  `----'     `----'             `--`---'     ---`-'                     `--" `--" `--"
 
 */
 
constexpr Pieces::Pieces(const Color color) noexcept
    : pawns { masks::starting::pawns(color) }
    , knights { masks::starting::knights(color) }
    , bishops { masks::starting::bishops(color) }
    , rooks { masks::starting::rooks(color) }
    , queens { masks::starting::queen(color) }
    , king { masks::starting::king(color) }
{
}
 
constexpr void Pieces::refresh_occupied() noexcept
{
    occupied = pawns | knights | bishops | rooks | queens | king;
}
 
constexpr void Pieces::vertical_flip() noexcept
{
    using flips::vertical;
 
    pawns   = vertical(pawns);
    knights = vertical(knights);
    bishops = vertical(bishops);
    rooks   = vertical(rooks);
    queens  = vertical(queens);
    king    = vertical(king);
 
    refresh_occupied();
}
 
constexpr auto Pieces::get_type(const PieceType type) noexcept -> Bitboard&
{
    switch (type) {
        case PieceType::Knight: return knights;
        case PieceType::Bishop: return bishops;
        case PieceType::Rook  : return rooks;
        case PieceType::Queen : return queens;
        case PieceType::King  : return king;
        case PieceType::Pawn  : [[fallthrough]];
        default:
            return pawns;
    }
}
 
constexpr auto Pieces::get_type(const PieceType type) const noexcept -> Bitboard
{
    switch (type) {
        case PieceType::Knight: return knights;
        case PieceType::Bishop: return bishops;
        case PieceType::Rook  : return rooks;
        case PieceType::Queen : return queens;
        case PieceType::King  : return king;
        case PieceType::Pawn  : [[fallthrough]];
        default:
            return pawns;
    }
}
 
constexpr auto Pieces::is_file_half_open(const File file) const noexcept -> bool
{
    return (pawns & masks::files::get(file)).none();
}
 
constexpr auto Pieces::has_bishop_pair() const noexcept -> bool
{
    // NB. can't just check that bishops.count() == 2 because
    // it's possible that we have 2 bishops of the same color
 
    return (bishops & masks::LIGHT_SQUARES).any()
       and (bishops & masks::DARK_SQUARES).any();
}
 
constexpr auto Pieces::get_king_location() const noexcept -> Square
{
    assert(std::cmp_equal(king.count(), 1));
 
    return Square::from_index(king.first());
}
 
constexpr auto Pieces::get_piece_on(const Square square) const noexcept
    -> std::optional<PieceType>
{
    if (not occupied.test(square))
        return std::nullopt;
 
    static constexpr auto allTypes = magic_enum::enum_values<PieceType>();
 
    if (const auto found = std::ranges::find_if(
            allTypes,
            [this, index = square.index()](const PieceType type) {
                return get_type(type).test(index);
            });
        found != allTypes.end()) {
        // we should find a piece unless the occupied bitboard has gotten out of sync
        [[likely]];
 
        return *found;
    }
 
    assert(false);
 
    return std::nullopt;
}
 
constexpr void Pieces::capture_at(const Square square) noexcept
{
    const auto idx = square.index();
 
    // if we're trying to capture the king, then an illegal move has already been played
    assert(not king.test(idx));
 
    pawns.unset(idx);
    knights.unset(idx);
    bishops.unset(idx);
    rooks.unset(idx);
    queens.unset(idx);
 
    occupied.unset(idx);
}
 
constexpr void Pieces::our_move(const moves::Move move, const Color ourColor) noexcept
{
    const auto movementMask = Bitboard::from_square(move.from()) | Bitboard::from_square(move.to());
 
    occupied ^= movementMask;
 
    move.promoted_type()
        .transform([move, this](const PieceType type) {
            get_type(move.piece()).unset(move.from());
            get_type(type).set(move.to());
            return std::monostate { };
        })
        .or_else([move, movementMask, ourColor, this] {
            get_type(move.piece()) ^= movementMask;
 
            if (move.is_castling()) {
                const auto castleMask = move.to().is_queenside()
                                          ? masks::queenside_castle_rook_pos_mask(ourColor)
                                          : masks::kingside_castle_rook_pos_mask(ourColor);
 
                rooks ^= castleMask;
                occupied ^= castleMask;
            }
 
            return std::make_optional(std::monostate { });
        });
}
 
} // namespace chess::board