Re-enable EnPassant

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

@@ -12,8 +12,8 @@
 #include "chess/persistence/MovesPersistence.h"
 #include "chess/algorithm/Search.h"
 
-JavaVM *jvm = nullptr;
-jobject gameManagerInstance;
+static JavaVM *jvm = nullptr;
+static jobject gameManagerInstance;
 
 const BoardManager::PieceChangeListener listener = [](State state, bool shouldRedraw,
 													  const std::vector<std::pair<byte, byte>> &moved)
@@ -23,7 +23,7 @@ const BoardManager::PieceChangeListener listener = [](State state, bool shouldRe
 	if (getEnvStat == JNI_EDETACHED)
 	{
 		jvm->AttachCurrentThread(&env, nullptr);
-		LOGI("ChessCpp", "Attached to Thread");
+		LOGD("ChessCpp", "Attached to Thread");
 	}
 
 	env->ExceptionClear();
@@ -51,7 +51,7 @@ const BoardManager::PieceChangeListener listener = [](State state, bool shouldRe
 	if (getEnvStat == JNI_EDETACHED)
 	{
 		jvm->DetachCurrentThread();
-		LOGI("ChessCpp", "Detached from Thread");
+		LOGD("ChessCpp", "Detached from Thread");
 	}
 };
 
@@ -124,7 +124,7 @@ Java_net_theluckycoder_chess_Native_isPlayerWhite(JNIEnv */*pEnv*/, jclass /*typ
 // region Stats
 
 external JNIEXPORT jdouble JNICALL
-Java_net_theluckycoder_chess_Native_getSearchTime(JNIEnv *pEnv, jclass /*type*/)
+Java_net_theluckycoder_chess_Native_getSearchTime(JNIEnv */*pEnv*/, jclass /*type*/)
 {
 	return static_cast<jdouble>(Stats::getElapsedTime());
 }
@@ -228,8 +228,8 @@ Java_net_theluckycoder_chess_Native_movePiece(JNIEnv */*pEnv*/, jclass /*type*/,
 											  jbyte destY)
 {
 	BoardManager::movePiece(
-		Pos(static_cast<byte>(selectedX), static_cast<byte>(selectedY)).toSquare(),
-		Pos(static_cast<byte>(destX), static_cast<byte>(destY)).toSquare());
+		toSquare(static_cast<byte>(selectedX), static_cast<byte>(selectedY)),
+		toSquare(static_cast<byte>(destX), static_cast<byte>(destY)));
 }
 
 
@@ -243,7 +243,7 @@ external JNIEXPORT void JNICALL
 Java_net_theluckycoder_chess_Native_loadMoves(JNIEnv *pEnv, jclass /*type*/, jstring moves)
 {
 	const char *nativeString = pEnv->GetStringUTFChars(moves, nullptr);
-	const MovesPersistence savedMoves = MovesPersistence(nativeString);
+	const MovesPersistence savedMoves(nativeString);
 
 	BoardManager::loadGame(savedMoves.getMoves(), savedMoves.isPlayerWhite());
 
@@ -279,6 +279,7 @@ Java_net_theluckycoder_chess_Native_perft(JNIEnv */*pEnv*/, jclass /*type*/, jin
 {
 	using namespace std::chrono;
 
+	constexpr auto TAG = "Perft Test";
 	constexpr std::array<U64, 7> perftResults{
 		1, 20, 400, 8902, 197281, 4865609, 119060324
 	};
@@ -292,17 +293,17 @@ Java_net_theluckycoder_chess_Native_perft(JNIEnv */*pEnv*/, jclass /*type*/, jin
 
 	for (int i = 0; i <= depth; ++i)
 	{
-		LOGV("Perft Test", "Starting Depth %d Test", i);
+		LOGV(TAG, "Starting Depth %d Test", i);
 
 		const auto startTime = high_resolution_clock::now();
 		const U64 nodesCount = perft(board, i);
 		const auto endTime = high_resolution_clock::now();
 
 		const auto timeNeeded = duration<double, std::milli>(endTime - startTime).count();
 
-		LOGV("Perft Test", "Time needed: %lf", timeNeeded);
-		LOGV("Perft Test", "Nodes count: %llu/%llu", nodesCount, perftResults[i]);
+		LOGV(TAG, "Time needed: %lf", timeNeeded);
+		LOGV(TAG, "Nodes count: %llu/%llu", nodesCount, perftResults[i]);
 		if (nodesCount != perftResults[i])
-			LOGE("Perft Test Error", "Nodes count do not match at depth %d", i);
+			LOGE(TAG, "Nodes count do not match at depth %d", i);
 	}
 }

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

@@ -15,8 +15,10 @@ void BoardManager::initBoardManager(const PieceChangeListener &listener, const b
 {
     Hash::init();
 	PieceAttacks::init();
+	//MoveOrdering::init();
 
 	s_Board.initDefaultBoard();
+	//s_Board.setToFen("r1b1k2r/ppppnppp/2n2q2/2b5/3NP3/2P1B3/PP3PPP/RN1QKB1R w KQkq - 0 1");
 	s_Listener = listener;
 
 	s_MovesHistory.clear();

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

@@ -7,7 +7,7 @@
 
 #include "Settings.h"
 #include "containers/StackVector.h"
-#include "data/Enums.h"
+#include "data/Defs.h"
 #include "data/Piece.h"
 
 class RootMove;

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

@@ -19,16 +19,31 @@ void Stats::resetStats() noexcept
 	s_NodesGenerated = 0;
 }
 
+size_t Stats::getBoardsEvaluated() noexcept
+{
+	return s_BoardsEvaluated;
+}
+
+size_t Stats::getNodesSearched() noexcept
+{
+	return s_NodesSearched;
+}
+
+size_t Stats::getNodesGenerated() noexcept
+{
+	return s_NodesGenerated;
+}
+
 void Stats::incrementBoardsEvaluated() noexcept
 {
 	if (s_StatsEnabled)
 		++s_BoardsEvaluated;
 }
 
-void Stats::incrementNodesSearched() noexcept
+void Stats::incrementNodesSearched(const std::size_t amount) noexcept
 {
 	if (s_StatsEnabled)
-		++s_NodesSearched;
+		s_NodesSearched += amount;
 }
 
 void Stats::incrementNodesGenerated(const std::size_t amount) noexcept

ChessAndroid/app/src/main/cpp/chess/Stats.h

@@ -23,9 +23,13 @@ class Stats final
 	static void setEnabled(bool enabled) noexcept;
 	static void resetStats() noexcept;
 
+	static size_t getBoardsEvaluated() noexcept;
+	static size_t getNodesSearched() noexcept;
+	static size_t getNodesGenerated() noexcept;
+
 	static void incrementBoardsEvaluated() noexcept;
-	static void incrementNodesSearched() noexcept;
-	static void incrementNodesGenerated(std::size_t amount) noexcept;
+	static void incrementNodesSearched(std::size_t amount = 1u) noexcept;
+	static void incrementNodesGenerated(std::size_t amount = 1u) noexcept;
 
 	static void startTimer() noexcept;
 	static void stopTimer() noexcept;

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

@@ -31,7 +31,7 @@ void Hash::init()
 
 U64 Hash::movePiece(const byte sq, const Piece &piece)
 {
-	return s_Pieces[sq][piece.isWhite][piece.type - 1u];
+	return s_Pieces[sq][piece.isWhite][piece.type];
 }
 
 U64 Hash::compute(const Board &board)
@@ -40,7 +40,7 @@ U64 Hash::compute(const Board &board)
 
 	for (byte i = 0; i < 64; ++i)
 		if (const Piece &piece = board.getPiece(i); piece)
-			hash ^= s_Pieces[i][piece.isWhite][piece.type - 1u];
+			hash ^= s_Pieces[i][piece.isWhite][piece.type];
 
 	if (board.colorToMove)
 		hash ^= s_WhiteToMove;
@@ -65,15 +65,15 @@ void Hash::makeMove(U64 &key, const byte selectedSq, const byte destSq, const Pi
 void Hash::promotePawn(U64 &key, const byte sq, const Color color, const PieceType promotedType)
 {
 	// Remove the Pawn
-	key ^= s_Pieces[sq][color][PAWN - 1u];
+	key ^= s_Pieces[sq][color][PAWN];
 
 	// Add the Promoted Piece
-	key ^= s_Pieces[sq][color][promotedType - 1u];
+	key ^= s_Pieces[sq][color][promotedType];
 }
 
 void Hash::xorPiece(U64 &key, const byte sq, const Piece &piece)
 {
-	key ^= s_Pieces[sq][piece.isWhite][piece.type - 1u];
+	key ^= s_Pieces[sq][piece.isWhite][piece.type];
 }
 
 void Hash::flipSide(U64 &key)

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

@@ -2,14 +2,14 @@
 
 #include <array>
 
-#include "../data/Enums.h"
+#include "../data/Defs.h"
 #include "../data/Piece.h"
 
 using U64 = std::uint64_t;
 
 class Hash final
 {
-	using HashArray = std::array<std::array<std::array<U64, 6>, 2>, 64>;
+	using HashArray = std::array<std::array<std::array<U64, 7>, 2>, 64>;
 
 	static HashArray s_Pieces;
 	static U64 s_WhiteToMove;

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

@@ -15,25 +15,25 @@ U64 MoveGen<T>::generatePawnMoves(const Piece &piece, const byte square, const B
 	{
 		U64 captures = attacks & board.allPieces[!piece.isWhite];
 
-		/*if (board.enPassantSq < 64)
-		{ 
+		if (board.enPassantSq < 64u)
+		{
 			Pos capturedPos(board.enPassantSq);
 			capturedPos.y += static_cast<byte>(piece.isWhite ? -1 : 1);
 			// Keep the en-passant capture if it intersect with one of our potential attacks
 			captures |= attacks & Bitboard::shiftedBoards[board.enPassantSq];
-		}*/
+		}
 
 		attacks = captures;
 	}
 	else if (T == ATTACKS_DEFENSES)
 		attacks &= board.occupied;
 
-	const U64 initialBb = Bitboard::shiftedBoards[square];
-	Pos pos(square);
-	piece.isWhite ? pos.y++ : pos.y--;
-
 	if constexpr (T == ALL)
 	{
+		const U64 initialBb = Bitboard::shiftedBoards[square];
+		Pos pos(square);
+		piece.isWhite ? pos.y++ : pos.y--;
+
 		if (!board[pos])
 		{
 			attacks |= pos.toBitboard();
@@ -157,10 +157,11 @@ U64 MoveGen<T>::generateKingMoves(const Piece &piece, const byte square, const B
 
 	const byte y = row(square);
 	const auto isEmptyAndCheckFree = [&, y](const byte x) {
-		const byte sq = Pos(x, y).toSquare();
+		const byte sq = toSquare(x, y);
 		const U64 bb = Bitboard::shiftedBoards[sq];
 
-		return !board.getPiece(x, y) && !(opponentsMoves & bb) && !Player::isAttacked(oppositeColor(color), sq, board);
+		return !board.getPiece(x, y) && !(opponentsMoves & bb)
+			&& !Player::isAttacked(oppositeColor(color), sq, board);
 	};
 
 	// King Side

ChessAndroid/app/src/main/cpp/chess/algorithm/MoveOrdering.h

@@ -15,9 +15,9 @@ class MoveOrdering
 		if (initialized) return;
 		initialized = true;
 
-		for (int attacker = PAWN; attacker <= KING; ++attacker)
+		for (byte attacker = PAWN; attacker <= KING; ++attacker)
 		{
-			for (int victim = PAWN; victim <= KING; ++victim)
+			for (byte victim = PAWN; victim <= KING; ++victim)
 			{
 				MvvLvaScore[victim][attacker] = victimScore[victim] + 6 - (victimScore[attacker] / 100);
 			}