feat: quiet move history

Added quiet move history. A quick test estimates an Elo level of roughly
1650 on CCRL scale.

Author: UndefinedCpp

config.json

@@ -5,8 +5,8 @@
 #include <cstring>
 #include <vector>
 
-constexpr short MAX_HISTORY_SCORE = 5000;
-constexpr short MIN_HISTORY_SCORE = -5000;
+constexpr short MAX_HISTORY_SCORE = 10000;
+constexpr short MIN_HISTORY_SCORE = -10000;
 
 /**
  * This class keeps track of the search history.
@@ -40,8 +40,25 @@ class SearchHistory {
         }
     };
 
+    struct QuietHistoryTable {
+        int16_t data[2][64][64];
+
+        void clear() { std::memset(data, 0, sizeof(data)); }
+
+        inline int16_t get(const Color stm, const Move& move) {
+            return data[(int) stm][move.from().index()][move.to().index()];
+        }
+        inline void update(const Color stm, const Move& move, int16_t bonus) {
+            int16_t& ref      = data[(int) stm][move.from().index()][move.to().index()];
+            int      newScore = bonus + ref;
+
+            ref = std::clamp(newScore, (int) MIN_HISTORY_SCORE, (int) MAX_HISTORY_SCORE);
+        }
+    };
+
 public:
-    KillerTable killerTable[MAX_PLY];
+    KillerTable       killerTable[MAX_PLY];
+    QuietHistoryTable qHistoryTable;
 
     void clear() {
         for (int i = 0; i < MAX_PLY; i++) {

src/history.h

@@ -209,8 +209,11 @@ void MovePicker::generateQuietMoves() {
         if (pos.at(move.from()).type() != PieceType::PAWN &&
             (attacks::pawn(pos.sideToMove(), move.to()) &
              pos.pieces(PieceType::PAWN, ~pos.sideToMove()))) {
-            score -= 200;
+            score -= 900;
         }
+        // Assign score from quiet history
+        int historyScore = history.qHistoryTable.get(pos.sideToMove(), move);
+        score += historyScore / 8;
 
         quietBuffer.emplace_back(ScoredMove {move.move(), score});
     }

src/movepick.cpp

@@ -61,4 +61,6 @@ class MovePicker {
 
     Move next();
     void skipQuiet();
+
+    const MovePickerStage& getStage() const { return stage; }
 };

src/movepick.h

@@ -103,6 +103,11 @@ Value qsearch(Position& pos, int depth, int ply, Value alpha, Value beta) {
             break;
         }
 
+        // Delta Pruning
+        if (!pos.inCheck() && standPat + Value(1000) < alpha) {
+            continue;
+        }
+
         pos.makeMove(m);
         Value score = -qsearch(pos, depth - 1, ply + 1, -beta, -alpha);
         pos.unmakeMove(m);
@@ -166,6 +171,9 @@ Value negamax(Position& pos, int depth, int ply, Value alpha, Value beta, bool c
 
     searchHistory.killerTable[ply + 1].clear();
     searchStats.nodes++;
+    if (ply == 0) {
+        searchHistory.qHistoryTable.clear();
+    }
 
     // Transposition table lookup
     // See if this node has been visited before. If so, we can reuse the data
@@ -271,9 +279,10 @@ Value negamax(Position& pos, int depth, int ply, Value alpha, Value beta, bool c
             currSS->bestMove = m;
             if (score >= beta) {
                 ttFlag = EntryType::LOWER_BOUND;
-                // Record quiet killer moves
+                // Update quiet history
                 if (!pos.isCapture(bestMove)) {
                     searchHistory.killerTable[ply].add(bestMove);
+                    searchHistory.qHistoryTable.update(pos.sideToMove(), bestMove, depth * depth);
                 }
                 break;
             }
@@ -303,15 +312,36 @@ void searchWorker(SearchParams params, Position pos) {
     Move  rootBestMove;
     Value rootBestScore = MATED_VALUE;
 
+    Value windowUpper = 20;
+    Value windowLower = 20;
+
     for (int depth = 1; depth <= maxDepth; ++depth) {
         if (g_stopRequested.load())
             break;
         if (g_timeControl.hitSoftLimit(depth, (int) searchStats.nodes, 0))
             break;
 
-        Value score = negamax<true>(pos, depth, 0, MATED_VALUE, MATE_VALUE, false);
-        if (g_stopRequested.load())
-            break;
+        // Aspiration window
+        Value score;
+        if (depth <= 3) {
+            score = negamax<true>(pos, depth, 0, MATED_VALUE, MATE_VALUE, false);
+        } else {
+            Value alpha = rootBestScore - windowLower;
+            Value beta  = rootBestScore + windowUpper;
+            score       = negamax<true>(pos, depth, 0, alpha, beta, false);
+            // Adjust window on fail-highs or fail-lows
+            if (score >= beta) {
+                windowUpper = std::min(MATE_VALUE, windowUpper * 2);
+                continue;
+            } else if (score <= alpha) {
+                windowLower = std::min(MATE_VALUE, windowLower * 2);
+                continue;
+            } else {
+                // Score within window, accept the score
+                windowUpper = 25;
+                windowLower = 25;
+            }
+        }
 
         auto pv = extractPv(pos, depth);
         if (!pv.empty())
@@ -326,6 +356,8 @@ void searchWorker(SearchParams params, Position pos) {
 
         if (g_timeControl.hitSoftLimit(depth, (int) searchStats.nodes, 0))
             break;
+        if (g_stopRequested.load())
+            break;
     }
 
     if (rootBestMove.move() != 0)