Revert movepick optimizations before to release
authorMarco Costalba <mcostalba@gmail.com>
Sun, 2 Nov 2008 14:58:10 +0000 (15:58 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Sun, 2 Nov 2008 14:58:10 +0000 (15:58 +0100)
More testing is needed and better do not risk
just before release.

Reverted:

Disable LSN filtering as defualt for release
Use MVV/LVA in score_evasions()

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/movepick.cpp

index 59855dba66a56d0ab808f3f75bfce778aca4ee23..187a3c513e0275a112c377919a40d62cbdebf586 100644 (file)
@@ -206,22 +206,27 @@ 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.
   Move m;
+  int seeValue;
 
   for (int i = 0; i < numOfMoves; i++)
   {
       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)));
+      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 = seeValue;
   }
 }
 
@@ -251,26 +256,21 @@ void MovePicker::score_noncaptures() {
   }
 }
 
-void MovePicker::score_evasions() {\r
-\r
-  Move m;\r
-  int hs;\r
-\r
-  // Use MVV/LVA ordering\r
-   for (int i = 0; i < numOfMoves; i++)\r
-   {\r
-      m = moves[i].move;\r
-\r
-       if (m == ttMove)\r
-          hs = 2*HistoryMax;\r
-       else if (!pos.square_is_empty(move_to(m)))\r
-          hs = int(pos.midgame_value_of_piece_on(move_to(m)))\r
-              -int(pos.type_of_piece_on(move_from(m))) + HistoryMax;\r
-      else\r
-          hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);\r
-\r
-      moves[i].score = hs;\r
-  }\r
+void MovePicker::score_evasions() {
+
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      Move m = moves[i].move;
+      if (m == ttMove)
+          moves[i].score = 2*HistoryMax;
+      else if (!pos.square_is_empty(move_to(m)))
+      {
+          int seeScore = pos.see(m);
+          moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
+      } else
+          moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+  }
+  // FIXME try psqt also here
 }
 
 void MovePicker::score_qcaptures() {
@@ -325,21 +325,26 @@ Move MovePicker::pick_move_from_list() {
 
       while (movesPicked < numOfMoves)
       {
-          bestIndex = find_best_index();
-
-          if (bestIndex != -1) // Found a possibly good capture
+          int bestScore = -10000000;
+          bestIndex = -1;
+          for (int i = movesPicked; i < numOfMoves; i++)
           {
-              move = moves[bestIndex].move;
-              int seeValue = pos.see(move);
-              if (seeValue < 0)
+              if (moves[i].score < 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;
+                  badCaptures[numOfBadCaptures++] = moves[i];
+                  moves[i--] = moves[--numOfMoves];
               }
+              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