Refactor BitBoard

BitBoard.cpp

@@ -0,0 +1,180 @@
+#include <iostream>
+#include "BitBoard.h"
+
+//BitBoard::BitBoard() {
+//    mBoard = 0;
+//}
+
+BitBoard::BitBoard(uint64_t v) {
+    mBoard = v;
+}
+
+BitBoard::operator bool() const {
+    return mBoard != 0;
+}
+
+BitBoard::operator unsigned long long() const {
+    return mBoard;
+}
+
+bool BitBoard::operator==(const BitBoard &rhs) const {
+    return mBoard == rhs.mBoard;
+}
+
+bool BitBoard::operator!=(const BitBoard &rhs) const {
+    return !(rhs == *this);
+}
+
+bool BitBoard::operator<(const BitBoard &rhs) const {
+    return mBoard < rhs.mBoard;
+}
+
+bool BitBoard::operator>(const BitBoard &rhs) const {
+    return rhs < *this;
+}
+
+bool BitBoard::operator<=(const BitBoard &rhs) const {
+    return !(rhs < *this);
+}
+
+bool BitBoard::operator>=(const BitBoard &rhs) const {
+    return !(*this < rhs);
+}
+
+BitBoard &BitBoard::operator&=(const BitBoard &rhs) {
+    mBoard &= rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator|=(const BitBoard &rhs) {
+    mBoard |= rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator^=(const BitBoard &rhs) {
+    mBoard ^= rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator<<=(const BitBoard &rhs) {
+    mBoard <<= rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator>>=(const BitBoard &rhs) {
+    mBoard >>= rhs.mBoard;
+    return *this;
+}
+
+BitBoard BitBoard::operator~() {
+    BitBoard result(*this);
+    result.mBoard = ~mBoard;
+    return result;
+}
+
+BitBoard &BitBoard::operator+=(const BitBoard &rhs) {
+    mBoard += rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator-=(const BitBoard &rhs) {
+    mBoard -= rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator*=(const BitBoard &rhs) {
+    mBoard *= rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator/=(const BitBoard &rhs) {
+    mBoard /= rhs.mBoard;
+    return *this;
+}
+
+BitBoard &BitBoard::operator%=(const BitBoard &rhs) {
+    mBoard %= rhs.mBoard;
+    return *this;
+}
+
+std::ostream &operator<<(std::ostream &os, const BitBoard &board) {
+    // For debugging only, performance isn't important
+    for (int i = 7; i >= 0; i--) {
+        int rank = i * 8;
+        for (int j = 0; j < 8; j++) {
+            // Get the piece for this index. Assume it exists.
+            // Print piece, otherwise '.';
+            if (board.mBoard & (1ULL << (rank + j))) {
+                os << 1;
+            } else {
+                os << '.';
+            }
+
+            os << ' ';
+        }
+        os << '\n';
+    }
+
+    return os;
+}
+bool BitBoard::operator!() const {
+    return !mBoard;
+}
+
+bool BitBoard::operator&&(const BitBoard &rhs) const {
+    return mBoard && rhs.mBoard;
+}
+
+bool BitBoard::operator||(const BitBoard &rhs) const {
+    return mBoard || rhs.mBoard;
+}
+BitBoard::operator void *() const {
+    return (void *) mBoard;
+}
+
+BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result &= rhs;
+    return result;
+}
+
+BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result |= rhs;
+    return result;
+}
+
+BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result ^= rhs;
+    return result;
+}
+BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result <<= rhs;
+    return result;
+}
+
+BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result >>= rhs;
+    return result;
+}
+
+BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result -= rhs;
+    return result;
+}
+
+BitBoard operator*(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result *= rhs;
+    return result;
+}
+
+BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result %= rhs;
+    return result;
+}

BitBoard.h

@@ -0,0 +1,64 @@
+#ifndef CHESS_ENGINE_BITBOARD_HPP
+#define CHESS_ENGINE_BITBOARD_HPP
+
+#include <cstdint>
+#include <ostream>
+#include "CastlingRights.hpp"
+
+class BitBoard final {
+public:
+    using U64 = uint64_t;
+
+    BitBoard(uint64_t v = 0);
+
+//    explicit operator uint64_t() const;
+    explicit operator bool() const;
+    explicit operator unsigned long long() const;
+    operator void*() const;
+
+    bool operator==(const BitBoard &rhs) const;
+    bool operator!=(const BitBoard &rhs) const;
+    bool operator<(const BitBoard &rhs) const;
+    bool operator>(const BitBoard &rhs) const;
+    bool operator<=(const BitBoard &rhs) const;
+    bool operator>=(const BitBoard &rhs) const;
+
+    // bitset operations
+    BitBoard &operator&=(const BitBoard &rhs);
+    BitBoard &operator|=(const BitBoard &rhs);
+    BitBoard &operator^=(const BitBoard &rhs);
+    BitBoard &operator<<=(const BitBoard &rhs);
+    BitBoard &operator>>=(const BitBoard &rhs);
+    BitBoard operator~();
+
+    bool operator!() const;
+    bool operator&&(const BitBoard &rhs) const;
+    bool operator||(const BitBoard &rhs) const;
+
+    BitBoard &operator+=(const BitBoard &rhs);
+    BitBoard &operator-=(const BitBoard &rhs);
+    BitBoard &operator*=(const BitBoard &rhs);
+    BitBoard &operator/=(const BitBoard &rhs);
+    BitBoard &operator%=(const BitBoard &rhs);
+
+    friend std::ostream &operator<<(std::ostream &os, const BitBoard &board);
+//    friend bool operator&&(const bool &lhs, const BitBoard &rhs);
+
+private:
+    U64 mBoard = {};
+
+};
+
+
+BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs);
+BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs);
+BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs);
+BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs);
+BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs);
+BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs);
+BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs);
+//BitBoard operator*(const BitBoard &lhs, const BitBoard &rhs);
+//BitBoard operator/(const BitBoard &lhs, const BitBoard &rhs);
+BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs);
+
+#endif //CHESS_ENGINE_BITBOARD_HPP

Board.cpp

@@ -196,25 +196,7 @@ bool Board::isMoveCastling(const BitBoard &from, const BitBoard &to, const Piece
         return (from & indexToBitBoard(E1));
     }
 
-    return (from & indexToBitBoard(E8));
-}
-void Board::printBitBoard(const Board::BitBoard &bb) {
-    // For debugging only, performance isn't important
-    for (int i = 7; i >= 0; i--) {
-        int rank = i * 8;
-        for (int j = 0; j < 8; j++) {
-            // Get the piece for this index. Assume it exists.
-            // Print piece, otherwise '.';
-            if (bb & (1ULL << (rank + j))) {
-                std::cout << 1;
-            } else {
-                std::cout << '.';
-            }
-
-            std::cout << ' ';
-        }
-        std::cout << '\n';
-    }
+    return from & indexToBitBoard(E8);
 }
 
 std::ostream &operator<<(std::ostream &os, const Board &board) {

Board.hpp

@@ -5,6 +5,7 @@
 #include "Square.hpp"
 #include "Move.hpp"
 #include "CastlingRights.hpp"
+#include "BitBoard.h"
 
 #include <optional>
 #include <iosfwd>
@@ -22,8 +23,6 @@ public:
     using Optional = std::optional<Board>;
     using MoveVec = std::vector<Move>;
 
-    using BitBoard = uint64_t;
-
     Board();
 
     void setPiece(const Square &square, const Piece::Optional &piece);
@@ -49,7 +48,7 @@ private:
     CastlingRights mCR = CastlingRights::None;
     std::optional<Square> mEPS;
 
-    enum DefinedBoards : BitBoard {
+    enum DefinedBoards : uint64_t {
         AFile = 0x0101010101010101,
         BFile = AFile << 1,
         CFile = AFile << 2,
@@ -124,10 +123,9 @@ private:
     // Returns the number of trailing 0-bits in b.
     // WARN: Check for 0!
     static inline int getLSB(const BitBoard b) {
-        return __builtin_ctzll(b);
+        return __builtin_ctzll(static_cast<unsigned long long>(b));
     }
 
-    static void printBitBoard(const BitBoard &bb);
     void handlePawnDoubleAdvance(const Move &move, BitBoard bb, const Piece &movedPiece);
     void handleEnPassant(const Move &move, const Piece &movedPiece);
 };

CMakeLists.txt

@@ -35,6 +35,7 @@ add_library(cplchess_lib OBJECT
     Engine.cpp
     EngineFactory.cpp
     Uci.cpp
+    BitBoard.cpp
 )
 
 target_include_directories(cplchess_lib PUBLIC .)