X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovepick.cpp;h=ce82a59ba3dd14441f431cf42c0692d0824bcefa;hb=08e0f52b77edb929989c68c49e954b9bc5d7d67e;hp=6aa1954b5ae67ccee5108b8de2729f43dc46b03b;hpb=dc5d9bdfee70f4267d9a49ad71e5ee478dd50ca5;p=stockfish

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 6aa1954b..ce82a59b 100644
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -1,6 +1,6 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
+  Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -87,8 +87,8 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHist
 
 /// MovePicker constructor for ProbCut: we generate captures with SEE greater
 /// than or equal to the given threshold.
-MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph)
-           : pos(p), captureHistory(cph), ttMove(ttm), threshold(th)
+MovePicker::MovePicker(const Position& p, Move ttm, Value th, Depth d, const CapturePieceToHistory* cph)
+           : pos(p), captureHistory(cph), ttMove(ttm), threshold(th), depth(d)
 {
   assert(!pos.checkers());
 
@@ -97,6 +97,44 @@ MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePiece
                              && 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.
@@ -105,17 +143,52 @@ void MovePicker::score() {
 
   static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type");
 
+  Bitboard threatened, 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;
+  }
+
   for (auto& m : *this)
       if constexpr (Type == CAPTURES)
-          m.value =  int(PieceValue[MG][pos.piece_on(to_sq(m))]) * 6
-                   + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))];
+          m.value =  6 * int(PieceValue[MG][pos.piece_on(to_sq(m))])
+                   +     (*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)]
                    + 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)];
+                   +     (*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);
 
       else // Type == EVASIONS
       {
@@ -169,11 +242,12 @@ top:
       endMoves = generate<CAPTURES>(pos, cur);
 
       score<CAPTURES>();
+      partial_insertion_sort(cur, endMoves, -3000 * depth);
       ++stage;
       goto top;
 
   case GOOD_CAPTURE:
-      if (select<Best>([&](){
+      if (select<Next>([&](){
                        return pos.see_ge(*cur, Value(-69 * cur->value / 1024)) ?
                               // Move losing capture to endBadCaptures to be tried later
                               true : (*endBadCaptures++ = *cur, false); }))
@@ -241,10 +315,10 @@ top:
       return select<Best>([](){ return true; });
 
   case PROBCUT:
-      return select<Best>([&](){ return pos.see_ge(*cur, threshold); });
+      return select<Next>([&](){ return pos.see_ge(*cur, threshold); });
 
   case QCAPTURE:
-      if (select<Best>([&](){ return   depth > DEPTH_QS_RECAPTURES
+      if (select<Next>([&](){ return   depth > DEPTH_QS_RECAPTURES
                                     || to_sq(*cur) == recaptureSquare; }))
           return *(cur - 1);