Masks.hpp

Go to the documentation of this file.

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


 
#pragma once
 
#include <cstddef> // IWYU pragma: keep - for size_t
#include <libchess/board/Bitboard.hpp>
#include <libchess/board/File.hpp>
#include <libchess/board/Rank.hpp>
#include <libchess/board/Square.hpp>
#include <libchess/pieces/Colors.hpp>
#include <utility>

namespace chess::board::masks {
 
using pieces::Color;
using std::size_t;
 
using namespace board::literals; // NOLINT(build/namespaces_literals)


inline constexpr auto ALL = 0XFFFFFFFFFFFFFFFF_bb;

inline constexpr auto NONE = 0X0_bb;

inline constexpr auto DARK_SQUARES = 0xAA55AA55AA55AA55_bb;

inline constexpr auto LIGHT_SQUARES = 0x55AA55AA55AA55AA_bb;

inline constexpr auto MAIN_DIAGONAL = 0x8040201008040201_bb;

inline constexpr auto MAIN_ANTIDIAGONAL = 0x0102040810204080_bb;

inline constexpr auto CENTER = 0X1818000000_bb;

inline constexpr auto PERIMETER = 0XFF818181818181FF_bb;

[[nodiscard, gnu::const]] constexpr auto diagonal(const Square& square) noexcept -> Bitboard
{
    const auto diag = static_cast<int>(square.file) - static_cast<int>(square.rank);
 
    if (std::cmp_greater_equal(diag, 0))
        return MAIN_DIAGONAL >> static_cast<size_t>(diag) * 8uz;
 
    return MAIN_DIAGONAL << static_cast<size_t>(-diag) * 8uz;
}

[[nodiscard, gnu::const]] constexpr auto antidiagonal(const Square& square) noexcept -> Bitboard
{
    const auto diag = 7 - static_cast<int>(square.file) - static_cast<int>(square.rank);
 
    if (std::cmp_greater_equal(diag, 0))
        return MAIN_ANTIDIAGONAL >> static_cast<size_t>(diag) * 8uz;
 
    return MAIN_ANTIDIAGONAL << static_cast<size_t>(-diag) * 8uz;
}

[[nodiscard, gnu::const]] constexpr auto queenside_castle_rook_pos_mask(
    const Color side) noexcept -> Bitboard
{
    const auto rank = back_rank_for(side);
 
    Bitboard mask;
 
    mask.set(Square { .file = File::A, .rank = rank });
    mask.set(Square { .file = File::D, .rank = rank });
 
    return mask;
}

[[nodiscard, gnu::const]] constexpr auto kingside_castle_rook_pos_mask(
    const Color side) noexcept -> Bitboard
{
    const auto rank = back_rank_for(side);
 
    Bitboard mask;
 
    mask.set(Square { .file = File::H, .rank = rank });
    mask.set(Square { .file = File::F, .rank = rank });
 
    return mask;
}


namespace files {

 
    // NOLINTBEGIN(readability-identifier-length)

    inline constexpr auto A = 0x0101010101010101_bb;

    inline constexpr auto B = 0X202020202020202_bb;

    inline constexpr auto C = 0X404040404040404_bb;

    inline constexpr auto D = 0X808080808080808_bb;

    inline constexpr auto E = 0X1010101010101010_bb;

    inline constexpr auto F = 0X2020202020202020_bb;

    inline constexpr auto G = 0X4040404040404040_bb;

    inline constexpr auto H = 0x8080808080808080_bb;
 
    // NOLINTEND(readability-identifier-length)

    [[nodiscard, gnu::const]] constexpr auto get(const File file) noexcept -> Bitboard
    {
        return A << static_cast<size_t>(file);
    }

 
} // namespace files

namespace ranks {


    inline constexpr auto ONE = 0x00000000000000FF_bb;

    inline constexpr auto TWO = 0XFF00_bb;

    inline constexpr auto THREE = 0XFF0000_bb;

    inline constexpr auto FOUR = 0XFF000000_bb;

    inline constexpr auto FIVE = 0XFF00000000_bb;

    inline constexpr auto SIX = 0XFF0000000000_bb;

    inline constexpr auto SEVEN = 0XFF000000000000_bb;

    inline constexpr auto EIGHT = 0xFF00000000000000_bb;

    [[nodiscard, gnu::const]] constexpr auto get(const Rank rank) noexcept -> Bitboard
    {
        return ONE << (8uz * std::to_underlying(rank));
    }

 
} // namespace ranks

namespace starting {

    namespace white {


        inline constexpr auto PAWNS = ranks::TWO;

        inline constexpr auto ROOKS = 0X81_bb;

        inline constexpr auto KNIGHTS = 0X42_bb;

        inline constexpr auto BISHOPS = 0X24_bb;

        inline constexpr auto QUEEN = 0X8_bb;

        inline constexpr auto KING = 0X10_bb;

 
    } // namespace white

    namespace black {


        inline constexpr auto PAWNS = ranks::SEVEN;

        inline constexpr auto ROOKS = 0X8100000000000000_bb;

        inline constexpr auto KNIGHTS = 0X4200000000000000_bb;

        inline constexpr auto BISHOPS = 0X2400000000000000_bb;

        inline constexpr auto QUEEN = 0X800000000000000_bb;

        inline constexpr auto KING = 0X1000000000000000_bb;

 
    } // namespace black


    [[nodiscard, gnu::const]] constexpr auto pawns(const Color color) noexcept -> Bitboard
    {
        if (color == Color::White)
            return white::PAWNS;
 
        return black::PAWNS;
    }

    [[nodiscard, gnu::const]] constexpr auto rooks(const Color color) noexcept -> Bitboard
    {
        if (color == Color::White)
            return white::ROOKS;
 
        return black::ROOKS;
    }

    [[nodiscard, gnu::const]] constexpr auto knights(const Color color) noexcept -> Bitboard
    {
        if (color == Color::White)
            return white::KNIGHTS;
 
        return black::KNIGHTS;
    }

    [[nodiscard, gnu::const]] constexpr auto bishops(const Color color) noexcept -> Bitboard
    {
        if (color == Color::White)
            return white::BISHOPS;
 
        return black::BISHOPS;
    }

    [[nodiscard, gnu::const]] constexpr auto queen(const Color color) noexcept -> Bitboard
    {
        if (color == Color::White)
            return white::QUEEN;
 
        return black::QUEEN;
    }

    [[nodiscard, gnu::const]] constexpr auto king(const Color color) noexcept -> Bitboard
    {
        if (color == Color::White)
            return white::KING;
 
        return black::KING;
    }

 
} // namespace starting
 
} // namespace chess::board::masks