Add Generated Nodes to Stats

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

@@ -65,16 +65,19 @@ StackVector<Pos, 27> BoardManager::getPossibleMoves(const Pos &selectedPos)
 	const Piece &piece = s_Board.getPiece(startSq);
 	U64 possibleMoves = piece.getPossibleMoves(startSq, s_Board);
 
+	// Make sure we are not capturing the king
+	possibleMoves &= ~s_Board.getType(s_Board.colorToMove, KING);
+
 	while (possibleMoves)
 	{
 		const byte destSq = Bitboard::findNextSquare(possibleMoves);
-		const Piece &destPiece = s_Board.getPiece(destSq);
-		if (destPiece.type == PieceType::KING)
-			continue;
 
 		Board board = s_Board;
 		board.doMove(startSq, destSq);
 
+		if (!board.hasValidState())
+			continue;
+
 		moves.emplace_back(Pos(destSq));
 	}
 

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

@@ -2,45 +2,65 @@
 
 #include <sstream>
 
-std::chrono::time_point<std::chrono::steady_clock> Stats::_startTime;
-std::atomic_size_t Stats::boardsEvaluated;
-std::atomic_size_t Stats::nodesSearched;
+std::chrono::time_point<std::chrono::steady_clock> Stats::s_StartTime;
+std::atomic_size_t Stats::s_BoardsEvaluated;
+std::atomic_size_t Stats::s_NodesSearched;
+std::atomic_size_t Stats::s_NodesGenerated;
 
 void Stats::setEnabled(const bool enabled) noexcept
 {
-	_statsEnabled = enabled;
+	s_StatsEnabled = enabled;
 }
 
 void Stats::resetStats() noexcept
 {
-	boardsEvaluated = 0;
-	nodesSearched = 0;
+	s_BoardsEvaluated = 0;
+	s_NodesSearched = 0;
+	s_NodesGenerated = 0;
+}
+
+void Stats::incrementBoardsEvaluated() noexcept
+{
+	if (s_StatsEnabled)
+		++s_BoardsEvaluated;
+}
+
+void Stats::incrementNodesSearched() noexcept
+{
+	if (s_StatsEnabled)
+		++s_NodesSearched;
+}
+
+void Stats::incrementNodesGenerated(const std::size_t amount) noexcept
+{
+	if (s_StatsEnabled)
+		s_NodesGenerated += amount;
 }
 
 void Stats::startTimer() noexcept
 {
-	_startTime = std::chrono::high_resolution_clock::now();
-	_elapsedTime = 0;
+	s_StartTime = std::chrono::high_resolution_clock::now();
+	s_ElapsedTime = 0;
 }
 
 void Stats::stopTimer() noexcept
 {
 	const auto currentTime = std::chrono::high_resolution_clock::now();
-	_elapsedTime = std::chrono::duration<double, std::milli>(currentTime - _startTime).count();
+	s_ElapsedTime = std::chrono::duration<double, std::milli>(currentTime - s_StartTime).count();
 }
 
 double Stats::getElapsedTime() noexcept
 {
-	return _elapsedTime;
+	return s_ElapsedTime;
 }
 
 std::string Stats::formatStats(const char separator) noexcept(false)
 {
 	std::stringstream stream;
 
-	stream << "Boards Evaluated: " << static_cast<size_t>(boardsEvaluated) << separator
-		<< "Nodes Searched: " << static_cast<size_t>(nodesSearched) << separator
-		<< "Time Needed: " << _elapsedTime << " millis" << separator;
+	stream << "Boards Evaluated: " << static_cast<size_t>(s_BoardsEvaluated) << separator
+		<< "Nodes Searched: " << static_cast<size_t>(s_NodesSearched) << separator
+		<< "Nodes Generated: " << static_cast<size_t>(s_NodesGenerated) << separator;
 
 	return stream.str();
 }

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

@@ -6,22 +6,30 @@
 
 class Stats final
 {
-	inline static bool _statsEnabled = false;
-	inline static double _elapsedTime = 0;
-	static std::chrono::time_point<std::chrono::steady_clock> _startTime;
+	inline static bool s_StatsEnabled = false;
+	inline static double s_ElapsedTime = 0;
+	static std::chrono::time_point<std::chrono::steady_clock> s_StartTime;
+
+	static std::atomic_size_t s_BoardsEvaluated;
+	static std::atomic_size_t s_NodesSearched;
+	static std::atomic_size_t s_NodesGenerated;
 
 public:
 	Stats() = delete;
+	Stats(const Stats&) = delete;
+	Stats(Stats&&) = delete;
 
-	static std::atomic_size_t boardsEvaluated;
-	static std::atomic_size_t nodesSearched;
-	static std::atomic_size_t allocationsCount;
-
-	static bool enabled() noexcept { return _statsEnabled;  }
+	static bool isEnabled() noexcept { return s_StatsEnabled; }
 	static void setEnabled(bool enabled) noexcept;
 	static void resetStats() noexcept;
+
+	static void incrementBoardsEvaluated() noexcept;
+	static void incrementNodesSearched() noexcept;
+	static void incrementNodesGenerated(std::size_t amount) noexcept;
+
 	static void startTimer() noexcept;
 	static void stopTimer() noexcept;
 	static double getElapsedTime() noexcept;
+
 	static std::string formatStats(char separator) noexcept(false);
 };

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

@@ -89,8 +89,7 @@ short Evaluation::evaluate(const Board &board) noexcept
 	if (board.state == State::WINNER_BLACK)
 		return VALUE_WINNER_BLACK;
 
-	if (Stats::enabled())
-		++Stats::boardsEvaluated;
+	Stats::incrementBoardsEvaluated();
 
 	Score totalScore;
 

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

@@ -135,13 +135,13 @@ short Search::negaMax(const Board &board, const short ply, short alpha, short be
 			return cache.value;
 	}
 
-	if (Stats::enabled())
-		++Stats::nodesSearched;
-
 	const auto validMoves = board.listValidMoves<Board>();
 	short bestScore = VALUE_MIN;
 	short movesCount = 0;
 
+	Stats::incrementNodesSearched();
+	Stats::incrementNodesGenerated(validMoves.size());
+
 	for (const Board &move : validMoves)
 	{
 		if (move.state == State::WINNER_WHITE || move.state == State::WINNER_BLACK)
@@ -244,8 +244,8 @@ short Search::quiescence(const Board &board, short alpha, const short beta)
 
 	const auto validMoves = board.listQuiescenceMoves();
 
-	if (Stats::enabled())
-		++Stats::nodesSearched;
+	Stats::incrementNodesSearched();
+	Stats::incrementNodesGenerated(validMoves.size());
 
 	for (const Board &move : validMoves)
 	{