CastlingRights.hpp

Go to the documentation of this file.

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

 
#pragma once
 
#include <libchess/board/File.hpp>
#include <libchess/board/Rank.hpp>
#include <libchess/moves/Move.hpp>
#include <libchess/pieces/Colors.hpp>
#include <libchess/pieces/PieceTypes.hpp>
 
namespace chess::game {
 
using board::File;
using board::Rank;
using moves::Move;
using pieces::Color;
using PieceType = pieces::Type;

struct CastlingRights final {
    bool kingside { true };

    bool queenside { true };

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

    constexpr void king_moved() noexcept;

    constexpr void rook_moved(bool isKingside) noexcept;

    constexpr void our_move(Move move) noexcept;

    template <Color Side>
    constexpr void their_move(Move move) noexcept;

    [[nodiscard]] constexpr auto either() const noexcept -> bool { return kingside or queenside; }

    [[nodiscard]] constexpr auto neither() const noexcept -> bool { return not either(); }
};
 
/*
                         ___                           ,--,
      ,---,            ,--.'|_                ,--,   ,--.'|
    ,---.'|            |  | :,'             ,--.'|   |  | :
    |   | :            :  : ' :             |  |,    :  : '    .--.--.
    |   | |   ,---.  .;__,'  /    ,--.--.   `--'_    |  ' |   /  /    '
  ,--.__| |  /     \ |  |   |    /       \  ,' ,'|   '  | |  |  :  /`./
 /   ,'   | /    /  |:__,'| :   .--.  .-. | '  | |   |  | :  |  :  ;_
.   '  /  |.    ' / |  '  : |__  \__\/: . . |  | :   '  : |__ \  \    `.
'   ; |:  |'   ;   /|  |  | '.'| ," .--.; | '  : |__ |  | '.'| `----.   \
|   | '/  ''   |  / |  ;  :    ;/  /  ,.  | |  | '.'|;  :    ;/  /`--'  /__  ___  ___
|   :    :||   :    |  |  ,   /;  :   .'   \;  :    ;|  ,   /'--'.     /  .\/  .\/  .\
 \   \  /   \   \  /    ---`-' |  ,     .-./|  ,   /  ---`-'   `--'---'\  ; \  ; \  ; |
  `----'     `----'             `--`---'     ---`-'                     `--" `--" `--"
 
 */
 
constexpr void CastlingRights::king_moved() noexcept
{
    kingside  = false;
    queenside = false;
}
 
constexpr void CastlingRights::rook_moved(const bool isKingside) noexcept
{
    // if the rook wasn't already on its starting square, then the castling rights
    // to that side would've already been lost, so we can tell if any rook move
    // should lose castling rights to that side with a simple boolean indicating
    // if the move's from square is on the kingside
 
    kingside  = kingside and not isKingside;
    queenside = queenside and isKingside;
}
 
constexpr void CastlingRights::our_move(const Move move) noexcept
{
    switch (move.piece()) {
        case PieceType::King  : king_moved(); return;
        case PieceType::Rook  : rook_moved(move.from().is_kingside()); return;
        case PieceType::Pawn  : [[fallthrough]];
        case PieceType::Knight: [[fallthrough]];
        case PieceType::Bishop: [[fallthrough]];
        case PieceType::Queen : [[fallthrough]];
        default               : return;
    }
}
 
template <Color Side>
constexpr void CastlingRights::their_move(const Move move) noexcept
{
    // we want to mark castling rights as lost when a rook is captured
    // we simply test if the move's to square is the rook's starting position,
    // since the rook either must've been there (in which case this move is a
    // rook capture), or must've already moved (meaning the rights to that side
    // must've already been lost)
 
    static constexpr auto backRank = board::back_rank_for(Side);
 
    const auto [file, rank] = move.to();
 
    if (rank != backRank)
        return;
 
    kingside  = kingside and (file != File::H);
    queenside = queenside and (file != File::A);
}
 
} // namespace chess::game