Not very good, but faster than v0.0.3b

Author: winapiadmin

chess.hpp

@@ -131,6 +131,7 @@ namespace utils {
 // Split a string by a delimiter
 [[nodiscard]] inline std::vector<std::string_view> splitString(std::string_view string, const char &delimiter) {
     std::vector<std::string_view> result;
+    result.reserve(100);
     size_t start = 0;
     size_t end   = string.find(delimiter);
 
@@ -1824,6 +1825,7 @@ class Board {
     std::vector<Move> move_stack;
     explicit Board(std::string_view fen = constants::STARTPOS, bool chess960 = false) {
         prev_states_.reserve(256);
+        move_stack.reserve(200);
         chess960_ = chess960;
         setFenInternal<true>(fen);
     }

eval.cpp

@@ -1,78 +1,63 @@
 #include "eval.h"
 
-std::map<unsigned long long, int> transposition;
-int eval(chess::Board board){
-    if (transposition.count(board.hash())) return transposition[board.hash()];
-    U64 hash=board.hash();
-	//Game over
-	if (board.inCheck()&&board.isGameOver().first!=chess::GameResultReason::NONE)return MAX;
-	else if (board.isGameOver().first!=chess::GameResultReason::NONE)return 0;
-	int eval=0;
-	//Material
-	eval+=Pawn*board.pieces(chess::PieceType::underlying::PAWN,chess::Color::underlying::WHITE).count();
-	eval+=Knight*board.pieces(chess::PieceType::underlying::KNIGHT,chess::Color::underlying::WHITE).count();
-	eval+=Bishop*board.pieces(chess::PieceType::underlying::BISHOP,chess::Color::underlying::WHITE).count();
-	eval+=Rook*board.pieces(chess::PieceType::underlying::ROOK,chess::Color::underlying::WHITE).count();
-	eval+=Queen*board.pieces(chess::PieceType::underlying::QUEEN,chess::Color::underlying::WHITE).count();
-	eval-=Pawn*board.pieces(chess::PieceType::underlying::PAWN,chess::Color::underlying::BLACK).count();
-	eval-=Knight*board.pieces(chess::PieceType::underlying::KNIGHT,chess::Color::underlying::BLACK).count();
-	eval-=Bishop*board.pieces(chess::PieceType::underlying::BISHOP,chess::Color::underlying::BLACK).count();
-	eval-=Rook*board.pieces(chess::PieceType::underlying::ROOK,chess::Color::underlying::BLACK).count();
-	eval-=Queen*board.pieces(chess::PieceType::underlying::QUEEN,chess::Color::underlying::BLACK).count();
-	//Pawns
-	eval -= isolated(board);
-	eval -= dblisolated(board);
-	eval -= weaks(board);
-    eval -= blockage(board);
-    eval += pawnIslands(board);
-    eval -= holes(board);
-    eval += pawnRace(board);
-    eval -= underpromote(board);
-    eval -= weakness(board);
-    eval += pawnShield(board);
-    eval += pawnStorm(board);
-    eval += pawnLevers(board);
-    eval += outpost(board);
-    eval -= evaluatePawnRams(board);
-    eval += evaluateUnfreePawns(board);
-    eval += evaluateOpenPawns(board);
-    eval -= evaluateBadBishops(board);
-    eval += evaluateFianchetto(board);
-    eval -= evaluateTrappedPieces(board);
-    eval -= evaluateKnightForks(board);
-    eval += evaluateRooksOnFiles(board);
+std::unordered_map<U64, int> transposition;  // Faster lookup
+
+// Declare only missing functions
+int evaluatePawnStructure(const chess::Board& board);
+int evaluatePieces(const chess::Board& board);
+
+int eval(const chess::Board& board) {
+    U64 hash = board.hash();
+
+    // Faster lookup & insertion
+    auto [it, inserted] = transposition.emplace(hash, 0);
+    if (!inserted) return it->second;  // Already exists, return stored evaluation
+
+    if (board.inCheck() && board.isGameOver().first != chess::GameResultReason::NONE) return MAX;
+    if (board.isGameOver().first != chess::GameResultReason::NONE) return 0;
+
+    // Precompute piece counts (avoid multiple function calls)
+    int pieceCount[10] = {
+        board.pieces(chess::PieceType::PAWN, chess::Color::WHITE).count(),
+        board.pieces(chess::PieceType::KNIGHT, chess::Color::WHITE).count(),
+        board.pieces(chess::PieceType::BISHOP, chess::Color::WHITE).count(),
+        board.pieces(chess::PieceType::ROOK, chess::Color::WHITE).count(),
+        board.pieces(chess::PieceType::QUEEN, chess::Color::WHITE).count(),
+        board.pieces(chess::PieceType::PAWN, chess::Color::BLACK).count(),
+        board.pieces(chess::PieceType::KNIGHT, chess::Color::BLACK).count(),
+        board.pieces(chess::PieceType::BISHOP, chess::Color::BLACK).count(),
+        board.pieces(chess::PieceType::ROOK, chess::Color::BLACK).count(),
+        board.pieces(chess::PieceType::QUEEN, chess::Color::BLACK).count(),
+    };
+
+    // Compute material score
+    int eval = (Pawn * (pieceCount[0] - pieceCount[5])) +
+               (Knight * (pieceCount[1] - pieceCount[6])) +
+               (Bishop * (pieceCount[2] - pieceCount[7])) +
+               (Rook * (pieceCount[3] - pieceCount[8])) +
+               (Queen * (pieceCount[4] - pieceCount[9]));
+
+    // Evaluate positional aspects
+    eval += evaluatePawnStructure(board);
+    eval += evaluatePieces(board);
     eval += evaluateKingSafety(board);
-    eval += evaluateKingPawnTropism(board);
-    eval += evaluateKingMobility(board);
-    eval += evaluateSpaceControl(board);
-    eval -= evaluateTactics(board);
-    board.pop();
-    eval -= -isolated(board);
-	eval -= -dblisolated(board);
-	eval -= -weaks(board);
-    eval -= -blockage(board);
-    eval += -pawnIslands(board);
-    eval -= -holes(board);
-    eval += -pawnRace(board);
-    eval -= -underpromote(board);
-    eval -= -weakness(board);
-    eval += -pawnShield(board);
-    eval += -pawnStorm(board);
-    eval += -pawnLevers(board);
-    eval += -outpost(board);
-    eval -= -evaluatePawnRams(board);
-    eval += -evaluateUnfreePawns(board);
-    eval += -evaluateOpenPawns(board);
-    eval -= -evaluateBadBishops(board);
-    eval += -evaluateFianchetto(board);
-    eval -= -evaluateTrappedPieces(board);
-    eval -= -evaluateKnightForks(board);
-    eval += -evaluateRooksOnFiles(board);
-    eval += -evaluateKingSafety(board);
-    eval += -evaluateKingPawnTropism(board);
-    eval += -evaluateKingMobility(board);
-    eval += -evaluateSpaceControl(board);
-    eval -= -evaluateTactics(board);
-    transposition[hash]=eval;
-	return eval;
+    eval += evaluateTactics(board);
+
+    it->second = eval;  // Store result
+    return eval;
+}
+
+// Use `const chess::Board&` to avoid copies
+int evaluatePawnStructure(const chess::Board& board) {
+    chess::Board b=board;
+    return -(isolated(board) + dblisolated(board) + weaks(board) + blockage(board) +
+             holes(board) + underpromote(b) + weakness(board) + evaluatePawnRams(board)) +
+           (pawnIslands(board) + pawnRace(board) + pawnShield(board) + pawnStorm(board) +
+            pawnLevers(board) + outpost(board) + evaluateUnfreePawns(board) + evaluateOpenPawns(board));
+}
+
+// Use `const chess::Board&` to avoid copies
+int evaluatePieces(const chess::Board& board) {
+    return -(evaluateBadBishops(board) + evaluateTrappedPieces(board) + evaluateKnightForks(board)) +
+           (evaluateFianchetto(board) + evaluateRooksOnFiles(board));
 }

eval.h

@@ -13,4 +13,4 @@
 #define Queen 900
 #define MATE(i) MAX-i
 #define MATE_DISTANCE(i) i-MAX_MATE
-int eval(chess::Board);
+int eval(const chess::Board&);

patterns.cpp

@@ -37,41 +37,54 @@ inline bool isTrappedPiece(const chess::Board& board, chess::Square pieceSq) {
         return true;
     }
 
+    // A knight is trapped if it has **no safe squares to jump to**
+    U64 pieceBB = 1ULL << pieceSq.index();  // Precompute once
+	U64 knightAttacks = getKnightAttacks(pieceBB, board.occ()), bishopAttacks=getBishopAttacks(pieceSq, board.occ()),
+	    rookAttacks = getRookAttacks(1ULL<<pieceSq.index(), board.occ()), queenAttacks=getQueenAttacks(pieceSq, board.occ());
+	chess::Piece p;
     // **3. Special Conditions for Specific Pieces**
     switch (type) {
         case chess::KNIGHT:
-            // A knight is trapped if it has **no safe squares to jump to**
-            for (chess::Square sq : scan_reversed(getKnightAttacks(1ULL << pieceSq.index(),board.occ()))) {
-                if (board.at(sq) == chess::Piece::NONE || board.at(sq).color() != side) {
+			while (knightAttacks) {
+    			int sq = __builtin_ctzll(knightAttacks);  // Extract LSB (fast)
+    			p=board.at(sq);
+                if (p == chess::Piece::NONE || p.color() != side) {
                     return false; // The knight has a safe escape
                 }
-            }
+    			knightAttacks &= knightAttacks - 1;  // Remove LSB
+			}
             return true;
 
         case chess::BISHOP:
-            // A bishop is trapped if **all diagonal escape squares are blocked**
-            for (chess::Square sq : scan_reversed(getBishopAttacks(pieceSq, board.occ()))) {
-                if (board.at(sq) == chess::Piece::NONE || board.at(sq).color() != side) {
+			while (bishopAttacks) {
+    			int sq = __builtin_ctzll(bishopAttacks);  // Extract LSB (fast)
+    			p=board.at(sq);
+                if (p == chess::Piece::NONE || p.color() != side) {
                     return false;
                 }
-            }
+    			bishopAttacks &= bishopAttacks - 1;  // Remove LSB
+			}
             return true;
 
         case chess::ROOK:
-            // A rook is trapped if **all rank/file escape squares are blocked**
-            for (chess::Square sq : scan_reversed(getRookAttacks(1ULL<<pieceSq.index(), board.occ()))) {
-                if (board.at(sq) == chess::Piece::NONE || board.at(sq).color() != side) {
+			while (rookAttacks) {
+    			int sq = __builtin_ctzll(rookAttacks);  // Extract LSB (fast)
+    			p=board.at(sq);
+                if (p == chess::Piece::NONE || p.color() != side) {
                     return false;
                 }
+    			rookAttacks &= rookAttacks - 1;  // Remove LSB
             }
             return true;
 
         case chess::QUEEN:
-            // A queen is trapped if **both bishop and rook movements are blocked**
-            for (chess::Square sq : scan_reversed(getQueenAttacks(pieceSq, board.occ()))) {
-                if (board.at(sq) == chess::Piece::NONE || board.at(sq).color() != side) {
+			while (queenAttacks) {
+    			int sq = __builtin_ctzll(queenAttacks);  // Extract LSB (fast)
+    			p=board.at(sq);
+                if (p == chess::Piece::NONE || p.color() != side) {
                     return false;
                 }
+    			queenAttacks &= queenAttacks - 1;  // Remove LSB
             }
             return true;
 
@@ -95,8 +108,11 @@ inline bool isPinned(chess::Board& board, chess::Square pieceSq) {
 
     return isPinned;
 }
-
+std::unordered_map<U64, int> tacticsCache;
 int evaluateTactics(const chess::Board& board) {
+    U64 hash = board.hash();
+    if (tacticsCache.find(hash) != tacticsCache.end()) return tacticsCache[hash];
+
     int score = 0;
 
     chess::Square myKing = board.kingSq(board.sideToMove());
@@ -143,15 +159,14 @@ int evaluateTactics(const chess::Board& board) {
             }
         }
     }
+    tacticsCache[hash] = score;
     return score;
 }
 
-
 // **8. King Patterns (Mobility & Escape Routes)**
 inline U64 getKingMobility(U64 king, U64 friendlyPieces) {
     return (king << 8 | king >> 8 | king << 1 | king >> 1) & ~friendlyPieces;
 }
-
 bool isLosingQueenPromotion(int pawn, U64 enemyKing, U64 enemyPieces, U64 friendlyPieces) {    
     // **1. Stalemate Check**
     U64 kingMobility = getKingMobility(enemyKing, enemyPieces | friendlyPieces);