Do not use SEE in evasion scoring

[stockfish] / src / movepick.cpp

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 622ef8a9a9dd896ea9dbcab8257dc7a1ee4cac3a..1ec56c2f700a7c2a30bedd371af100fc6a29e9ec 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -26,13 +26,12 @@
 namespace {
 
   enum Stages {
-    MAIN_SEARCH, GOOD_CAPTURES_INIT, GOOD_CAPTURES, KILLERS, KILLERS_2,
-    QUIET_INIT, QUIET, BAD_CAPTURES,
-    EVASION, ALL_EVASIONS,
-    QSEARCH_WITH_CHECKS, QCAPTURES_CHECKS_INIT, QCAPTURES_CHECKS, CHECKS,
-    QSEARCH_WITHOUT_CHECKS, QCAPTURES_NO_CHECKS, REMAINING,
-    RECAPTURE, RECAPTURES,
-    PROBCUT, PROBCUT_INIT, PROBCUT_CAPTURES
+    MAIN_SEARCH, CAPTURES_INIT, GOOD_CAPTURES, KILLERS, COUNTERMOVE, QUIET_INIT, QUIET, BAD_CAPTURES,
+    EVASION, EVASIONS_INIT, ALL_EVASIONS,
+    PROBCUT, PROBCUT_INIT, PROBCUT_CAPTURES,
+    QSEARCH_WITH_CHECKS, QCAPTURES_1_INIT, QCAPTURES_1, QCHECKS,
+    QSEARCH_NO_CHECKS, QCAPTURES_2_INIT, QCAPTURES_2,
+    QSEARCH_RECAPTURES, QRECAPTURES
   };
 
   // Our insertion sort, which is guaranteed to be stable, as it should be
@@ -92,11 +91,11 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, Square s)
       stage = QSEARCH_WITH_CHECKS;
 
   else if (d > DEPTH_QS_RECAPTURES)
-      stage = QSEARCH_WITHOUT_CHECKS;
+      stage = QSEARCH_NO_CHECKS;
 
   else
   {
-      stage = RECAPTURE;
+      stage = QSEARCH_RECAPTURES;
       recaptureSquare = s;
       return;
   }
@@ -160,19 +159,13 @@ void MovePicker::score<QUIETS>() {
 
 template<>
 void MovePicker::score<EVASIONS>() {
-  // Try winning and equal captures ordered by MVV/LVA, then non-captures ordered
-  // by history value, then bad captures and quiet moves with a negative SEE ordered
-  // by SEE value.
+  // Try captures ordered by MVV/LVA, then non-captures ordered by history value
   const HistoryStats& history = pos.this_thread()->history;
   const FromToStats& fromTo = pos.this_thread()->fromTo;
   Color c = pos.side_to_move();
-  Value see;
 
   for (auto& m : *this)
-      if ((see = pos.see_sign(m)) < VALUE_ZERO)
-          m.value = see - HistoryStats::Max; // At the bottom
-
-      else if (pos.capture(m))
+      if (pos.capture(m))
           m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
                    - Value(type_of(pos.moved_piece(m))) + HistoryStats::Max;
       else
@@ -192,11 +185,11 @@ Move MovePicker::next_move() {
   switch (stage) {
 
   case MAIN_SEARCH: case EVASION: case QSEARCH_WITH_CHECKS:
-  case QSEARCH_WITHOUT_CHECKS: case PROBCUT:
+  case QSEARCH_NO_CHECKS: case PROBCUT:
       ++stage;
       return ttMove;
 
-  case GOOD_CAPTURES_INIT:
+  case CAPTURES_INIT:
       endBadCaptures = cur = moves;
       endMoves = generate<CAPTURES>(pos, cur);
       score<CAPTURES>();
@@ -215,10 +208,9 @@ Move MovePicker::next_move() {
               *endBadCaptures++ = move;
           }
       }
-      ++stage;
 
-      // First killer move
-      move = ss->killers[0];
+      ++stage;
+      move = ss->killers[0];  // First killer move
       if (    move != MOVE_NONE
           &&  move != ttMove
           &&  pos.pseudo_legal(move)
@@ -234,7 +226,7 @@ Move MovePicker::next_move() {
           && !pos.capture(move))
           return move;
 
-  case KILLERS_2:
+  case COUNTERMOVE:
       ++stage;
       move = countermove;
       if (    move != MOVE_NONE
@@ -276,72 +268,77 @@ Move MovePicker::next_move() {
           return *cur++;
       break;
 
-  case ALL_EVASIONS:
+  case EVASIONS_INIT:
       cur = moves;
       endMoves = generate<EVASIONS>(pos, cur);
-      if (endMoves - cur > 1)
+      if (endMoves - cur - (ttMove != MOVE_NONE) > 1)
           score<EVASIONS>();
-      stage = REMAINING;
-      goto remaining;
-
-  case QCAPTURES_CHECKS_INIT:
-  case QCAPTURES_NO_CHECKS:
-      cur = moves;
-      endMoves = generate<CAPTURES>(pos, cur);
-      score<CAPTURES>();
       ++stage;
 
-remaining:
-  case QCAPTURES_CHECKS:
-  case REMAINING:
+  case ALL_EVASIONS:
       while (cur < endMoves)
       {
           move = pick_best(cur++, endMoves);
           if (move != ttMove)
               return move;
       }
-      if (stage == REMAINING)
-          break;
+      break;
+
+  case PROBCUT_INIT:
       cur = moves;
-      endMoves = generate<QUIET_CHECKS>(pos, cur);
+      endMoves = generate<CAPTURES>(pos, cur);
+      score<CAPTURES>();
       ++stage;
 
-  case CHECKS:
+  case PROBCUT_CAPTURES:
       while (cur < endMoves)
       {
-          move = cur++->move;
-          if (move != ttMove)
+          move = pick_best(cur++, endMoves);
+          if (   move != ttMove
+              && pos.see(move) > threshold)
               return move;
       }
       break;
 
-  case RECAPTURE:
+  case QCAPTURES_1_INIT: case QCAPTURES_2_INIT:
       cur = moves;
       endMoves = generate<CAPTURES>(pos, cur);
       score<CAPTURES>();
       ++stage;
 
-  case RECAPTURES:
+  case QCAPTURES_1: case QCAPTURES_2:
       while (cur < endMoves)
       {
           move = pick_best(cur++, endMoves);
-          if (to_sq(move) == recaptureSquare)
+          if (move != ttMove)
+              return move;
+      }
+      if (stage == QCAPTURES_2)
+          break;
+      cur = moves;
+      endMoves = generate<QUIET_CHECKS>(pos, cur);
+      ++stage;
+
+  case QCHECKS:
+      while (cur < endMoves)
+      {
+          move = cur++->move;
+          if (move != ttMove)
               return move;
       }
       break;
 
-  case PROBCUT_INIT:
+  case QSEARCH_RECAPTURES:
       cur = moves;
       endMoves = generate<CAPTURES>(pos, cur);
       score<CAPTURES>();
       ++stage;
 
-  case PROBCUT_CAPTURES:
+  case QRECAPTURES:
       while (cur < endMoves)
       {
           move = pick_best(cur++, endMoves);
-          if (   move != ttMove
-              && pos.see(move) > threshold)
+          if (to_sq(move) == recaptureSquare)
               return move;
       }
       break;