X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.cpp;h=1519f85d04388c1b24940a31c4babf65ea33f7e0;hp=c71572e7cf86bead8aa853dd16db512ab329e55d;hb=2ed22e4fc80313f69cbdfe0a617a70188813b16e;hpb=d087b0a34a6aaa0fc31d2fa256b02861d0351256

diff --git a/src/movepick.cpp b/src/movepick.cpp
index c71572e7..1519f85d 100644
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -134,6 +134,7 @@ Move MovePicker::get_next_move() {
     case PH_GOOD_CAPTURES:
         numOfMoves = generate_captures(pos, moves);
         score_captures();
+        capSquares = EmptyBoardBB;
         movesPicked = 0;
         break;
 
@@ -206,22 +207,36 @@ void MovePicker::score_captures() {
   // Suprisingly, this appears to perform slightly better than SEE based
   // move ordering.  The reason is probably that in a position with a winning
   // capture, capturing a more valuable (but sufficiently defended) piece
-  // first usually doesn't hurt. The opponent will have to recapture, and
+  // first usually doesn't hurt.  The opponent will have to recapture, and
   // the hanging piece will still be hanging (except in the unusual cases
   // 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. Instead of calculating SEE here to filter out 
-  // loosing captures, we delay the filtering in pick_move_from_list()
+  // the subtree size.
+  // While scoring captures it moves all captures with negative SEE values
+  // to the badCaptures[] array.
   Move m;
+  int seeValue;
 
   for (int i = 0; i < numOfMoves; i++)
   {
       m = moves[i].move;
-      if (move_promotion(m))
-          moves[i].score = QueenValueMidgame;
+      seeValue = pos.see(m);
+      if (seeValue >= 0)
+      {
+          if (move_promotion(m))
+              moves[i].score = QueenValueMidgame;
+          else
+              moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
+                              -int(pos.type_of_piece_on(move_from(m)));
+      }
       else
-          moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
-                          -int(pos.type_of_piece_on(move_from(m)));
+      {
+          // Losing capture, move it to the badCaptures[] array
+          assert(numOfBadCaptures < 63);
+          moves[i].score = seeValue;
+          badCaptures[numOfBadCaptures++] = moves[i];
+          moves[i--] = moves[--numOfMoves];
+      }
   }
 }
 
@@ -283,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
+/// the highest scored one. There is also a second version that
+/// lowers the priority of moves that attack the same square,
+/// so that if the best move that attack a square fails the next
+/// move picked attacks a different square if any, not the same one.
 
 int MovePicker::find_best_index() {
 
@@ -299,14 +317,48 @@ int MovePicker::find_best_index() {
   return bestIndex;
 }
 
+int MovePicker::find_best_index(Bitboard* squares, int values[]) {
+
+  int hs;
+  Move m;
+  Square to;
+  int bestScore = -10000000, bestIndex = -1;
+
+  for (int i = movesPicked; i < numOfMoves; i++)
+  {
+      m = moves[i].move;
+      to = move_to(m);
+      
+      if (!bit_is_set(*squares, to))
+      {
+          // Init at first use
+          set_bit(squares, to);
+          values[to] = 0;
+      }
+
+      hs = moves[i].score - values[to];
+      if (hs > bestScore)
+      {
+          bestIndex = i;
+          bestScore = hs;
+      }
+  }
+
+  if (bestIndex != -1)
+  {
+      // Raise value of the picked square, so next attack
+      // to the same square will get low priority.
+      to = move_to(moves[bestIndex].move);
+      values[to] += 0xB00;
+  }
+  return bestIndex;
+}
+
 
 /// 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() {
 
@@ -322,19 +374,9 @@ Move MovePicker::pick_move_from_list() {
       {
           bestIndex = find_best_index();
 
-          if (bestIndex != -1) // Found a possibly good capture
+          if (bestIndex != -1) // Found a good capture
           {
               move = moves[bestIndex].move;
-              int seeValue = pos.see(move);
-              if (seeValue < 0)
-              {
-                  // Losing capture, move it to the badCaptures[] array
-                  assert(numOfBadCaptures < 63);
-                  moves[bestIndex].score = seeValue;
-                  badCaptures[numOfBadCaptures++] = moves[bestIndex];
-                  moves[bestIndex] = moves[--numOfMoves];
-                  continue;
-              }
               moves[bestIndex] = moves[movesPicked++];
               if (   move != ttMove
                   && move != mateKiller