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

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 68f03a30..c71572e7 100644
--- 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
@@ -205,37 +206,48 @@ 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
+  // 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.
+  // the subtree size. Instead of calculating SEE here to filter out 
+  // loosing captures, we delay the filtering in pick_move_from_list()
+  Move m;
+
   for (int i = 0; i < numOfMoves; i++)
   {
-      int seeValue = pos.see(moves[i].move);
-      if (seeValue >= 0)
-      {
-          if (move_promotion(moves[i].move))
-              moves[i].score = QueenValueMidgame;
-          else
-              moves[i].score = int(pos.midgame_value_of_piece_on(move_to(moves[i].move)))
-                              -int(pos.type_of_piece_on(move_from(moves[i].move)));
-      } else
-          moves[i].score = seeValue;
+      m = moves[i].move;
+      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)));
   }
 }
 
 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;
+  int hs;
 
   for (int i = 0; i < numOfMoves; i++)
   {
-      Move m = moves[i].move;
+      m = moves[i].move;
+
       if (m == killer1)
-          moves[i].score = HistoryMax + 2;
+          hs = HistoryMax + 2;
       else if (m == killer2)
-          moves[i].score = HistoryMax + 1;
+          hs = HistoryMax + 1;
       else
-         moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+          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);
   }
 }
 
@@ -266,7 +278,7 @@ void MovePicker::score_qcaptures() {
           moves[i].score = QueenValueMidgame;
       else
           moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
-                          -int(pos.midgame_value_of_piece_on(move_to(m))) / 64;
+                          -int(pos.type_of_piece_on(move_from(m)));
   }
 }
 
@@ -308,26 +320,21 @@ Move MovePicker::pick_move_from_list() {
 
       while (movesPicked < numOfMoves)
       {
-          int bestScore = -10000000;
-          bestIndex = -1;
-          for (int i = movesPicked; i < numOfMoves; i++)
+          bestIndex = find_best_index();
+
+          if (bestIndex != -1) // Found a possibly good capture
           {
-              if (moves[i].score < 0)
+              move = moves[bestIndex].move;
+              int seeValue = pos.see(move);
+              if (seeValue < 0)
               {
                   // Losing capture, move it to the badCaptures[] array
                   assert(numOfBadCaptures < 63);
-                  badCaptures[numOfBadCaptures++] = moves[i];
-                  moves[i--] = moves[--numOfMoves];
+                  moves[bestIndex].score = seeValue;
+                  badCaptures[numOfBadCaptures++] = moves[bestIndex];
+                  moves[bestIndex] = moves[--numOfMoves];
+                  continue;
               }
-              else if (moves[i].score > bestScore)
-              {
-                  bestIndex = i;
-                  bestScore = moves[i].score;
-              }
-          }
-          if (bestIndex != -1) // Found a good capture
-          {
-              move = moves[bestIndex].move;
               moves[bestIndex] = moves[movesPicked++];
               if (   move != ttMove
                   && move != mateKiller