Fix Pawn Move Generation from last commit

ChessAndroid/app/src/main/cpp/Main.cpp

@@ -306,4 +306,6 @@ Java_net_theluckycoder_chess_Native_perft(JNIEnv */*pEnv*/, jclass /*type*/, jin
 		if (nodesCount != perftResults[i])
 			LOGE(TAG, "Nodes count do not match at depth %d", i);
 	}
+
+	LOGV(TAG, "Test Finished");
 }

ChessAndroid/app/src/main/cpp/chess/algorithm/Evaluation.cpp

@@ -344,7 +344,7 @@ Score Evaluation::evaluateQueen(const Piece &piece, const byte square, const Boa
 				Pos dPos(pos, d * ix, d * iy);
 				if (dPos.isValid())
 				{
-					const Piece &other = board[dPos];
+					const Piece &other = board.getPiece(dPos.toSquare());
 					if (other.type == ROOK && (ix == 0 || iy == 0) && count == 1) return true;
 					if (other.type == BISHOP && (ix != 0 && iy != 0) && count == 1) return true;
 					if (other) count++;

ChessAndroid/app/src/main/cpp/chess/algorithm/MoveGen.inl

@@ -18,16 +18,19 @@ U64 MoveGen<T>::generatePawnMoves(const Piece &piece, const byte square, const B
 
 		if (board.enPassantSq < 64u)
 		{
-			Pos capturedPos(board.enPassantSq);
-			capturedPos.y += static_cast<byte>(piece.color ? -1 : 1);
-			// Keep the en-passant capture if it intersect with one of our potential attacks
-			if (attacks & Bitboard::shiftedBoards[capturedPos.toSquare()])
-				captures |= Bitboard::shiftedBoards[board.enPassantSq];
+			const U64 enPassant = shiftedBoards[board.enPassantSq];
+			const U64 capturedPawn = piece.color ? shift<SOUTH>(enPassant) : shift<NORTH>(enPassant);
+
+			if (board.getType(~piece.color, PAWN) & capturedPawn)
+			{
+				// Keep the en-passant capture if it intersect with one of our potential attacks
+				captures |= attacks & enPassant;
+			}
 		}
 
 		attacks = captures;
 	}
-	else if (T == ATTACKS_DEFENSES)
+	else if constexpr (T == ATTACKS_DEFENSES)
 		attacks &= board.occupied;
 
 	if constexpr (T == ALL)
@@ -42,10 +45,10 @@ U64 MoveGen<T>::generatePawnMoves(const Piece &piece, const byte square, const B
 			const U64 initialRank = piece.color ? RANK_2 : RANK_7;
 			if (initialRank & bitboard)
 			{
-				const U64 doubleMove = piece.color ? shift<NORTH>(bitboard) : shift<SOUTH>(bitboard);
+				const U64 doubleMove = piece.color ? shift<NORTH>(move) : shift<SOUTH>(move);
 
 				if (!(board.occupied & doubleMove))
-					attacks |= move;
+					attacks |= doubleMove;
 			}
 		}
 	}
@@ -60,9 +63,9 @@ U64 MoveGen<T>::generateKnightMoves(const Piece &piece, const byte square, const
 
 	if constexpr (T == ALL)
 		attacks &= ~board.allPieces[piece.color]; // Remove our pieces
-	else if (T == CAPTURES)
+	else if constexpr (T == CAPTURES)
 		attacks &= board.allPieces[~piece.color]; // Keep only their pieces
-	else if (T == ATTACKS_DEFENSES)
+	else if constexpr (T == ATTACKS_DEFENSES)
 		attacks &= board.occupied; // Keep only the pieces
 
 	return attacks;
@@ -75,9 +78,9 @@ U64 MoveGen<T>::generateBishopMoves(const Piece &piece, const byte square, const
 
 	if constexpr (T == ALL)
 		attacks &= ~board.allPieces[piece.color]; // Remove our pieces
-	else if (T == CAPTURES)
+	else if constexpr (T == CAPTURES)
 		attacks &= board.allPieces[~piece.color]; // Keep only their pieces
-	else if (T == ATTACKS_DEFENSES)
+	else if constexpr (T == ATTACKS_DEFENSES)
 		attacks &= board.occupied; // Keep only the pieces
 
 	return attacks;
@@ -90,9 +93,9 @@ U64 MoveGen<T>::generateRookMoves(const Piece &piece, const byte square, const B
 
 	if constexpr (T == ALL)
 		attacks &= ~board.allPieces[piece.color]; // Remove our pieces
-	else if (T == CAPTURES)
+	else if constexpr (T == CAPTURES)
 		attacks &= board.allPieces[~piece.color]; // Keep only their pieces
-	else if (T == ATTACKS_DEFENSES)
+	else if constexpr (T == ATTACKS_DEFENSES)
 		attacks &= board.occupied; // Keep only the pieces
 
 	return attacks;
@@ -106,9 +109,9 @@ U64 MoveGen<T>::generateQueenMoves(const Piece &piece, const byte square, const
 
 	if constexpr (T == ALL)
 		attacks &= ~board.allPieces[piece.color]; // Remove our pieces
-	else if (T == CAPTURES)
+	else if constexpr (T == CAPTURES)
 		attacks &= board.allPieces[~piece.color]; // Keep only their pieces
-	else if (T == ATTACKS_DEFENSES)
+	else if constexpr (T == ATTACKS_DEFENSES)
 		attacks &= board.occupied; // Keep only the pieces
 
 	return attacks;
@@ -121,9 +124,9 @@ U64 MoveGen<T>::generateKingMoves(const Piece &piece, const byte square, const B
 
 	if constexpr (T == ALL)
 		attacks &= ~board.allPieces[piece.color]; // Remove our pieces
-	else if (T == CAPTURES)
+	else if constexpr (T == CAPTURES)
 		attacks &= board.allPieces[~piece.color]; // Keep only their pieces
-	else if (T == ATTACKS_DEFENSES)
+	else if constexpr (T == ATTACKS_DEFENSES)
 		attacks &= board.occupied; // Keep only the pieces
 
 	if constexpr (T == CAPTURES || T == ATTACKS_DEFENSES)

ChessAndroid/app/src/main/cpp/chess/algorithm/PieceAttacks.cpp

@@ -65,9 +65,9 @@ constexpr std::array<U64, 64> rookMagics = {
  */
 constexpr auto bishopMasks = [] {
 	using namespace Bitboard;
-	
+
 	const U64 edgeSquares = FILE_A | FILE_H | RANK_1 | RANK_8;
-	std::array<U64, 64> masks{};
+	std::array<U64, SQUARE_NB> masks{};
 
 	for (byte square = 0u; square < SQUARE_NB; ++square)
 	{
@@ -83,7 +83,7 @@ constexpr auto bishopMasks = [] {
 constexpr auto rookMasks = [] {
 	using namespace Bitboard;
 
-	std::array<U64, 64> masks{};
+	std::array<U64, SQUARE_NB> masks{};
 
 	for (byte square = 0u; square < 64u; ++square)
 	{
@@ -129,7 +129,6 @@ U64 getRayAttacksBackwards(const byte square, const U64 occupied, const Dir dire
 
 U64 generateBishopAttacks(const byte square, const U64 blockers) noexcept
 {
-	using namespace Bitboard;
 	return getRayAttacksForwards(square, blockers, NORTH_WEST)
 		   | getRayAttacksForwards(square, blockers, NORTH_EAST)
 		   | getRayAttacksBackwards(square, blockers, SOUTH_EAST)
@@ -138,44 +137,23 @@ U64 generateBishopAttacks(const byte square, const U64 blockers) noexcept
 
 U64 generateRookAttacks(const byte square, const U64 blockers) noexcept
 {
-	using namespace Bitboard;
 	return getRayAttacksForwards(square, blockers, NORTH)
 		   | getRayAttacksForwards(square, blockers, EAST)
 		   | getRayAttacksBackwards(square, blockers, SOUTH)
 		   | getRayAttacksBackwards(square, blockers, WEST);
 }
 
 const std::array<std::array<U64, 64>, 2> PieceAttacks::s_PawnAttacks = [] {
+	using namespace Bitboard;
 	std::array<std::array<U64, 64>, 2> moves{};
 
-	for (byte i = 0u; i < 64u; i++)
+	for (byte i = 0u; i < SQUARE_NB; i++)
 	{
-		const Pos start(i);
-
-		U64 whiteAttackBb{};
-		{
-			const Pos leftPos = start + Pos(-1, 1u);
-			const Pos rightPos = start + Pos(1u, 1u);
-
-			if (leftPos.isValid())
-				whiteAttackBb |= leftPos.toBitboard();
-			if (rightPos.isValid())
-				whiteAttackBb |= rightPos.toBitboard();
-		}
-
-		U64 blackAttackBb{};
-		{
-			const Pos leftPos = start + Pos(-1, -1);
-			const Pos rightPos = start + Pos(1u, -1);
-
-			if (leftPos.isValid())
-				blackAttackBb |= leftPos.toBitboard();
-			if (rightPos.isValid())
-				blackAttackBb |= rightPos.toBitboard();
-		}
+		const U64 bb = shiftedBoards[i];
+		const U64 attacks = shift<EAST>(bb) | shift<WEST>(bb);
 
-	    moves[true][i] = whiteAttackBb;
-	    moves[false][i] = blackAttackBb;
+	    moves[true][i] = shift<NORTH>(attacks);
+	    moves[false][i] = shift<SOUTH>(attacks);
 	}
 
 	return moves;
@@ -191,7 +169,7 @@ const std::array<U64, 64> PieceAttacks::s_KnightAttacks = [] {
 			moves[startSquare] |= pos.toBitboard();
 	};
 
-	for (byte i = 0u; i < 64u; i++)
+	for (byte i = 0u; i < SQUARE_NB; i++)
 	{
 		addAttack(i, -2, -1);
 		addAttack(i, -2, 1u);
@@ -214,28 +192,21 @@ std::array<std::array<U64, 1024>, SQUARE_NB> PieceAttacks::s_BishopAttacks{};
 std::array<std::array<U64, 4096>, SQUARE_NB> PieceAttacks::s_RookAttacks{};
 
 const std::array<U64, SQUARE_NB> PieceAttacks::s_KingAttacks = [] {
-	std::array<U64, SQUARE_NB> moves{};
-
-	const auto addAttack = [&](const byte startSquare, const byte x, const byte y) {
-		const Pos pos(col(startSquare) + x, row(startSquare) + y);
+	using namespace Bitboard;
 
-		if (pos.isValid())
-			moves[startSquare] |= pos.toBitboard();
-	};
+	std::array<U64, SQUARE_NB> moves{};
 
 	for (byte i = 0u; i < SQUARE_NB; i++)
 	{
+		const U64 bb = shiftedBoards[i];
+
 		// Vertical and Horizontal
-		addAttack(i, -1, 0u);
-		addAttack(i, 1u, 0u);
-		addAttack(i, 0u, -1);
-		addAttack(i, 0u, 1u);
+		U64 attacks = shift<NORTH>(bb) | shift<SOUTH>(bb) | shift<EAST>(bb) | shift<WEST>(bb);
 
 		// Diagonals
-		addAttack(i, 1u, -1);
-		addAttack(i, 1u, 1u);
-		addAttack(i, -1, -1);
-		addAttack(i, -1, 1u);
+		attacks |= shift<NORTH_EAST>(bb) | shift<NORTH_WEST>(bb) | shift<SOUTH_EAST>(bb) | shift<SOUTH_WEST>(bb);
+
+		moves[i] = attacks;
 	}
 
 	return moves;

ChessAndroid/app/src/main/cpp/chess/data/Bitboard.h

@@ -254,13 +254,22 @@ namespace Bitboard
 	{
 		if constexpr (D == NORTH)
 			return bb << 8u;
-		else if (D == SOUTH)
+		else if constexpr (D == SOUTH)
 			return bb >> 8u;
-		else if (D == EAST)
+		else if constexpr (D == EAST)
 			return (bb & ~FILE_H) << 1u;
-		else if (D == WEST)
+		else if constexpr (D == WEST)
 			return (bb & ~FILE_A) >> 1u;
 
+		else if constexpr (D == NORTH_EAST)
+			return (bb & ~FILE_H) << 9u;
+		else if constexpr (D == NORTH_WEST)
+			return (bb & ~FILE_A) << 7u;
+		else if constexpr (D == SOUTH_EAST)
+			return (bb & ~FILE_H) >> 7u;
+		else if constexpr (D == SOUTH_WEST)
+			return (bb & ~FILE_A) >> 9u;
+
 		return {};
 	}
 

ChessAndroid/app/src/main/cpp/chess/data/Board.cpp

@@ -75,16 +75,6 @@ U64 Board::getType(const Color color, const PieceType type) const noexcept
 	return pieces[color][type];
 }
 
-Piece &Board::operator[](const Pos &pos) noexcept
-{
-	return data[pos.toSquare()];
-}
-
-const Piece &Board::operator[](const Pos &pos) const noexcept
-{
-	return data[pos.toSquare()];
-}
-
 bool Board::operator<(const Board &other) const noexcept
 {
 	return score < other.score;
@@ -256,7 +246,7 @@ std::vector<Board> Board::listQuiescenceMoves() const
 	return moves;
 }
 
-bool Board::movePawn(const byte startSq, const byte destSq)
+void Board::movePawn(const byte startSq, const byte destSq)
 {
 	Piece &pawn = getPiece(startSq);
 
@@ -272,25 +262,20 @@ bool Board::movePawn(const byte startSq, const byte destSq)
 
 		getType(pawn.color, PieceType::PAWN) &= ~destBb;
 		getType(pawn.color, newPieceType) |= destBb;
-		return true;
 	}
 
-	if (enPassantSq < 64u)
+	if (enPassantSq < 64u && destSq == enPassantSq)
 	{
-		if (destSq == enPassantSq)
-		{
-			isCapture = true;
+		isCapture = true;
 
-			Pos capturedPos(enPassantSq);
-			capturedPos.y += static_cast<byte>(pawn.color ? -1 : 1);
-			Piece &capturedPiece = getPiece(capturedPos.toSquare());
+		Pos capturedPos(enPassantSq);
+		capturedPos.y += static_cast<byte>(pawn.color ? -1 : 1);
+		Piece &capturedPiece = getPiece(capturedPos.toSquare());
 
-			// Remove the captured Pawn
-			Hash::xorPiece(zKey, capturedPos.toSquare(), capturedPiece);
-			getType(capturedPiece.color, capturedPiece.type) &= ~capturedPos.toBitboard();
-			capturedPiece = Piece();
-			return true;
-		}
+		// Remove the captured Pawn
+		Hash::xorPiece(zKey, capturedPos.toSquare(), capturedPiece);
+		getType(capturedPiece.color, capturedPiece.type) &= ~capturedPos.toBitboard();
+		capturedPiece = Piece();
 	}
 
 	enPassantSq = 64u;
@@ -302,8 +287,6 @@ bool Board::movePawn(const byte startSq, const byte destSq)
 		newEnPassant.y -= static_cast<byte>(distance / 2);
 		enPassantSq = newEnPassant.toSquare();
 	}
-
-	return false;
 }
 
 void Board::moveRook(const byte startSq)

ChessAndroid/app/src/main/cpp/chess/data/Board.h

@@ -40,9 +40,6 @@ class Board final
 	Board &operator=(Board&&) noexcept = default;
 	Board &operator=(const Board &other) = default;
 
-	Piece &operator[](const Pos &pos) noexcept;
-	const Piece &operator[](const Pos &pos) const noexcept;
-
 	bool operator<(const Board &other) const noexcept;
 	bool operator>(const Board &other) const noexcept;
 
@@ -73,7 +70,7 @@ class Board final
 	std::vector<Board> listQuiescenceMoves() const;
 
 private:
-	bool movePawn(byte startSq, byte destSq);
+	void movePawn(byte startSq, byte destSq);
 	void moveRook(byte startSq);
 	void moveKing(const Piece &king, byte startSq, byte destSq);