Remove QS_CHECKS movepick stage

I've tried this a few times in the last half a year, it had been stubbornly worth 1 elo. However, other recent movepick simplifs seem to have cleared the way for this: simplifications beget simplifications.

I assume that, like most other search/movepick simplifications in the last two years, this is a result of the NNUE eval. NNUE seems to make obsolete all the best search tweaks!

src/movegen.cpp

@@ -44,7 +44,7 @@ ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Bitboard target)
         else
         {
             // Generate cannon capture moves.
-            if (Type != QUIETS && Type != QUIET_CHECKS)
+            if (Type != QUIETS)
                 b |= attacks_bb<CANNON>(from, pos.pieces()) & pos.pieces(~Us);
 
             // Generate cannon quite moves.
@@ -56,12 +56,6 @@ ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Bitboard target)
                 b &= target;
         }
 
-        // To check, you either move freely a blocker or make a direct check.
-        if constexpr (Type == QUIET_CHECKS)
-            b &= Pt == CANNON ? ~line_bb(from, pos.king_square(~Us)) & pos.check_squares(Pt)
-               : (pos.blockers_for_king(~Us) & from) ? ~line_bb(from, pos.king_square(~Us))
-                                                     : pos.check_squares(Pt);
-
         while (b)
             *moveList++ = Move(from, pop_lsb(b));
     }
@@ -86,15 +80,13 @@ ExtMove* generate_all(const Position& pos, ExtMove* moveList) {
     const Square ksq    = pos.king_square(Us);
     Bitboard     target = Type == PSEUDO_LEGAL ? ~pos.pieces(Us)
                         : Type == CAPTURES     ? pos.pieces(~Us)
-                                               : ~pos.pieces();  // QUIETS || QUIET_CHECKS
+                                               : ~pos.pieces();  // QUIETS
 
     moveList = generate_moves<Us, Type>(pos, moveList, target);
 
-    if (Type != EVASIONS && (Type != QUIET_CHECKS || pos.blockers_for_king(~Us) & ksq))
+    if (Type != EVASIONS)
     {
         Bitboard b = attacks_bb<KING>(ksq) & target;
-        if constexpr (Type == QUIET_CHECKS)
-            b &= ~attacks_bb<ROOK>(pos.king_square(~Us));
 
         while (b)
             *moveList++ = Move(ksq, pop_lsb(b));
@@ -109,7 +101,6 @@ ExtMove* generate_all(const Position& pos, ExtMove* moveList) {
 // <CAPTURES>     Generates all pseudo-legal captures
 // <QUIETS>       Generates all pseudo-legal non-captures
 // <PSEUDO_LEGAL> Generates all pseudo-legal captures and non-captures
-// <QUIET_CHECKS> Generates all pseudo-legal non-captures giving check
 //
 // Returns a pointer to the end of the move list.
 template<GenType Type>
@@ -124,7 +115,6 @@ ExtMove* generate(const Position& pos, ExtMove* moveList) {
 // Explicit template instantiations
 template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
 template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
-template ExtMove* generate<QUIET_CHECKS>(const Position&, ExtMove*);
 template ExtMove* generate<PSEUDO_LEGAL>(const Position&, ExtMove*);
 
 

src/movegen.h

@@ -31,7 +31,6 @@ class Position;
 enum GenType {
     CAPTURES,
     QUIETS,
-    QUIET_CHECKS,
     EVASIONS,
     PSEUDO_LEGAL,
     LEGAL

src/movepick.cpp

@@ -52,9 +52,7 @@ enum Stages {
     // generate qsearch moves
     QSEARCH_TT,
     QCAPTURE_INIT,
-    QCAPTURE,
-    QCHECK_INIT,
-    QCHECK
+    QCAPTURE
 };
 
 // Sort moves in descending order up to and including a given limit.
@@ -323,24 +321,6 @@ Move MovePicker::next_move(bool skipQuiets) {
         return select<Next>([&]() { return pos.see_ge(*cur, threshold); });
 
     case QCAPTURE :
-        if (select<Next>([]() { return true; }))
-            return *(cur - 1);
-
-        // If we found no move and the depth is too low to try checks, then we have finished
-        if (depth <= DEPTH_QS_NORMAL)
-            return Move::none();
-
-        ++stage;
-        [[fallthrough]];
-
-    case QCHECK_INIT :
-        cur      = moves;
-        endMoves = generate<QUIET_CHECKS>(pos, cur);
-
-        ++stage;
-        [[fallthrough]];
-
-    case QCHECK :
         return select<Next>([]() { return true; });
     }
 

src/search.cpp

@@ -1369,12 +1369,6 @@ Value Search::Worker::qsearch(Position& pos, Stack* ss, Value alpha, Value beta,
 
     assert(0 <= ss->ply && ss->ply < MAX_PLY);
 
-    // Note that unlike regular search, which stores the literal depth into the
-    // transposition table, from qsearch we only store the current movegen stage
-    // as "depth". If in check, we search all evasions and thus store DEPTH_QS_CHECKS.
-    // Evasions may be quiet, and _CHECKS includes quiets.
-    Depth qsTtDepth = ss->inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS : DEPTH_QS_NORMAL;
-
     // Step 3. Transposition table lookup
     posKey                         = pos.key();
     auto [ttHit, ttData, ttWriter] = tt.probe(posKey);
@@ -1385,7 +1379,7 @@ Value Search::Worker::qsearch(Position& pos, Stack* ss, Value alpha, Value beta,
     pvHit        = ttHit && ttData.is_pv;
 
     // At non-PV nodes we check for an early TT cutoff
-    if (!PvNode && ttData.depth >= qsTtDepth
+    if (!PvNode && ttData.depth >= DEPTH_QS
         && ttData.value != VALUE_NONE  // Can happen when !ttHit or when access race in probe()
         && (ttData.bound & (ttData.value >= beta ? BOUND_LOWER : BOUND_UPPER)))
         return ttData.value;
@@ -1567,7 +1561,7 @@ Value Search::Worker::qsearch(Position& pos, Stack* ss, Value alpha, Value beta,
     // Save gathered info in transposition table. The static evaluation
     // is saved as it was before adjustment by correction history.
     ttWriter.write(posKey, value_to_tt(bestValue, ss->ply), pvHit,
-                   bestValue >= beta ? BOUND_LOWER : BOUND_UPPER, qsTtDepth, bestMove,
+                   bestValue >= beta ? BOUND_LOWER : BOUND_UPPER, DEPTH_QS, bestMove,
                    unadjustedStaticEval, tt.generation());
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);

src/types.h

@@ -181,8 +181,7 @@ enum : int {
     // quiescence search, however, the transposition table entries only store
     // the current quiescence move generation stage (which should thus compare
     // lower than any regular search depth).
-    DEPTH_QS_CHECKS = 0,
-    DEPTH_QS_NORMAL = -1,
+    DEPTH_QS = 0,
     // For transposition table entries where no searching at all was done
     // (whether regular or qsearch) we use DEPTH_UNSEARCHED, which should thus
     // compare lower than any quiescence or regular depth. DEPTH_ENTRY_OFFSET