Rename NegaMax class to Search

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

@@ -10,7 +10,7 @@
 #include "chess/Stats.h"
 #include "chess/data/Board.h"
 #include "chess/persistence/MovesPersistence.h"
-#include "chess/algorithm/NegaMax.h"
+#include "chess/algorithm/Search.h"
 
 JavaVM *jvm = nullptr;
 jobject gameManagerInstance;
@@ -220,7 +220,7 @@ Java_net_theluckycoder_chess_Native_movePiece(JNIEnv */*pEnv*/, jclass /*type*/,
 external JNIEXPORT jint JNICALL
 Java_net_theluckycoder_chess_Native_getBestMoveFound(JNIEnv */*pEnv*/, jclass /*type*/)
 {
-	return static_cast<jint>(NegaMax::getBestMoveFound());
+	return static_cast<jint>(Search::getBestMoveFound());
 }
 
 

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

@@ -3,7 +3,7 @@
 #include "Stats.h"
 #include "data/Board.h"
 #include "algorithm/Hash.h"
-#include "algorithm/NegaMax.h"
+#include "algorithm/Search.h"
 #include "algorithm/PieceAttacks.h"
 
 Settings BoardManager::s_Settings(4u, std::thread::hardware_concurrency() - 1u, 100, true);
@@ -111,7 +111,7 @@ void BoardManager::moveComputerPlayer(const Settings &settings)
 	Stats::resetStats();
 	Stats::startTimer();
 
-	const RootMove bestMove = NegaMax::findBestMove(s_Board, settings);
+	const RootMove bestMove = Search::findBestMove(s_Board, settings);
 
 	Stats::stopTimer();
 	movePiece(bestMove.startSq, bestMove.destSq, false);

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

@@ -1,4 +1,4 @@
-#include "NegaMax.h"
+#include "Search.h"
 
 #include <algorithm>
 #include <atomic>
@@ -8,11 +8,11 @@
 #include "../data/Board.h"
 #include "../threads/NegaMaxThreadPool.h"
 
-bool NegaMax::s_QuiescenceSearchEnabled{};
-TranspositionTable NegaMax::s_SearchCache(1);
-short NegaMax::s_BestMoveFound{};
+bool Search::s_QuiescenceSearchEnabled{};
+TranspositionTable Search::s_SearchCache(1);
+short Search::s_BestMoveFound{};
 
-RootMove NegaMax::findBestMove(const Board &board, const Settings &settings)
+RootMove Search::findBestMove(const Board &board, const Settings &settings)
 {
 	const auto validMoves = board.listValidMoves<RootMove>();
 	assert(!validMoves.empty());
@@ -37,12 +37,12 @@ RootMove NegaMax::findBestMove(const Board &board, const Settings &settings)
 	return negaMaxRoot(validMoves, std::min<unsigned>(threadCount, validMoves.size()), depth);
 }
 
-short NegaMax::getBestMoveFound()
+short Search::getBestMoveFound()
 {
 	return s_BestMoveFound;
 }
 
-RootMove NegaMax::negaMaxRoot(const std::vector<RootMove> &validMoves, const unsigned jobCount, const short ply)
+RootMove Search::negaMaxRoot(const std::vector<RootMove> &validMoves, const unsigned jobCount, const short ply)
 {
 	std::vector<ThreadPool::TaskFuture<void>> futures;
 	futures.reserve(jobCount);
@@ -91,12 +91,12 @@ RootMove NegaMax::negaMaxRoot(const std::vector<RootMove> &validMoves, const uns
 	for (auto &future : futures)
 		future.get(); // Wait for the Search to finish
 
-	s_BestMoveFound = validMoves.front().board.colorToMove ? alpha : -alpha;
+	s_BestMoveFound = oppositeColor(validMoves.front().board.colorToMove) ? alpha : -alpha;
 
 	return bestMove;
 }
 
-short NegaMax::negaMax(const Board &board, const short ply, short alpha, short beta, const short depth, const bool moveCountPruning)
+short Search::negaMax(const Board &board, const short ply, short alpha, short beta, const short depth, const bool moveCountPruning)
 {
 	if (board.state == State::DRAW)
 		return 0;
@@ -210,7 +210,7 @@ short NegaMax::negaMax(const Board &board, const short ply, short alpha, short b
 	return alpha;
 }
 
-short NegaMax::quiescence(const Board &board, short alpha, const short beta)
+short Search::quiescence(const Board &board, short alpha, const short beta)
 {
 	if (board.state == State::DRAW)
 		return 0;
@@ -225,8 +225,8 @@ short NegaMax::quiescence(const Board &board, short alpha, const short beta)
 	// Delta Pruning
 	if (board.getPhase() != Phase::ENDING) // Turn it off in the Endgame
 	{
-		constexpr short QUEEN_VALUE = 2529;
-		constexpr short PAWN_VALUE = 136;
+		constexpr short QUEEN_VALUE = 2538;
+		constexpr short PAWN_VALUE = 128;
 
 		short bigDelta = QUEEN_VALUE;
 		if (board.isPromotion)
@@ -257,7 +257,7 @@ short NegaMax::quiescence(const Board &board, short alpha, const short beta)
 	return alpha;
 }
 
-short NegaMax::negaScout(const Board &board, const short ply, short alpha, const short beta, const bool isWhite, const short depth)
+short Search::negaScout(const Board &board, const short ply, short alpha, const short beta, const bool isWhite, const short depth)
 {
 	if (board.state == State::DRAW)
 		return 0;
@@ -294,7 +294,7 @@ short NegaMax::negaScout(const Board &board, const short ply, short alpha, const
 	return bestScore;
 }
 
-inline short NegaMax::sideToMove(const Board &board)
+inline short Search::sideToMove(const Board &board)
 {
 	const short value = Evaluation::evaluate(board);
 	return board.colorToMove ? value : -value;

ChessAndroid/app/src/main/cpp/chess/algorithm/NegaMax.h → ChessAndroid/app/src/main/cpp/chess/algorithm/Search.h

@@ -6,16 +6,16 @@ class Board;
 class RootMove;
 class Settings;
 
-class NegaMax final
+class Search final
 {
 	static bool s_QuiescenceSearchEnabled;
 	static TranspositionTable s_SearchCache;
 	static short s_BestMoveFound;
 
 public:
-	NegaMax() = delete;
-	NegaMax(const NegaMax&) = delete;
-	NegaMax(NegaMax&&) = delete;
+	Search() = delete;
+	Search(const Search&) = delete;
+	Search(Search&&) = delete;
 
 	static RootMove findBestMove(const Board &board, const Settings &settings);
 	static short getBestMoveFound();

ChessAndroid/app/src/main/java/net/theluckycoder/chess/ChessActivity.kt

@@ -11,6 +11,7 @@ import androidx.appcompat.app.AppCompatActivity
 import kotlinx.android.synthetic.main.activity_chess.*
 import kotlinx.android.synthetic.main.dialog_restart.view.*
 import net.theluckycoder.chess.utils.CapturedPieces
+import net.theluckycoder.chess.utils.PieceResourceManager
 import net.theluckycoder.chess.views.CustomView
 import net.theluckycoder.chess.views.PieceView
 import net.theluckycoder.chess.views.TileView

ChessAndroid/app/src/main/java/net/theluckycoder/chess/Data.kt

@@ -36,9 +36,8 @@ data class Pos(
 ) {
 
     constructor() : this(8, 8)
-    constructor(square: Byte) : this(square % 8, square / 8)
 
-    fun invertIf(invert: Boolean) = Pos(x, if (invert) 7 - y else y)
+    constructor(square: Byte) : this(square % 8, square / 8)
 
     val isValid
         get() = (x in 0..7 && y in 0..7)

ChessAndroid/app/src/main/java/net/theluckycoder/chess/GameManager.kt

@@ -110,4 +110,4 @@ class GameManager(
     }
 
     private external fun initBoardNative(restartGame: Boolean, isPlayerWhite: Boolean)
-}
+}

ChessAndroid/app/src/main/java/net/theluckycoder/chess/PieceResourceManager.kt → ChessAndroid/app/src/main/java/net/theluckycoder/chess/utils/PieceResourceManager.kt

@@ -1,19 +1,26 @@
-package net.theluckycoder.chess
+package net.theluckycoder.chess.utils
 
 import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.util.SparseArray
+import net.theluckycoder.chess.R
 
 object PieceResourceManager {
 
     val piecesResources = arrayOf(
-        R.drawable.w_pawn, R.drawable.w_knight,
-        R.drawable.w_bishop, R.drawable.w_rook,
-        R.drawable.w_queen, R.drawable.w_king,
-        R.drawable.b_pawn, R.drawable.b_knight,
-        R.drawable.b_bishop, R.drawable.b_rook,
-        R.drawable.b_queen, R.drawable.b_king
+        R.drawable.w_pawn,
+        R.drawable.w_knight,
+        R.drawable.w_bishop,
+        R.drawable.w_rook,
+        R.drawable.w_queen,
+        R.drawable.w_king,
+        R.drawable.b_pawn,
+        R.drawable.b_knight,
+        R.drawable.b_bishop,
+        R.drawable.b_rook,
+        R.drawable.b_queen,
+        R.drawable.b_king
     )
 
     private val piecesBitmaps = SparseArray<Bitmap>(piecesResources.size)

ChessAndroid/app/src/main/java/net/theluckycoder/chess/views/PieceView.kt

@@ -6,7 +6,7 @@ import android.graphics.BlurMaskFilter
 import android.graphics.Canvas
 import android.graphics.Paint
 import net.theluckycoder.chess.ChessActivity
-import net.theluckycoder.chess.PieceResourceManager
+import net.theluckycoder.chess.utils.PieceResourceManager
 import net.theluckycoder.chess.Pos
 
 @SuppressLint("ViewConstructor")