cpl_cpp-project/BitBoard.h

#ifndef CHESS_ENGINE_BITBOARD_HPP
#define CHESS_ENGINE_BITBOARD_HPP

#include <cstdint>
#include <ostream>
#include "Square.hpp"

enum DefinedBoards : uint64_t {
    AFile = 0x0101010101010101,
    BFile = AFile << 1,
    CFile = AFile << 2,
    DFile = AFile << 3,
    EFile = AFile << 4,
    FFile = AFile << 5,
    GFile = AFile << 6,
    HFile = AFile << 7,
    WhiteCastlingRank = (1ULL << A2) - 1,
    BlackCastlingRank = (~1ULL << H7),
    CastlingRanks = WhiteCastlingRank | BlackCastlingRank,
    CastlingSquares = (WhiteCastlingRank | BlackCastlingRank) & (CFile | GFile),
};

class BitBoard final {

public:

    using U64 = uint64_t;

    BitBoard(U64 v = 0);

    explicit constexpr operator bool() const {
        return mBoard != 0;
    }
    explicit constexpr operator unsigned long long() const {
        return mBoard;
    }
    operator void *() const {
        return (void *) mBoard;
    }

    // Relational operators
    constexpr bool operator==(const BitBoard &rhs) const;
    constexpr bool operator!=(const BitBoard &rhs) const;
    constexpr bool operator<(const BitBoard &rhs) const;
    constexpr bool operator>(const BitBoard &rhs) const;
    constexpr bool operator<=(const BitBoard &rhs) const;
    constexpr bool operator>=(const BitBoard &rhs) const;

    // Logical operators
    constexpr bool operator!() const;
    constexpr bool operator&&(const BitBoard &rhs) const;
    constexpr bool operator||(const BitBoard &rhs) const;

    // Bitwise operators
    constexpr BitBoard &operator&=(const BitBoard &rhs);
    constexpr BitBoard &operator|=(const BitBoard &rhs);
    constexpr BitBoard &operator^=(const BitBoard &rhs);
    constexpr BitBoard &operator<<=(const BitBoard &rhs);
    constexpr BitBoard &operator>>=(const BitBoard &rhs);
    BitBoard operator~() const {
        BitBoard result(*this);
        result.mBoard = ~mBoard;
        return result;
    }
    friend BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs);
    friend BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs);
    friend BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs);
    friend BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs);
    friend BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs);

    // Arithmetic operators
    constexpr BitBoard &operator+=(const BitBoard &rhs);
    constexpr BitBoard &operator-=(const BitBoard &rhs);
    constexpr BitBoard &operator%=(const BitBoard &rhs);
    friend BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs);
    friend BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs);
    friend BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs);

    // Stream operator
    friend std::ostream &operator<<(std::ostream &os, const BitBoard &board);

    constexpr void clear(unsigned i);
    constexpr void set(unsigned i);

    BitBoard left(unsigned i) const;
    BitBoard right(unsigned i) const;

    static BitBoard fromIndex(unsigned i);

    static BitBoard getRank(int r);

    // Returns the number of trailing 0-bits in b.
    // WARN: Check for 0!
    int lsb() const;

private:
    U64 mBoard = {};

    static BitBoard genShift(BitBoard x, int s);
};

// Relational operators
constexpr bool BitBoard::operator==(const BitBoard &rhs) const {
    return mBoard == rhs.mBoard;
}
constexpr bool BitBoard::operator!=(const BitBoard &rhs) const {
    return !(rhs == *this);
}
constexpr bool BitBoard::operator<(const BitBoard &rhs) const {
    return mBoard < rhs.mBoard;
}
constexpr bool BitBoard::operator>(const BitBoard &rhs) const {
    return rhs < *this;
}
constexpr bool BitBoard::operator<=(const BitBoard &rhs) const {
    return !(rhs < *this);
}
constexpr bool BitBoard::operator>=(const BitBoard &rhs) const {
    return !(*this < rhs);
}

// Logical operators
constexpr bool BitBoard::operator!() const {
    return !mBoard;
}
constexpr bool BitBoard::operator&&(const BitBoard &rhs) const {
    return mBoard && rhs.mBoard;
}
constexpr bool BitBoard::operator||(const BitBoard &rhs) const {
    return mBoard || rhs.mBoard;
}

// Bitwise operators
constexpr BitBoard &BitBoard::operator&=(const BitBoard &rhs) {
    mBoard &= rhs.mBoard;
    return *this;
}
constexpr BitBoard &BitBoard::operator|=(const BitBoard &rhs) {
    mBoard |= rhs.mBoard;
    return *this;
}
constexpr BitBoard &BitBoard::operator^=(const BitBoard &rhs) {
    mBoard ^= rhs.mBoard;
    return *this;
}
constexpr BitBoard &BitBoard::operator<<=(const BitBoard &rhs) {
    mBoard <<= rhs.mBoard;
    return *this;
}
constexpr BitBoard &BitBoard::operator>>=(const BitBoard &rhs) {
    mBoard >>= rhs.mBoard;
    return *this;
}
inline BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result ^= rhs;
    return result;
}
inline BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result |= rhs;
    return result;
}
inline BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result &= rhs;
    return result;
}
inline BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result <<= rhs;
    return result;
}
inline BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result >>= rhs;
    return result;
}

// Arithmetic operators
constexpr BitBoard &BitBoard::operator+=(const BitBoard &rhs) {
    mBoard += rhs.mBoard;
    return *this;
}
constexpr BitBoard &BitBoard::operator-=(const BitBoard &rhs) {
    mBoard -= rhs.mBoard;
    return *this;
}
constexpr BitBoard &BitBoard::operator%=(const BitBoard &rhs) {
    mBoard %= rhs.mBoard;
    return *this;
}
inline BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result += rhs;
    return result;
}
inline BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result -= rhs;
    return result;
}
inline BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs) {
    BitBoard result(lhs);
    result %= rhs;
    return result;
}

constexpr void BitBoard::set(const unsigned i) {
    mBoard |= (1ULL << i);
}
constexpr void BitBoard::clear(const unsigned i) {
    mBoard &= ~(1ULL << i);
}
inline BitBoard BitBoard::fromIndex(const unsigned i) {
    return 1ULL << i;
}
inline BitBoard BitBoard::left(const unsigned int i) const {
    return (mBoard >> i);
}
inline BitBoard BitBoard::right(const unsigned int i) const {
    return (mBoard << i);
}
inline int BitBoard::lsb() const {
    return __builtin_ctzll(mBoard);
}

#endif //CHESS_ENGINE_BITBOARD_HPP