Square.hpp

Go to the documentation of this file.

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


 
#pragma once
 
#include <cassert>
#include <compare>
#include <cstddef> // IWYU pragma: keep - for size_t
#include <expected>
#include <format>
#include <libchess/board/BitboardIndex.hpp>
#include <libchess/board/File.hpp>
#include <libchess/board/Rank.hpp>
#include <libutil/Math.hpp>
#include <string>
#include <string_view>
#include <utility>

namespace chess::board {

struct Square final {
    File file { File::A };

    Rank rank { Rank::One };

    [[nodiscard, gnu::const]] static constexpr auto from_index(BitboardIndex index) noexcept -> Square;

    [[nodiscard]] static auto from_string(std::string_view text) -> std::expected<Square, std::string>;

    [[nodiscard]] constexpr auto index() const noexcept -> BitboardIndex;

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


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

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

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

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


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

    [[nodiscard]] constexpr auto is_dark() const noexcept -> bool { return not is_light(); }
};


[[nodiscard, gnu::const]] constexpr auto operator<=>(
    const Square& first, const Square& second) noexcept
    -> std::strong_ordering
{
    return first.index() <=> second.index();
}

[[nodiscard, gnu::const]] constexpr auto get_en_passant_captured_square(
    Square targetSquare, bool isWhite) noexcept
    -> Square;

 
} // namespace chess::board

template <>
struct std::formatter<chess::board::Square> final {
    template <typename ParseContext>
    constexpr auto parse(ParseContext& ctx) -> typename ParseContext::iterator
    {
        return ctx.begin();
    }
 
    template <typename FormatContext>
    auto format(
        const chess::board::Square& square, FormatContext& ctx) const
        -> typename FormatContext::iterator
    {
        return std::format_to(ctx.out(), "{}{}", square.file, square.rank);
    }
};
 
/*
                         ___                           ,--,
      ,---,            ,--.'|_                ,--,   ,--.'|
    ,---.'|            |  | :,'             ,--.'|   |  | :
    |   | :            :  : ' :             |  |,    :  : '    .--.--.
    |   | |   ,---.  .;__,'  /    ,--.--.   `--'_    |  ' |   /  /    '
  ,--.__| |  /     \ |  |   |    /       \  ,' ,'|   '  | |  |  :  /`./
 /   ,'   | /    /  |:__,'| :   .--.  .-. | '  | |   |  | :  |  :  ;_
.   '  /  |.    ' / |  '  : |__  \__\/: . . |  | :   '  : |__ \  \    `.
'   ; |:  |'   ;   /|  |  | '.'| ," .--.; | '  : |__ |  | '.'| `----.   \
|   | '/  ''   |  / |  ;  :    ;/  /  ,.  | |  | '.'|;  :    ;/  /`--'  /__  ___  ___
|   :    :||   :    |  |  ,   /;  :   .'   \;  :    ;|  ,   /'--'.     /  .\/  .\/  .\
 \   \  /   \   \  /    ---`-' |  ,     .-./|  ,   /  ---`-'   `--'---'\  ; \  ; \  ; |
  `----'     `----'             `--`---'     ---`-'                     `--" `--" `--"
 
 */
 
namespace chess::board {
 
constexpr auto Square::from_index(const BitboardIndex index) noexcept -> Square
{
    assert(std::cmp_less_equal(index, MAX_BITBOARD_IDX));
 
    return {
        .file = static_cast<File>(index & static_cast<BitboardIndex>(7)),
        .rank = static_cast<Rank>(index >> static_cast<BitboardIndex>(3))
    };
}
 
constexpr auto Square::index() const noexcept -> BitboardIndex
{
    return static_cast<BitboardIndex>(
        (static_cast<int>(rank) << 3) + static_cast<int>(file));
}
 
constexpr auto Square::is_queenside() const noexcept -> bool
{
    return std::cmp_less_equal(
        std::to_underlying(file), std::to_underlying(File::D));
}
 
constexpr auto Square::is_kingside() const noexcept -> bool
{
    return std::cmp_greater_equal(
        std::to_underlying(file), std::to_underlying(File::E));
}
 
constexpr auto Square::is_white_territory() const noexcept -> bool
{
    return std::cmp_less_equal(
        std::to_underlying(rank), std::to_underlying(Rank::Four));
}
 
constexpr auto Square::is_black_territory() const noexcept -> bool
{
    return std::cmp_greater_equal(
        std::to_underlying(rank), std::to_underlying(Rank::Five));
}
 
constexpr auto Square::is_light() const noexcept -> bool
{
    return not util::math::is_even(
        std::to_underlying(rank) + std::to_underlying(file));
}
 
inline auto Square::from_string(const std::string_view text)
    -> std::expected<Square, std::string>
{
    if (std::cmp_not_equal(text.length(), 2)) {
        return std::unexpected {
            std::format(
                "Cannot parse Square from invalid input string: {}",
                text)
        };
    }
 
    return rank_from_char(text.back())
        .and_then([fileChar = text.front()](const Rank rankToUse) {
            return file_from_char(fileChar)
                .transform([rankToUse](const File fileToUse) {
                    return Square {
                        .file = fileToUse,
                        .rank = rankToUse
                    };
                });
        });
}
 
constexpr auto get_en_passant_captured_square(
    const Square targetSquare, const bool isWhite) noexcept
    -> Square
{
    // the captured pawn is on the file of the target square, but
    // one rank below (White capture) or one rank above (Black capture)
    const auto capturedRank = isWhite
                                ? prev_pawn_rank<Color::White>(targetSquare.rank)
                                : prev_pawn_rank<Color::Black>(targetSquare.rank);
 
    return Square {
        .file = targetSquare.file,
        .rank = capturedRank
    };
}
 
} // namespace chess::board