Remake the Pawn Evaluation add Connected Bonus

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

@@ -8,7 +8,7 @@
 #define S Score
 
 constexpr short TEMPO_BONUS = 20;
-constexpr S CHECK_BONUS{ 30, 42 };
+constexpr S CHECK_BONUS(30, 42);
 
 /*
  * These values were imported from the Stockfish Chess Engine
@@ -20,6 +20,10 @@ constexpr S MINOR_THREATS[] =
 constexpr S OVERLOAD(12, 6);
 constexpr S PAWN_DOUBLED(11, 56);
 constexpr S PAWN_ISOLATED(5, 15);
+constexpr short PAWN_CONNECTED[] =
+{
+	0, 7, 8, 12, 29, 48, 86
+};
 constexpr S PASSED_PAWN_RANK[] =
 {
 	S(0, 0), S(10, 28), S(17, 33), S(15, 41), S(62, 72), S(168, 177), S(276, 260)
@@ -74,7 +78,7 @@ short Evaluation::simpleEvaluation(const Board &board) noexcept
 		return VALUE_WINNER_BLACK;
 
 	Score score[2]{};
-	for (byte i = 0; i < 64u; i++)
+	for (byte i = 0; i < SQUARE_NB; i++)
 	{
 		const Piece &piece = board.getPiece(i);
 		score[piece.color] += Psqt::s_Bonus[piece.type][i];
@@ -104,7 +108,7 @@ short Evaluation::evaluate(const Board &board) noexcept
 	const AttacksMap whiteMoves = Player::getAttacksPerColor(true, board);
 	const AttacksMap blackMoves = Player::getAttacksPerColor(false, board);
 
-	for (byte i = 0; i < 64u; i++)
+	for (byte i = 0u; i < SQUARE_NB; i++)
 		if (const auto &piece = board.getPiece(i); piece && piece.type != KING)
 		{
 			if (piece.type == PAWN)
@@ -145,7 +149,7 @@ short Evaluation::evaluate(const Board &board) noexcept
 	if (bishopCount[BLACK] >= 2)
 		totalScore[BLACK] += 10;
 
-	for (byte i = 0; i < 64u; i++)
+	for (byte i = 0u; i < SQUARE_NB; i++)
 		if (const Piece &piece = board.getPiece(i); piece)
 		{
 			const Score points = [&] {
@@ -187,70 +191,53 @@ short Evaluation::evaluate(const Board &board) noexcept
 Score Evaluation::evaluatePawn(const Piece &piece, const byte square, const Board &board,
 							   const AttacksMap &ourAttacks, const AttacksMap &theirAttacks) noexcept
 {
+	const Color oppositeColor = ~piece.color;
 	const Pos pos(square);
 	Score value = Psqt::s_Bonus[PAWN][square];
 
+	const Rays::Dir forwardDir = piece.color ? Rays::NORTH : Rays::SOUTH;
+	const byte rank = (piece.color ? pos.y : 7u - pos.y) - 1u;
 	const byte behind = piece.color ? -1 : 1;
-	const int supported = int(piece == board.at(pos.x - 1u, pos.y + behind))
-						+ int(piece == board.at(pos.x + 1u, pos.y + behind));
 
-	bool isolated = !static_cast<bool>(supported);
-
-	if (piece == board.getPiece(pos.x, pos.y + behind))
-		value -= PAWN_DOUBLED;
+	const U64 adjacentFiles = Rays::getAdjacentFiles(square);
+	const U64 opposed = board.getType(oppositeColor, PAWN) & Rays::getRay(forwardDir, square);
+	const U64 neighbours = board.getType(piece.color, PAWN) & adjacentFiles;
+	const U64 connected = neighbours & Rays::getRank(square);
+	const U64 support = neighbours & Rays::getRank(toSquare(pos.x + behind, pos.y));
+	const bool isDoubled = board.at(pos.x, pos.y - behind) == piece;
 
-	if (isolated)
+	if (support | connected)
 	{
-		for (byte y = 0u ; y < 8u; y++) {
-			if (piece == board.at(pos.x - 1u, y) ||
-				piece == board.at(pos.x + 1u, y))
-			{
-				isolated = false;
-				break;
-			}
-		}
-	}
+		const int connectedScore = PAWN_CONNECTED[rank] * (2 + bool(connected) - bool(opposed))
+			+ 21 * Bitboard::popCount(support);
 
-	if (isolated)
+		value += Score(connectedScore, connectedScore * (rank - 2) / 4);
+	} else if (!neighbours)
 		value -= PAWN_ISOLATED;
 
+	if (!support && isDoubled)
+		value -= PAWN_DOUBLED;
+
 	// Threat Safe Pawn
 	if (ourAttacks.map[square] || theirAttacks.map[square] == 0) // check if the pawn is safe
 	{
-		const auto isEnemyPiece = [&] (const byte x, const byte y) {
-			const Pos newPos(pos, x, y);
-			if (!newPos.isValid()) return false;
+		const U64 enemyPieces = MoveGen<CAPTURES>::generatePawnMoves(piece, square, board)
+			& ~(board.getType(oppositeColor, PAWN) | board.getType(oppositeColor, KING));
 
-			const Piece &other = board[newPos];
-			const byte type = other.type;
-			return other.color != piece.color && type > PAWN && type < KING;
-		};
+		const int count = Bitboard::popCount(enemyPieces);
 
-		const int i = static_cast<int>(isEnemyPiece(-1, -behind))
-					+ static_cast<int>(isEnemyPiece(1u, -behind));
-
-		value += THREAT_SAFE_PAWN * i;
+		value += THREAT_SAFE_PAWN * count;
 	}
 
-	const auto isPassedPawn = [&] {
-		const Rays::Dir direction = piece.color ? Rays::NORTH : Rays::SOUTH;
-
-		const Pos posLeft(pos, -1, -behind);
-		const Pos posRight(pos, 1, -behind);
+	{ // Passed Pawn
+		U64 rays = Rays::getRay(forwardDir, square);
+		const U64 adjacentRays = Rays::shift<Rays::WEST>(rays) | Rays::shift<Rays::EAST>(rays);
+		rays |= piece.color ? Rays::shift<Rays::NORTH>(adjacentRays) : Rays::shift<Rays::SOUTH>(adjacentRays);
 
-		U64 rays = Rays::getRay(direction, square);
-		if (posLeft.isValid())
-			rays |= Rays::getRay(direction, posLeft.toSquare());
-		if (posRight.isValid())
-			rays |= Rays::getRay(direction, posRight.toSquare());
+		const bool isPassedPawn = !static_cast<bool>(rays & board.getType(oppositeColor, PAWN));
 
-		return static_cast<bool>(rays & board.getType(~piece.color, PAWN));
-	}();
-
-	if (isPassedPawn)
-	{
-		const auto rank = (piece.color ? pos.y : 7u - pos.y) - 1u;
-		value += PASSED_PAWN_RANK[rank];
+		if (isPassedPawn)
+			value += PASSED_PAWN_RANK[rank];
 	}
 
 	return value;
@@ -278,7 +265,7 @@ Score Evaluation::evaluateBishop(const Piece &piece, const byte square, const Bo
 	const auto isLongDiagonalBishop = [&] {
 		if (pos.y - pos.x == 0 || pos.y - (7 - pos.x) == 0)
 		{
-			auto [x, y] = pos;
+			auto[x, y] = pos;
 			if (std::min<byte>(x, 7u - x) > 2) return false;
 			for (byte i = std::min<byte>(x, 7u - x); i < 4; i++)
 			{
@@ -375,17 +362,15 @@ Score Evaluation::evaluateQueen(const Piece &piece, const byte square, const Boa
 	return value;
 }
 
-inline Score
-Evaluation::evaluateKing(const Piece &piece, const byte square, const Board &board) noexcept
+inline Score Evaluation::evaluateKing(const Piece &piece, const byte square, const Board &board) noexcept
 {
 	Score value = Psqt::s_Bonus[KNIGHT][square];
 
 	if (board.isCastled(piece.color))
 		value.mg += 57;
 	else {
-		const int count = static_cast<int>(board.canCastleKs(piece.color))
-						+ static_cast<int>(board.canCastleQs(piece.color));
-		value.mg += count * 23;
+		const int count = int(board.canCastleKs(piece.color)) + int(board.canCastleQs(piece.color));
+		value.mg += count * 20;
 	}
 
 	return value;

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

@@ -38,7 +38,7 @@ U64 Hash::compute(const Board &board)
 {
 	U64 hash{};
 
-	for (byte i = 0; i < 64; ++i)
+	for (byte i = 0; i < SQUARE_NB; ++i)
 		if (const Piece &piece = board.getPiece(i); piece)
 			hash ^= s_Pieces[i][piece.color][piece.type];
 

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

@@ -133,7 +133,7 @@ short Search::negaMax(const Board &board, const short ply, short alpha, short be
 
 	const auto validMoves = board.listValidMoves<Board>();
 	short bestScore = VALUE_MIN;
-	short movesCount = 0;
+	size_t movesCount{};
 
 	Stats::incrementNodesGenerated(validMoves.size());
 
@@ -196,7 +196,7 @@ short Search::negaMax(const Board &board, const short ply, short alpha, short be
 		++movesCount;
 	}
 
-	Stats::incrementNodesSearched(static_cast<size_t>(movesCount));
+	Stats::incrementNodesSearched(movesCount);
 
 	// Store the result in the transposition table
 	Flag flag = Flag::EXACT;
@@ -240,8 +240,8 @@ short Search::quiescence(const Board &board, short alpha, const short beta)
 	}
 
 	const auto validMoves = board.listQuiescenceMoves();
+	size_t movesCount{};
 
-	Stats::incrementNodesSearched();
 	Stats::incrementNodesGenerated(validMoves.size());
 
 	for (const Board &move : validMoves)
@@ -255,8 +255,12 @@ short Search::quiescence(const Board &board, short alpha, const short beta)
 			return moveScore;
 		if (moveScore > alpha)
 			alpha = moveScore;
+
+		++movesCount;
 	}
 
+	Stats::incrementNodesSearched(movesCount);
+
 	return alpha;
 }
 

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

@@ -105,9 +105,9 @@ constexpr U64 FILE_A = 0x101010101010101ull;
 
 constexpr byte SQUARE_NB = 64u;
 
-constexpr byte row(const byte pos) noexcept { return static_cast<byte>(pos / 8u); }
+constexpr byte row(const byte pos) noexcept { return static_cast<byte>(pos >> 3u); }
 
-constexpr byte col(const byte pos) noexcept { return static_cast<byte>(pos % 8u); }
+constexpr byte col(const byte pos) noexcept { return static_cast<byte>(pos & 7u); }
 
 constexpr byte toSquare(const byte x, const byte y) noexcept
 {

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

@@ -20,12 +20,12 @@ namespace Rays
 	/**
 	 * Table of precalculated ray bitboards indexed by direction and square
 	 */
-	constexpr static std::array<std::array<U64, 64>, 8> rays = [] {
-		std::array<std::array<U64, 64>, 8> rays{};
+	constexpr static auto rays = [] {
+		std::array<std::array<U64, SQUARE_NB>, 8> rays{};
 
 		using namespace Bitboard;
 
-		for (byte square = 0u; square < 64u; square++)
+		for (byte square = 0u; square < SQUARE_NB; ++square)
 		{
 			rays[NORTH][square] = 0x0101010101010100ULL << square;
 
@@ -47,6 +47,39 @@ namespace Rays
 		return rays;
 	}();
 
+	constexpr static auto ranks = [] {
+		std::array<U64, 8> ranks{};
+
+		for (byte r = 0u; r < 8u; ++r)
+			ranks[r] = 0b1111'1111ull << (8u * r);
+
+		return ranks;
+	}();
+
+	constexpr static auto files = [] {
+		std::array<U64, 8> files{};
+
+		for (byte f = 0u; f < 8u; ++f)
+			files[f] = 0x101010101010101ull << f;
+
+		return files;
+	}();
+
+	template <Dir D>
+	constexpr U64 shift(const U64 bb) noexcept
+	{
+		if constexpr (D == NORTH)
+			return bb << 8u;
+		else if (D == SOUTH)
+			return bb >> 8u;
+		else if (D == EAST)
+			return (bb & ~FILE_H) << 1u;
+		else if (D == WEST)
+			return (bb & ~FILE_A) >> 1u;
+
+		return {};
+	}
+
 	/**
 	 * Returns a bitboard containing the given ray in the given direction.
 	 *
@@ -57,4 +90,19 @@ namespace Rays
 	{
 		return rays[direction][square];
 	}
+
+	constexpr U64 getRank(const byte square) noexcept
+	{
+		return ranks[row(square)];
+	}
+
+	constexpr U64 getFile(const byte square) noexcept
+	{
+		return files[col(square)];
+	}
+
+	constexpr U64 getAdjacentFiles(const byte square) noexcept
+	{
+		return shift<WEST>(getFile(square)) | shift<EAST>(getFile(square));
+	}
 };