X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovepick.cpp;h=4050810338fd1e3d5ce840bdbae86b10ca3fc84e;hb=65ece7d985291cc787d6c804a33f1dd82b75736d;hp=564adc286ea8221e01cac1dce4ac3d2d5cf72ca1;hpb=7cf93f8b7101e5cf5df3f7921861f27b3beb9525;p=stockfish

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 564adc28..40508103 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-2022 The Stockfish developers (see AUTHORS file)
+  Copyright (C) 2004-2023 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
@@ -69,7 +69,6 @@ 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
@@ -93,7 +92,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePiece
 {
   assert(!pos.checkers());
 
-  stage = PROBCUT_TT + !(ttm && pos.capture(ttm)
+  stage = PROBCUT_TT + !(ttm && pos.capture_stage(ttm)
                              && pos.pseudo_legal(ttm)
                              && pos.see_ge(ttm, threshold));
 }
@@ -106,7 +105,7 @@ void MovePicker::score() {
 
   static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type");
 
-  [[maybe_unused]] Bitboard threatenedByPawn, threatenedByMinor, threatenedByRook;
+  [[maybe_unused]] Bitboard threatenedByPawn, threatenedByMinor, threatenedByRook, threatenedPieces;
   if constexpr (Type == QUIETS)
   {
       Color us = pos.side_to_move();
@@ -124,24 +123,48 @@ void MovePicker::score() {
   for (auto& m : *this)
       if constexpr (Type == CAPTURES)
           m.value =  (7 * 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)))]) / 16;
+                   + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))]) / 16;
 
       else if constexpr (Type == QUIETS)
-          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)]
-                   +     (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;
+      {
+          Piece     pc   = pos.moved_piece(m);
+          PieceType pt   = type_of(pos.moved_piece(m));
+          Square    from = from_sq(m);
+          Square    to   = to_sq(m);
+
+          // histories
+          m.value =  2 * (*mainHistory)[pos.side_to_move()][from_to(m)];
+          m.value += 2 * (*continuationHistory[0])[pc][to];
+          m.value +=     (*continuationHistory[1])[pc][to];
+          m.value +=     (*continuationHistory[3])[pc][to];
+          m.value +=     (*continuationHistory[5])[pc][to];
+
+          // bonus for checks
+          m.value += bool(pos.check_squares(pt) & to) * 16384;
+
+          // bonus for escaping from capture
+          m.value += threatenedPieces & from ?
+                       (pt == QUEEN && !(to & threatenedByRook)  ? 50000
+                      : pt == ROOK  && !(to & threatenedByMinor) ? 25000
+                      :                !(to & threatenedByPawn)  ? 15000
+                      :                                            0 )
+                      :                                            0 ;
+
+          // malus for putting piece en prise
+          m.value -= !(threatenedPieces & from) ?
+                        (pt == QUEEN ?   bool(to & threatenedByRook)  * 50000
+                                       + bool(to & threatenedByMinor) * 10000
+                                       + bool(to & threatenedByPawn)  * 20000
+                       : pt == ROOK  ?   bool(to & threatenedByMinor) * 25000
+                                       + bool(to & threatenedByPawn)  * 10000
+                       : pt != PAWN ?    bool(to & threatenedByPawn)  * 15000
+                       :                                                0 )
+                       :                                                0 ;
+      }
+      
       else // Type == EVASIONS
       {
-          if (pos.capture(m))
+          if (pos.capture_stage(m))
               m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
                        - Value(type_of(pos.moved_piece(m)))
                        + (1 << 28);
@@ -158,7 +181,7 @@ Move MovePicker::select(Pred filter) {
 
   while (cur < endMoves)
   {
-      if (T == Best)
+      if constexpr (T == Best)
           std::swap(*cur, *std::max_element(cur, endMoves));
 
       if (*cur != ttMove && filter())
@@ -216,7 +239,7 @@ top:
 
   case REFUTATION:
       if (select<Next>([&](){ return    *cur != MOVE_NONE
-                                    && !pos.capture(*cur)
+                                    && !pos.capture_stage(*cur)
                                     &&  pos.pseudo_legal(*cur); }))
           return *(cur - 1);
       ++stage;