Use TT moves more often in qsearch

[stockfish] / src / movepick.cpp

diff --git a/src/movepick.cpp b/src/movepick.cpp
index ce82a59ba3dd14441f431cf42c0692d0824bcefa..587c6d79c0e0188b1df0ac740d335b449401b7f1 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -18,6 +18,7 @@
 
 #include <cassert>
 
+#include "bitboard.h"
 #include "movepick.h"
 
 namespace Stockfish {
@@ -68,6 +69,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHist
 
   stage = (pos.checkers() ? EVASION_TT : MAIN_TT) +
           !(ttm && pos.pseudo_legal(ttm));
+  threatenedPieces = 0;
 }
 
 /// MovePicker constructor for quiescence search
@@ -81,7 +83,6 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHist
 
   stage = (pos.checkers() ? EVASION_TT : QSEARCH_TT) +
           !(   ttm
-            && (pos.checkers() || depth > DEPTH_QS_RECAPTURES || to_sq(ttm) == recaptureSquare)
             && pos.pseudo_legal(ttm));
 }
 
@@ -97,44 +98,6 @@ MovePicker::MovePicker(const Position& p, Move ttm, Value th, Depth d, const Cap
                              && pos.see_ge(ttm, threshold));
 }
 
-//squares threatened by pawn attacks
-template <Color Us>
-Bitboard threatsByPawn (const Position& pos)
-{
-    return pawn_attacks_bb<Us>(pos.pieces(Us, PAWN));
-}
-
-//squares threatened by minor attacks
-template <Color Us>
-Bitboard threatsByMinor (const Position& pos)
-{
-    Bitboard our = pos.pieces(Us, KNIGHT, BISHOP);
-    Bitboard threats = 0;
-    while (our)
-    {
-        Square s = pop_lsb(our);
-        if (type_of(pos.piece_on(s)) == KNIGHT)
-            threats |= attacks_bb<KNIGHT>(s, pos.pieces());
-        else
-            threats |= attacks_bb<BISHOP>(s, pos.pieces());
-    }
-    return threats;
-}
-
-//squares threatened by rook attacks
-template <Color Us>
-Bitboard threatsByRook (const Position& pos)
-{
-    Bitboard our = pos.pieces(Us, ROOK);
-    Bitboard threats = 0;
-    while (our)
-    {
-        Square s = pop_lsb(our);
-        threats |= attacks_bb<ROOK>(s, pos.pieces());
-    }
-    return threats;
-}
-
 /// MovePicker::score() assigns a numerical value to each move in a list, used
 /// for sorting. Captures are ordered by Most Valuable Victim (MVV), preferring
 /// captures with a good history. Quiets moves are ordered using the histories.
@@ -143,33 +106,19 @@ void MovePicker::score() {
 
   static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type");
 
-  Bitboard threatened, threatenedByPawn, threatenedByMinor, threatenedByRook;
+  [[maybe_unused]] Bitboard threatenedByPawn, threatenedByMinor, threatenedByRook;
   if constexpr (Type == QUIETS)
   {
-      // squares threatened by pawns
-      threatenedByPawn   = pos.side_to_move() == WHITE ? threatsByPawn<BLACK>(pos)  : threatsByPawn<WHITE>(pos);
-      // squares threatened by minors or pawns
-      threatenedByMinor  = pos.side_to_move() == WHITE ? threatsByMinor<BLACK>(pos) : threatsByMinor<WHITE>(pos);
-      threatenedByMinor |= threatenedByPawn;
-      // squares threatened by rooks, minors or pawns
-      threatenedByRook   = pos.side_to_move() == WHITE ? threatsByRook<BLACK>(pos)  : threatsByRook<WHITE>(pos);
-      threatenedByRook  |= threatenedByMinor;
-
-      // pieces threatened by pieces of lesser material value
-      threatened = pos.side_to_move() == WHITE ? ((pos.pieces(WHITE, QUEEN) & threatenedByRook) |
-                                                  (pos.pieces(WHITE, ROOK) & threatenedByMinor) |
-                                                  (pos.pieces(WHITE, KNIGHT, BISHOP) & threatenedByPawn))
-                                               : ((pos.pieces(BLACK, QUEEN) & threatenedByRook) |
-                                                  (pos.pieces(BLACK, ROOK) & threatenedByMinor) |
-                                                  (pos.pieces(BLACK, KNIGHT, BISHOP) & threatenedByPawn));
-  }
-  else
-  {
-      // Silence unused variable warning
-      (void) threatened;
-      (void) threatenedByPawn;
-      (void) threatenedByMinor;
-      (void) threatenedByRook;
+      Color us = pos.side_to_move();
+
+      threatenedByPawn  = pos.attacks_by<PAWN>(~us);
+      threatenedByMinor = pos.attacks_by<KNIGHT>(~us) | pos.attacks_by<BISHOP>(~us) | threatenedByPawn;
+      threatenedByRook  = pos.attacks_by<ROOK>(~us) | threatenedByMinor;
+
+      // Pieces threatened by pieces of lesser material value
+      threatenedPieces = (pos.pieces(us, QUEEN) & threatenedByRook)
+                       | (pos.pieces(us, ROOK)  & threatenedByMinor)
+                       | (pos.pieces(us, KNIGHT, BISHOP) & threatenedByPawn);
   }
 
   for (auto& m : *this)
@@ -178,27 +127,27 @@ void MovePicker::score() {
                    +     (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))];
 
       else if constexpr (Type == QUIETS)
-          m.value =      (*mainHistory)[pos.side_to_move()][from_to(m)]
+          m.value =  2 * (*mainHistory)[pos.side_to_move()][from_to(m)]
                    + 2 * (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)]
                    +     (*continuationHistory[1])[pos.moved_piece(m)][to_sq(m)]
                    +     (*continuationHistory[3])[pos.moved_piece(m)][to_sq(m)]
                    +     (*continuationHistory[5])[pos.moved_piece(m)][to_sq(m)]
-                   +     (threatened & from_sq(m) ?
-                           (type_of(pos.piece_on(from_sq(m))) == QUEEN && !(to_sq(m) & threatenedByRook)  ? 50000
-                          : type_of(pos.piece_on(from_sq(m))) == ROOK  && !(to_sq(m) & threatenedByMinor) ? 25000
-                          :                                               !(to_sq(m) & threatenedByPawn)  ? 15000
-                          :                                                                                 0)
-                          :                                                                                 0);
-
+                   +     (threatenedPieces & from_sq(m) ?
+                           (type_of(pos.moved_piece(m)) == QUEEN && !(to_sq(m) & threatenedByRook)  ? 50000
+                          : type_of(pos.moved_piece(m)) == ROOK  && !(to_sq(m) & threatenedByMinor) ? 25000
+                          :                                         !(to_sq(m) & threatenedByPawn)  ? 15000
+                          :                                                                           0)
+                          :                                                                           0)
+                   +     bool(pos.check_squares(type_of(pos.moved_piece(m))) & to_sq(m)) * 16384;
       else // Type == EVASIONS
       {
           if (pos.capture(m))
               m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
-                       - Value(type_of(pos.moved_piece(m)));
+                       - Value(type_of(pos.moved_piece(m)))
+                       + (1 << 28);
           else
-              m.value =      (*mainHistory)[pos.side_to_move()][from_to(m)]
-                       + 2 * (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)]
-                       - (1 << 28);
+              m.value =  (*mainHistory)[pos.side_to_move()][from_to(m)]
+                       + (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)];
       }
 }