[MoveGenerator] Add generateAttackedSquares, fix castling

BitBoard.cpp

@@ -46,7 +46,7 @@ BitBoard BitBoard::fileFill() const {
     return northFill() | southFill();
 }
 
-BitBoard BitBoard::kingAttacks(const BitBoard kings) {
+BitBoard BitBoard::kingMoves(const BitBoard kings) {
     BitBoard result = kings.east() | kings.west() | kings;
     result |= (result.north() | result.south());
     result ^= kings;
@@ -58,13 +58,10 @@ BitBoard BitBoard::castlingMoves(BitBoard kings, BitBoard rooks, BitBoard empty)
     kings |= (kings.east() | kings.west()) & empty;
     kings |= (kings.east() | kings.west()) & empty;
     kings |= kings.west() & empty;
-    std::cout << "rooks1" << std::endl << rooks;
     rooks |= (rooks.east() | rooks.west()) & empty;
     rooks |= (rooks.east() | rooks.west()) & empty;
     rooks |= (rooks.east()) & empty;
 
-    std::cout << "rooks2" << std::endl << rooks;
-
     return kings & rooks & CastlingSquares;
 }
 
@@ -102,7 +99,7 @@ BitBoard BitBoard::queenAttacks(BitBoard queens, BitBoard empty) {
     return rookAttacks(queens, empty) | bishopAttacks(queens, empty);
 }
 
-BitBoard BitBoard::knightAttacks(BitBoard knights) {
+BitBoard BitBoard::knightMoves(BitBoard knights) {
     BitBoard east, west, result;
 
     east = knights.east();

BitBoard.hpp

@@ -109,9 +109,9 @@ public:
     static BitBoard bishopAttacks(BitBoard pos, BitBoard empty);
     static BitBoard rookAttacks(BitBoard rooks, BitBoard empty);
     static BitBoard queenAttacks(BitBoard queens, BitBoard empty);
-    static BitBoard kingAttacks(BitBoard kings);
+    static BitBoard kingMoves(const BitBoard kings);
     static BitBoard castlingMoves(BitBoard kings, BitBoard rooks, BitBoard empty);
-    static BitBoard knightAttacks(BitBoard knights);
+    static BitBoard knightMoves(BitBoard knights);
 
     static BitBoard pawnNorthAttacks(BitBoard pawns, BitBoard targets);
     static BitBoard pawnSouthAttacks(BitBoard pawns, BitBoard targets);

MoveGenerator.cpp

@@ -59,7 +59,7 @@ void MoveGenerator::generateMovesWithPromotion(const Square &from, BitBoard move
 }
 void MoveGenerator::generateKingMoves(const BoardState &bs, const Square &from, MoveGenerator::MoveVec &moves) {
     auto fromBB = BitBoard::fromIndex(from.index());
-    auto movesBB = BitBoard::kingAttacks(fromBB) & ~(*bs.pieceBBs)[Board::toIndex(bs.turn)];
+    auto movesBB = BitBoard::kingMoves(fromBB) & ~(*bs.pieceBBs)[Board::toIndex(bs.turn)];
 
     if ((bs.cr & CastlingRights::All) != CastlingRights::None) {
 
@@ -74,18 +74,16 @@ void MoveGenerator::generateKingMoves(const BoardState &bs, const Square &from,
 
         if (checkCR != CastlingRights::None) {
             // Generate attacked squares
-//            auto opponentBB = (*bs.pieceBBs)[Board::toIndex(!color)];
+            BitBoard target = CastlingRanks | bs.occupiedBB;
-//            BitBoard target = CastlingRanks | bs.occupiedBB;
+            auto attacked = generateAttackedSquares(bs, target, !bs.turn);
-//            // pawns
-//            BitBoard attacked = 0;
-//            if (!color == PieceColor::White) {
-//                attacked |= BitBoard::pawnNorthAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Pawn)] & opponentBB, target);
-//            } else {
-//                attacked |= BitBoard::pawnSouthAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Pawn)] & opponentBB, target);
-//            }
 
-            movesBB |= BitBoard::castlingMoves(fromBB, (*bs.pieceBBs)[Board::toIndex(PieceType::Rook)], ~bs.occupiedBB)
+            std::cout << "attacked\n" << attacked;
-                    & castlingRank;// & ~attacked;
+
+            movesBB |= BitBoard::castlingMoves(fromBB & ~attacked,
+                                               (*bs.pieceBBs)[Board::toIndex(PieceType::Rook)],
+                                               ~bs.occupiedBB)
+                    & castlingRank;
+            std::cout << "moves\n" << movesBB;
 
             if ((checkCR & CastlingRights::KingSide) == CastlingRights::None) {
                 movesBB &= ~GFile;
@@ -116,20 +114,35 @@ void MoveGenerator::generateQueenMoves(const BoardState &bs, const Square &from,
 void MoveGenerator::generateKnightMoves(const BoardState &bs, const Square &from, MoveVec &moves) {
 
     auto fromBB = BitBoard::fromIndex(from.index());
-    auto movesBB = BitBoard::knightAttacks(fromBB) & ~(*bs.pieceBBs)[Board::toIndex(bs.turn)];
+    auto movesBB = BitBoard::knightMoves(fromBB) & ~(*bs.pieceBBs)[Board::toIndex(bs.turn)];
     generateMoves(from, movesBB, moves);
 }
 
-//BitBoard MoveGenerator::generateAttackedSquares(const BoardState &bs, BitBoard target, PieceColor opColor) const {
+BitBoard MoveGenerator::generateAttackedSquares(const BoardState &bs, BitBoard target, PieceColor opColor) {
-//    auto opponentBB = (*bs.pieceBBs)[Board::toIndex(opColor)];
+    auto opponentBB = (*bs.pieceBBs)[Board::toIndex(opColor)];
-//
+    BitBoard attacked = 0;
-//    BitBoard attacked = 0;
+
-//
+    // pawns
-//    // pawns
+    if (opColor == PieceColor::White) {
-//    if (opColor == PieceColor::White) {
+        attacked |= BitBoard::pawnNorthAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Pawn)] & opponentBB, target);
-//        attacked |= BitBoard::pawnNorthAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Pawn)] & opponentBB, target);
+    } else {
-//    } else {
+        attacked |= BitBoard::pawnSouthAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Pawn)] & opponentBB, target);
-//        attacked |= BitBoard::pawnSouthAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Pawn)] & opponentBB, target);
+    }
-//    }
+
-//
+    // knights
-//}
+    attacked |= BitBoard::knightMoves((*bs.pieceBBs)[Board::toIndex(PieceType::Knight)] & opponentBB) & target;
+
+    // Bishop
+    attacked |= BitBoard::bishopAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Bishop)] & opponentBB, target);
+
+    // Rook
+    attacked |= BitBoard::rookAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Rook)] & opponentBB, target);
+
+    // Queen
+    attacked |= BitBoard::queenAttacks((*bs.pieceBBs)[Board::toIndex(PieceType::Queen)] & opponentBB, target);
+
+    // King
+    attacked |= BitBoard::kingMoves((*bs.pieceBBs)[Board::toIndex(PieceType::Queen)] & opponentBB) & target;
+
+    return attacked;
+}

MoveGenerator.hpp

@@ -29,6 +29,7 @@ private:
 
     static void generateMoves(const Square &from, BitBoard movesBB, MoveVec &moves);
     static void generateMovesWithPromotion(const Square &from, BitBoard movesBB, MoveVec &moves);
+    static BitBoard generateAttackedSquares(const BoardState &bs, BitBoard target, PieceColor opColor);
 };
 
 #endif //CHESS_ENGINE_MOVEGENERATOR_HPP

Tests/BitBoardTest.cpp

@@ -11,7 +11,7 @@ TEST_CASE("King attacks are correctly generated", "[Board][Fundamental]") {
     auto board = BitBoard::fromIndex(G2);
     board |= BitBoard::fromIndex(B7);
 
-    BitBoard ka = BitBoard::kingAttacks(board);
+    BitBoard ka = BitBoard::kingMoves(board);
     REQUIRE((ka == (
             BitBoard::fromIndex(G1) | BitBoard::fromIndex(G3) | BitBoard::fromIndex(H1) | BitBoard::fromIndex(H2)
                     | BitBoard::fromIndex(H3) | BitBoard::fromIndex(F1) | BitBoard::fromIndex(F2)