Fix getPhase always returning ENDGAME

ChessAndroid/app/src/main/cpp/chess/BoardManager.cpp

@@ -82,10 +82,12 @@ StackVector<Pos, 27> BoardManager::getPossibleMoves(const Pos &selectedPos)
 
 void BoardManager::movePiece(const byte startSq, const byte destSq, const bool movedByPlayer)
 {
+	assert(startSq != destSq);
 	assert(startSq < 64 && destSq < 64);
 
 	const byte castledBefore = (s_Board.castlingRights & CASTLED_WHITE) | (s_Board.castlingRights & CASTLED_BLACK);
 	s_Board.doMove(startSq, destSq);
+	assert(s_Board.hasValidState());
 	const byte castledAfter = (s_Board.castlingRights & CASTLED_WHITE) | (s_Board.castlingRights & CASTLED_BLACK);
 
 	s_Board.score = Evaluation::evaluate(s_Board);

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

@@ -76,22 +76,20 @@ short Evaluation::simpleEvaluation(const Board &board) noexcept
 		if (const Piece &piece = board.getPiece(i); piece)
 		{
 			const short points = [&]() -> short {
-				const byte x = col(i);
-				const byte y = row(i);
 				switch (piece.type)
 				{
 					case PAWN:
-						return Psqt::s_PawnSquares[x][y].mg;
+						return Psqt::s_PawnSquares[i].mg;
 					case KNIGHT:
-						return Psqt::s_KnightSquares[x][y].mg;
+						return Psqt::s_KnightSquares[i].mg;
 					case BISHOP:
-						return Psqt::s_BishopSquares[x][y].mg;
+						return Psqt::s_BishopSquares[i].mg;
 					case ROOK:
-						return Psqt::s_RookSquares[x][y].mg;
+						return Psqt::s_RookSquares[i].mg;
 					case QUEEN:
-						return Psqt::s_QueenSquares[x][y].mg;
+						return Psqt::s_QueenSquares[i].mg;
 					case KING:
-						return Psqt::s_KingSquares[x][y].mg;
+						return Psqt::s_KingSquares[i].mg;
 					default:
 						return 0;
 				}
@@ -263,11 +261,11 @@ short Evaluation::evaluate(const Board &board) noexcept
 
 Score Evaluation::evaluatePawn(const Piece &piece, const Pos &pos, const Board &board, const AttacksMap &ourAttacks, const AttacksMap &theirAttacks) noexcept
 {
-	Score value = Psqt::s_PawnSquares[pos.x][pos.y];
+	Score value = Psqt::s_PawnSquares[pos.toSquare()];
 
 	const byte behind = piece.isWhite ? -1 : 1;
-	const int supported = (board.at(pos.x - 1u, pos.y + behind).isSameType(piece) +
-		board.at(pos.x + 1u, pos.y + behind).isSameType(piece));
+	const int supported = board.at(pos.x - 1u, pos.y + behind).isSameType(piece)
+						+ board.at(pos.x + 1u, pos.y + behind).isSameType(piece);
 
 	bool isolated = !static_cast<bool>(supported);
 
@@ -369,7 +367,7 @@ Score Evaluation::evaluatePawn(const Piece &piece, const Pos &pos, const Board &
 
 inline Score Evaluation::evaluateKnight(const Piece &piece, const Pos &pos, const Board &board) noexcept
 {
-	Score value = Psqt::s_KnightSquares[pos.x][pos.y];
+	Score value = Psqt::s_KnightSquares[pos.toSquare()];
 
 	const int mobility = Bitboard::popCount(MoveGen<ALL>::generateKnightMoves(piece, pos.toSquare(), board));
 	value += KNIGHT_MOBILITY[mobility];
@@ -379,7 +377,7 @@ inline Score Evaluation::evaluateKnight(const Piece &piece, const Pos &pos, cons
 
 Score Evaluation::evaluateBishop(const Piece &piece, const Pos &pos, const Board &board) noexcept
 {
-	Score value = Psqt::s_BishopSquares[pos.x][pos.y];
+	Score value = Psqt::s_BishopSquares[pos.toSquare()];
 
 	const int mobility = Bitboard::popCount(MoveGen<ALL>::generateBishopMoves(piece, pos.toSquare(), board));
 	value += BISHOP_MOBILITY[mobility];
@@ -407,7 +405,7 @@ Score Evaluation::evaluateBishop(const Piece &piece, const Pos &pos, const Board
 
 Score Evaluation::evaluateRook(const Piece &piece, const Pos &pos, const Board &board) noexcept
 {
-	Score value = Psqt::s_RookSquares[pos.x][pos.y];
+	Score value = Psqt::s_RookSquares[pos.toSquare()];
 
 	value += ROOK_MOBILITY[Bitboard::popCount(MoveGen<ALL>::generateRookMoves(piece, pos.toSquare(), board))];
 
@@ -451,7 +449,7 @@ Score Evaluation::evaluateRook(const Piece &piece, const Pos &pos, const Board &
 
 Score Evaluation::evaluateQueen(const Piece &piece, const Pos &pos, const Board &board) noexcept
 {
-	Score value = Psqt::s_QueenSquares[pos.x][pos.y];
+	Score value = Psqt::s_QueenSquares[pos.toSquare()];
 
 	value += QUEEN_MOBILITY[Bitboard::popCount(MoveGen<ALL>::generateQueenMoves(piece, pos.toSquare(), board))];
 
@@ -469,7 +467,7 @@ Score Evaluation::evaluateQueen(const Piece &piece, const Pos &pos, const Board
 				Pos dPos(pos, d * ix, d * iy);
 				if (dPos.isValid())
 				{
-					const auto &other = board[dPos];
+					const Piece &other = board[dPos];
 					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++;
@@ -488,5 +486,5 @@ Score Evaluation::evaluateQueen(const Piece &piece, const Pos &pos, const Board
 
 inline Score Evaluation::evaluateKing(const Pos &pos) noexcept
 {
-	return Psqt::s_KingSquares[pos.x][pos.y];
+	return Psqt::s_KingSquares[pos.toSquare()];
 }

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

@@ -135,17 +135,17 @@ Phase Board::getPhase() const noexcept
 	constexpr short midGameLimit = 15258;
 	constexpr short endGameLimit = 3915;
 
-	const int limit = std::max(endGameLimit, std::min(npm, midGameLimit));
+	const short limit = std::max(endGameLimit, std::min(npm, midGameLimit));
 	return static_cast<Phase>(((limit - endGameLimit) * 128) / (midGameLimit - endGameLimit));
 }
 
 bool Board::hasValidState() const noexcept
 {
     if (state == State::INVALID)
         return false;
-    if (colorToMove && (state == State::WHITE_IN_CHECK || state == State::WINNER_BLACK))
+    if (colorToMove == WHITE && (state == State::WHITE_IN_CHECK || state == State::WINNER_BLACK))
         return false;
-    if (!colorToMove && (state == State::BLACK_IN_CHECK || state == State::WINNER_WHITE))
+    if (colorToMove == BLACK && (state == State::BLACK_IN_CHECK || state == State::WINNER_WHITE))
         return false;
 
     return true;
@@ -239,7 +239,8 @@ void Board::doMove(const byte startSq, const byte destSq, const bool updateState
 
 	if (destPiece)
 	{
-		npm -= Evaluation::getPieceValue(destPiece.type);
+		if (destPiece.type != PAWN)
+			npm -= Evaluation::getPieceValue(destPiece.type);
 		isCapture = true;
 		halfMoveClock = 0u;
 	}
@@ -279,7 +280,6 @@ bool Board::movePawn(const byte startSq, const byte destSq)
 
 		// Remove the captured Pawn
 		Hash::xorPiece(zKey, capturedPos.toSquare(), capturedPiece);
-		npm -= Evaluation::getPieceValue(PieceType::PAWN);
 		capturedPiece = Piece();
 		getType(toColor(capturedPiece.isWhite), capturedPiece.type);
 		return true;
@@ -326,8 +326,8 @@ void Board::moveKing(const Piece &king, const byte startSq, const byte destSq)
 			getPiece(destX, y) = rook;
 			rook = Piece::EMPTY;
 
-			getType(color, ROOK) &= ~Pos(destX, y).toBitboard();
 			getType(color, ROOK) &= ~Pos(startX, y).toBitboard();
+			getType(color, ROOK) |= Pos(destX, y).toBitboard();
 
 			castled = true;
 			Hash::makeMove(zKey, Pos(startX, y).toSquare(), Pos(destX, y).toSquare(), rook);
@@ -345,8 +345,8 @@ void Board::moveKing(const Piece &king, const byte startSq, const byte destSq)
 			getPiece(destX, y) = rook;
 			rook = Piece::EMPTY;
 
-			getType(color, ROOK) &= ~Pos(destX, y).toBitboard();
 			getType(color, ROOK) &= ~Pos(startX, y).toBitboard();
+			getType(color, ROOK) |= Pos(destX, y).toBitboard();
 
 			castled = true;
 			Hash::makeMove(zKey, Pos(startX, y).toSquare(), Pos(destX, y).toSquare(), rook);

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

@@ -73,13 +73,11 @@ class Pos
 
 	constexpr byte toSquare() const noexcept
 	{
-		return static_cast<byte>(x + y * 8u);
+		return static_cast<byte>((y << 3u) + x);
 	}
 
 	constexpr U64 toBitboard() const noexcept
 	{
 		return Bitboard::shiftedBoards[toSquare()];
 	}
 };
-
-using PosPair = std::pair<Pos, Pos>;

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

@@ -1,15 +1,16 @@
 #include "Psqt.h"
 
+#include "Bitboard.h"
+
 #define S Score
 
-constexpr S PAWN_SCORE(136, 208);
-constexpr S KNIGHT_SCORE(782, 865);
-constexpr S BISHOP_SCORE(830, 918);
-constexpr S ROOK_SCORE(1289, 1378);
-constexpr S QUEEN_SCORE(2529, 2687);
+constexpr static S PAWN_SCORE(128, 213);
+constexpr static S KNIGHT_SCORE(781, 854);
+constexpr static S BISHOP_SCORE(825, 915);
+constexpr static S ROOK_SCORE(1276, 1380);
+constexpr static S QUEEN_SCORE(2538, 2682);
 
-constexpr S PAWN_SQUARE[][4] =
-{
+constexpr static S PAWN_SQUARE[][4] = {
 	{ S(0,   0),  S(0,   0),   S(0,   0),  S(0,  0)  },
 	{ S(-11, -3), S(7,   -1),  S(7,   7),  S(17, 2)  },
 	{ S(-16, -2), S(-3,  2),   S(23,  6),  S(23, -1) },
@@ -19,60 +20,60 @@ constexpr S PAWN_SQUARE[][4] =
 	{ S(-2,  1),  S(20,  -12), S(-10, 6),  S(-2, 25) },
 	{ S(0,   0),  S(0,   0),   S(0,   0),  S(0,  0)  }
 };
-constexpr S KNIGHT_SQUARE[][4] =
-{
-	{ S(-169, -105), S(-96, -74), S(-80, -46), S(-79, -18) },
-	{ S(-79,  -70),  S(-39, -56), S(-24, -15), S(-9,  6)   },
-	{ S(-64,  -38),  S(-20, -33), S(4,   -5),  S(19,  27)  },
-	{ S(-28,  -36),  S(5,   0),   S(41,  13),  S(47,  34)  },
-	{ S(-29,  -41),  S(13,  -20), S(42,  4),   S(52,  35)  },
-	{ S(-11,  -51),  S(28,  -38), S(63,  -17), S(55,  19)  },
-	{ S(-67,  -64),  S(-21, -45), S(6,   -37), S(37,  16)  },
-	{ S(-200, -98),  S(-80, -89), S(-53, -53), S(-32, -16) }
+
+constexpr static S KNIGHT_SQUARE[][4] = {
+	{ S(-175,  -96), S(-92, -65), S(-74, -49), S(-73, -21) },
+	{ S( -77,  -67), S(-41, -54), S(-27, -18), S(-15,   8) },
+	{ S( -61,  -40), S(-17, -27), S(  6,  -8), S( 12,  29) },
+	{ S( -35,  -35), S(  8,  -2), S( 40,  13), S( 49,  28) },
+	{ S( -34,  -45), S( 13, -16), S( 44,   9), S( 51,  39) },
+	{ S(  -9,  -51), S( 22, -44), S( 58, -16), S( 53,  17) },
+	{ S( -67,  -69), S(-27, -50), S(  4, -51), S( 37,  12) },
+	{ S(-201, -100), S(-83, -88), S(-56, -56), S(-26, -17) }
 };
-constexpr S BISHOP_SQUARE[][4] =
-{
-	{ S(-44, -63), S(-4,  -30), S(-11, -35), S(-28, -8)  },
-	{ S(-18, -38), S(7,   -13), S(14,  -14), S(3,   0)   },
-	{ S(-8,  -18), S(24,  0),   S(-3,  -7),  S(15,  13)  },
-	{ S(1,   -26), S(8,   -3),  S(26,  1),   S(37,  16)  },
-	{ S(-7,  -24), S(30,  -6),  S(23,  -10), S(28,  17)  },
-	{ S(-17, -26), S(4,   2),   S(-1,  1),   S(8,   16)  },
-	{ S(-21, -34), S(-19, -18), S(10,  -7),  S(-6,  9)   },
-	{ S(-48, -51), S(-3,  -40), S(-12, -39), S(-25, -20) }
+
+constexpr static S BISHOP_SQUARE[][4] = {
+	{ S(-53, -57), S( -5, -30), S( -8, -37), S(-23, -12) },
+	{ S(-15, -37), S(  8, -13), S( 19, -17), S(  4,   1) },
+	{ S( -7, -16), S( 21,  -1), S( -5,  -2), S( 17,  10) },
+	{ S( -5, -20), S( 11,  -6), S( 25,   0), S( 39,  17) },
+	{ S(-12, -17), S( 29,  -1), S( 22, -14), S( 31,  15) },
+	{ S(-16, -30), S(  6,   6), S(  1,   4), S( 11,   6) },
+	{ S(-17, -31), S(-14, -20), S(  5,  -1), S(  0,   1) },
+	{ S(-48, -46), S(  1, -42), S(-14, -37), S(-23, -24) }
 };
-constexpr S ROOK_SQUARE[][4] =
-{
-	{ S(-24, -2),  S(-13, -6), S(-7, -3),  S(2,-2)  },
-	{ S(-18, -10), S(-10, -7), S(-5, 1),   S(9, 0)  },
-	{ S(-21, 10),  S(-7,  -4), S(3,  2),   S(-1,-2) },
-	{ S(-13, -5),  S(-5,  2),  S(-4, -8),  S(-6, 8) },
-	{ S(-24, -8),  S(-12, 5),  S(-1, 4),   S(6, -9) },
-	{ S(-24, 3),   S(-4,  -2), S(4,  -10), S(10, 7) },
-	{ S(-8,  1),   S(6,   2),  S(10, 17),  S(12,-8) },
-	{ S(-22, 12),  S(-24, -6), S(-6, 13),  S(4, 7)  }
+
+constexpr static S ROOK_SQUARE[][4] = {
+	{ S(-31,  -9), S(-20, -13), S(-14, -10), S(-5,  -9) },
+	{ S(-21, -12), S(-13,  -9), S( -8,  -1), S( 6,  -2) },
+	{ S(-25,   6), S(-11,  -8), S( -1,  -2), S( 3,  -6) },
+	{ S(-13,  -6), S( -5,   1), S( -4,  -9), S(-6,   7) },
+	{ S(-27,  -5), S(-15,   8), S( -4,   7), S( 3,  -6) },
+	{ S(-22,   6), S( -2,   1), S(  6,  -7), S(12,  10) },
+	{ S( -2,   4), S( 12,   5), S( 16,  20), S(18,  -5) },
+	{ S(-17,  18), S(-19,   0), S( -1,  19), S( 9,  13) }
 };
-constexpr S QUEEN_SQUARE[][4] =
-{
-	{ S(3,  -69), S(-5, -57), S(-5, -47), S(4,  -26) },
-	{ S(-3, -55), S(5,  -31), S(8,  -22), S(12, -4)  },
-	{ S(-3, -39), S(6,  -18), S(13, -9),  S(7,  3)   },
-	{ S(4,  -23), S(5,  -3),  S(9,  13),  S(8,  24)  },
-	{ S(0,  -29), S(14, -6),  S(12, 9),   S(5,  21)  },
-	{ S(-4, -38), S(10, -18), S(6,  -12), S(8,  1)   },
-	{ S(-5, -50), S(6,  -27), S(10, -24), S(8,  -8)  },
-	{ S(-2, -75), S(-2, -52), S(1,  -43), S(-2, -36) }
+
+constexpr static S QUEEN_SQUARE[][4] = {
+	{ S( 3, -69), S(-5, -57), S(-5, -47), S( 4, -26) },
+	{ S(-3, -55), S( 5, -31), S( 8, -22), S(12,  -4) },
+	{ S(-3, -39), S( 6, -18), S(13,  -9), S( 7,   3) },
+	{ S( 4, -23), S( 5,  -3), S( 9,  13), S( 8,  24) },
+	{ S( 0, -29), S(14,  -6), S(12,   9), S( 5,  21) },
+	{ S(-4, -38), S(10, -18), S( 6, -12), S( 8,   1) },
+	{ S(-5, -50), S( 6, -27), S(10, -24), S( 8,  -8) },
+	{ S(-2, -75), S(-2, -52), S( 1, -43), S(-2, -36) }
 };
-constexpr S KING_SQUARE[][4] =
-{
-	{ S(272, 0),   S(325, 41),  S(273, 80),  S(190, 93)  },
-	{ S(277, 57),  S(305, 98),  S(241, 138), S(183, 131) },
-	{ S(198, 86),  S(253, 138), S(168, 165), S(120, 173) },
-	{ S(169, 103), S(191, 152), S(136, 168), S(108, 169) },
-	{ S(145, 98),  S(176, 166), S(112, 197), S(69,  194) },
-	{ S(122, 87),  S(159, 164), S(85,  174), S(36,  189) },
-	{ S(87,  40),  S(120, 99),  S(64,  128), S(25,  141) },
-	{ S(64,  5),   S(87,  60),  S(49,  75),  S(0,   75)  }
+
+constexpr static S KING_SQUARE[][4] = {
+	{ S(271,   1), S(327,  45), S(270,  85), S(192,  76) },
+	{ S(278,  53), S(303, 100), S(230, 133), S(174, 135) },
+	{ S(195,  88), S(258, 130), S(169, 169), S(120, 175) },
+	{ S(164, 103), S(190, 156), S(138, 172), S( 98, 172) },
+	{ S(154,  96), S(179, 166), S(105, 199), S( 70, 199) },
+	{ S(123,  92), S(145, 172), S( 81, 184), S( 31, 191) },
+	{ S( 88,  47), S(120, 121), S( 65, 116), S( 33, 131) },
+	{ S( 59,  11), S( 89,  59), S( 45,  73), S( -1,  78) }
 };
 
 #undef S
@@ -82,59 +83,53 @@ using byte = unsigned char;
 const Psqt::ScoreArray Psqt::s_PawnSquares = [] {
 	ScoreArray array{};
 
-	for (byte x = 0; x < 8; x++)
-		for (byte y = 0; y < 8; y++)
-			array[x][y] = PAWN_SCORE + PAWN_SQUARE[7u - x][std::min<byte>(y, 7u - y)];
+	for (byte i = 0; i < 64; i++)
+		array[i] = PAWN_SCORE + PAWN_SQUARE[col(i)][std::min<byte>(row(i), 7u - row(i))];
 
 	return array;
 }();
 
 const Psqt::ScoreArray Psqt::s_KnightSquares = [] {
 	ScoreArray array{};
 
-	for (byte x = 0; x < 8; x++)
-		for (byte y = 0; y < 8; y++)
-			array[x][y] = KNIGHT_SCORE + KNIGHT_SQUARE[7u - x][std::min<byte>(y, 7u - y)];
+	for (byte i = 0; i < 64; i++)
+		array[i] = KNIGHT_SCORE + KNIGHT_SQUARE[col(i)][std::min<byte>(row(i), 7u - row(i))];
 
 	return array;
 }();
 
 const Psqt::ScoreArray Psqt::s_BishopSquares = [] {
 	ScoreArray array{};
 
-	for (byte x = 0; x < 8; x++)
-		for (byte y = 0; y < 8; y++)
-			array[x][y] = BISHOP_SCORE + BISHOP_SQUARE[7u - x][std::min<byte>(y, 7u - y)];
+	for (byte i = 0; i < 64; i++)
+		array[i] = BISHOP_SCORE + BISHOP_SQUARE[col(i)][std::min<byte>(row(i), 7u - row(i))];
 
 	return array;
 }();
 
 const Psqt::ScoreArray Psqt::s_RookSquares = [] {
 	ScoreArray array{};
 
-	for (byte x = 0; x < 8; x++)
-		for (byte y = 0; y < 8; y++)
-			array[x][y] = ROOK_SCORE + ROOK_SQUARE[7u - x][std::min<byte>(y, 7u - y)];
+	for (byte i = 0; i < 64; i++)
+		array[i] = ROOK_SCORE + ROOK_SQUARE[col(i)][std::min<byte>(row(i), 7u - row(i))];
 
 	return array;
 }();
 
 const Psqt::ScoreArray Psqt::s_QueenSquares = [] {
 	ScoreArray array{};
 
-	for (byte x = 0; x < 8; x++)
-		for (byte y = 0; y < 8; y++)
-			array[x][y] = QUEEN_SCORE + QUEEN_SQUARE[7u - x][std::min<byte>(y, 7u - y)];
+	for (byte i = 0; i < 64; i++)
+		array[i] = QUEEN_SCORE + QUEEN_SQUARE[col(i)][std::min<byte>(row(i), 7u - row(i))];
 
 	return array;
 }();
 
 const Psqt::ScoreArray Psqt::s_KingSquares = [] {
 	ScoreArray array{};
 
-	for (byte x = 0; x < 8; x++)
-		for (byte y = 0; y < 8; y++)
-			array[x][y] = KING_SQUARE[7u - x][std::min<byte>(y, 7u - y)];
+	for (byte i = 0; i < 64; i++)
+		array[i] = KING_SQUARE[col(i)][std::min<byte>(row(i), 7u - row(i))];
 
 	return array;
 }();

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

@@ -6,7 +6,7 @@
 
 class Psqt
 {
-	using ScoreArray = std::array<std::array<Score, 8>, 8>;
+	using ScoreArray = std::array<Score, 64>;
 
 public:
 	Psqt() = delete;