MovePicker:find bad captures during scoring

[stockfish] / src / movepick.cpp

diff --git a/src/movepick.cpp b/src/movepick.cpp
index b115e8ffb1a9c3b9a6a1c6371ffef62067eea3e3..1519f85d04388c1b24940a31c4babf65ea33f7e0 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -8,6 +8,7 @@
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
+
   Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -133,6 +134,7 @@ Move MovePicker::get_next_move() {
     case PH_GOOD_CAPTURES:
         numOfMoves = generate_captures(pos, moves);
         score_captures();
+        capSquares = EmptyBoardBB;
         movesPicked = 0;
         break;
 
@@ -210,6 +212,8 @@ void MovePicker::score_captures() {
   // where it is possible to recapture with the hanging piece). Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.
+  // While scoring captures it moves all captures with negative SEE values
+  // to the badCaptures[] array.
   Move m;
   int seeValue;
 
@@ -224,8 +228,15 @@ void MovePicker::score_captures() {
           else
               moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
                               -int(pos.type_of_piece_on(move_from(m)));
-      } else
+      }
+      else
+      {
+          // Losing capture, move it to the badCaptures[] array
+          assert(numOfBadCaptures < 63);
           moves[i].score = seeValue;
+          badCaptures[numOfBadCaptures++] = moves[i];
+          moves[i--] = moves[--numOfMoves];
+      }
   }
 }
 
@@ -233,25 +244,25 @@ void MovePicker::score_noncaptures() {
   // First score by history, when no history is available then use
   // piece/square tables values. This seems to be better then a
   // random choice when we don't have an history for any move.
-  Move m;\r
-  int hs;\r
-\r
-  for (int i = 0; i < numOfMoves; i++)\r
-  {\r
-      m = moves[i].move;\r
-\r
-      if (m == killer1)\r
-          hs = HistoryMax + 2;\r
-      else if (m == killer2)\r
-          hs = HistoryMax + 1;\r
-      else\r
-          hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);\r
-\r
-      // Ensure moves in history are always sorted as first\r
-      if (hs > 0)\r
-          hs += 1000;\r
-\r
-      moves[i].score = hs + pos.mg_pst_delta(m);\r
+  Move m;
+  int hs;
+
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      m = moves[i].move;
+
+      if (m == killer1)
+          hs = HistoryMax + 2;
+      else if (m == killer2)
+          hs = HistoryMax + 1;
+      else
+          hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+
+      // Ensure moves in history are always sorted as first
+      if (hs > 0)
+          hs += 1000;
+
+      moves[i].score = hs + pos.mg_pst_delta(m);
   }
 }
 
@@ -287,8 +298,11 @@ void MovePicker::score_qcaptures() {
 }
 
 
-/// find_best_index() loops across the moves and returns index of
-/// the highest scored one.
+/// find_best_index() loops across the moves and returns index of\r
+/// the highest scored one. There is also a second version that\r
+/// lowers the priority of moves that attack the same square,\r
+/// so that if the best move that attack a square fails the next\r
+/// move picked attacks a different square if any, not the same one.
 
 int MovePicker::find_best_index() {
 
@@ -303,14 +317,48 @@ int MovePicker::find_best_index() {
   return bestIndex;
 }
 
+int MovePicker::find_best_index(Bitboard* squares, int values[]) {\r
+\r
+  int hs;\r
+  Move m;\r
+  Square to;\r
+  int bestScore = -10000000, bestIndex = -1;\r
+\r
+  for (int i = movesPicked; i < numOfMoves; i++)\r
+  {\r
+      m = moves[i].move;\r
+      to = move_to(m);\r
+      \r
+      if (!bit_is_set(*squares, to))\r
+      {\r
+          // Init at first use\r
+          set_bit(squares, to);\r
+          values[to] = 0;\r
+      }\r
+\r
+      hs = moves[i].score - values[to];\r
+      if (hs > bestScore)\r
+      {\r
+          bestIndex = i;\r
+          bestScore = hs;\r
+      }\r
+  }\r
+\r
+  if (bestIndex != -1)\r
+  {\r
+      // Raise value of the picked square, so next attack\r
+      // to the same square will get low priority.\r
+      to = move_to(moves[bestIndex].move);\r
+      values[to] += 0xB00;\r
+  }\r
+  return bestIndex;\r
+}
+
 
 /// MovePicker::pick_move_from_list() picks the move with the biggest score
 /// from a list of generated moves (moves[] or badCaptures[], depending on
 /// the current move generation phase).  It takes care not to return the
 /// transposition table move if that has already been serched previously.
-/// While picking captures in the PH_GOOD_CAPTURES phase (i.e. while picking
-/// non-losing captures in the main search), it moves all captures with
-/// negative SEE values to the badCaptures[] array.
 
 Move MovePicker::pick_move_from_list() {
 
@@ -324,23 +372,8 @@ Move MovePicker::pick_move_from_list() {
 
       while (movesPicked < numOfMoves)
       {
-          int bestScore = -10000000;
-          bestIndex = -1;
-          for (int i = movesPicked; i < numOfMoves; i++)
-          {
-              if (moves[i].score < 0)
-              {
-                  // Losing capture, move it to the badCaptures[] array
-                  assert(numOfBadCaptures < 63);
-                  badCaptures[numOfBadCaptures++] = moves[i];
-                  moves[i--] = moves[--numOfMoves];
-              }
-              else if (moves[i].score > bestScore)
-              {
-                  bestIndex = i;
-                  bestScore = moves[i].score;
-              }
-          }
+          bestIndex = find_best_index();
+
           if (bestIndex != -1) // Found a good capture
           {
               move = moves[bestIndex].move;