Fix some silly bugs

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index e9941287f0ef2ad0fdf3c5d574219c9a4ccab603..6bc77d3ba61224197a72a5ada11e509ef08103c6 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -703,6 +703,7 @@ namespace {
     // Initialize
     TT.new_search();
     H.clear();
+    MG.clear();
     init_ss_array(ss);
     IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
     Iteration = 1;
@@ -1358,7 +1359,7 @@ namespace {
     Move ttMove, move;
     Depth ext, newDepth;
     Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled;
-    bool isCheck, useFutilityPruning, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
+    bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
     futilityValue = staticValue = bestValue = value = -VALUE_INFINITE;
@@ -1402,7 +1403,7 @@ namespace {
 
     // Calculate depth dependant futility pruning parameters
     const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8));
-    const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
+    const int PostFutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
 
     // Evaluate the position statically
     if (!isCheck)
@@ -1416,7 +1417,7 @@ namespace {
         }
 
         ss[ply].eval = staticValue;
-        futilityValue = staticValue + FutilityValueMargin;
+        futilityValue = staticValue + PostFutilityValueMargin; //FIXME: Remove me, only for split
         staticValue = refine_eval(tte, staticValue, ply); // Enhance accuracy with TT value if possible
 
         // Store gain statistics
@@ -1428,6 +1429,10 @@ namespace {
             MG.store(pos.piece_on(move_to(m)), move_from(m), move_to(m), ss[ply - 1].eval, -ss[ply].eval);
     }
 
+    // Post futility pruning
+    if (depth < SelectiveDepth && staticValue - PostFutilityValueMargin >= beta)
+        return (staticValue - PostFutilityValueMargin);
+
     // Null move search
     if (    allowNullmove
         &&  depth > OnePly
@@ -1505,7 +1510,6 @@ namespace {
     // to search all moves.
     MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
     CheckInfo ci(pos);
-    useFutilityPruning = depth < SelectiveDepth && !isCheck;
 
     // Loop through all legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
@@ -1551,10 +1555,34 @@ namespace {
       // Update current move
       movesSearched[moveCount++] = ss[ply].currentMove = move;
 
+      // Futility pruning for captures
+      Color them = opposite_color(pos.side_to_move());
+
+      if (   !isCheck
+          && newDepth < SelectiveDepth
+          && !dangerous
+          && pos.move_is_capture(move)
+          && !pos.move_is_check(move, ci)
+          && !move_is_promotion(move)
+          && move != ttMove
+          && !move_is_ep(move)
+          && (pos.type_of_piece_on(move_to(move)) != PAWN || !pos.pawn_is_passed(them, move_to(move)))) // Do not prune passed pawn captures
+      {
+          int preFutilityValueMargin = 0;
+
+          if (newDepth >= OnePly)
+              preFutilityValueMargin = 112 * bitScanReverse32(int(newDepth) * int(newDepth) / 2);
+
+          if (ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90 < beta)
+              continue;
+      }
+
+
       // Futility pruning
-      if (    useFutilityPruning
+      if (   !isCheck
           && !dangerous
           && !captureOrPromotion
+          && !move_is_castle(move)
           &&  move != ttMove)
       {
           // Move count based pruning
@@ -1564,13 +1592,29 @@ namespace {
               continue;
 
           // Value based pruning
-          futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
+          Depth predictedDepth = newDepth;
+
+          //FIXME HACK: awful code duplication
+          double red = 0.5 + ln(moveCount) * ln(depth / 2) / 3.0;
+          if (red >= 1.0)
+              predictedDepth -= int(floor(red * int(OnePly)));
 
-          if (futilityValueScaled < beta)
+          if (predictedDepth < SelectiveDepth)
           {
-              if (futilityValueScaled > bestValue)
-                  bestValue = futilityValueScaled;
-              continue;
+              int preFutilityValueMargin = 0;
+              if (predictedDepth >= OnePly)
+                  preFutilityValueMargin = 112 * bitScanReverse32(int(predictedDepth) * int(predictedDepth) / 2);
+
+              preFutilityValueMargin += MG.retrieve(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45;
+
+              futilityValueScaled = ss[ply].eval + preFutilityValueMargin - moveCount * IncrementalFutilityMargin;
+
+              if (futilityValueScaled < beta)
+              {
+                  if (futilityValueScaled > bestValue)
+                      bestValue = futilityValueScaled;
+                  continue;
+              }
           }
       }
 
@@ -1625,7 +1669,7 @@ namespace {
           && idle_thread_exists(threadID)
           && !AbortSearch
           && !thread_should_stop(threadID)
-          && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue,
+          && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
                    depth, &moveCount, &mp, threadID, false))
           break;
     }
@@ -2509,9 +2553,8 @@ namespace {
 
     Square mfrom, mto, tfrom, tto;
 
-    // Prune if there isn't any threat move and
-    // is not a castling move (common case).
-    if (threat == MOVE_NONE && !move_is_castle(m))
+    // Prune if there isn't any threat move
+    if (threat == MOVE_NONE)
         return true;
 
     mfrom = move_from(m);
@@ -2519,15 +2562,11 @@ namespace {
     tfrom = move_from(threat);
     tto = move_to(threat);
 
-    // Case 1: Castling moves are never pruned
-    if (move_is_castle(m))
-        return false;
-
-    // Case 2: Don't prune moves which move the threatened piece
+    // Case 1: Don't prune moves which move the threatened piece
     if (mfrom == tto)
         return false;
 
-    // Case 3: If the threatened piece has value less than or equal to the
+    // Case 2: If the threatened piece has value less than or equal to the
     // value of the threatening piece, don't prune move which defend it.
     if (   pos.move_is_capture(threat)
         && (   pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
@@ -2535,7 +2574,7 @@ namespace {
         && pos.move_attacks_square(m, tto))
         return false;
 
-    // Case 4: If the moving piece in the threatened move is a slider, don't
+    // Case 3: If the moving piece in the threatened move is a slider, don't
     // prune safe moves which block its ray.
     if (   piece_is_slider(pos.piece_on(tfrom))
         && bit_is_set(squares_between(tfrom, tto), mto)