Sync connected_threat() and yields_to_threat()
[stockfish] / src / search.cpp
index 9f617210662d1ead5f8347b3a497976d3f26e7df..35160b9665a39d6ed99bae69da65940ebf9f049b 100644 (file)
@@ -100,11 +100,11 @@ namespace {
   Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth);
 
   void id_loop(Position& pos);
-  bool check_is_dangerous(Position& pos, Move move, Value futilityBase, Value beta);
-  bool yields_to_threat(const Position& pos, Move move, Move threat);
   Value value_to_tt(Value v, int ply);
   Value value_from_tt(Value v, int ply);
-  bool connected_threat(const Position& pos, Move m, Move threat);
+  bool check_is_dangerous(Position& pos, Move move, Value futilityBase, Value beta);
+  bool yields_to_threat(const Position& pos, Move move, Move threat);
+  bool prevents_threat(const Position& pos, Move move, Move threat);
   string uci_pv(const Position& pos, int depth, Value alpha, Value beta);
 
   struct Skill {
@@ -861,7 +861,7 @@ split_point_start: // At split points actual search starts from here
           // Move count based pruning
           if (   depth < 16 * ONE_PLY
               && moveCount >= FutilityMoveCounts[depth]
-              && (!threatMove || !connected_threat(pos, move, threatMove)))
+              && (!threatMove || !prevents_threat(pos, move, threatMove)))
           {
               if (SpNode)
                   sp->mutex.lock();
@@ -1363,32 +1363,30 @@ split_point_start: // At split points actual search starts from here
 
     assert(is_ok(move));
     assert(is_ok(threat));
+    assert(color_of(pos.piece_on(from_sq(threat))) == ~pos.side_to_move());
 
-    Square t1 = to_sq(move);
-    Square f1 = from_sq(move);
-    Square t2 = to_sq(threat);
-    Square f2 = from_sq(threat);
-
-    // We are suposed to be called upon returning from a null search
-    assert(color_of(pos.piece_on(f2)) == ~pos.side_to_move());
+    Square mfrom = from_sq(move);
+    Square mto = to_sq(move);
+    Square tfrom = from_sq(threat);
+    Square tto = to_sq(threat);
 
     // The piece is the same or threat's destination was vacated by the move
-    if (t1 == f2 || t2 == f1)
+    if (mto == tfrom || tto == mfrom)
         return true;
 
     // Threat moves through the vacated square
-    if (between_bb(f2, t2) & f1)
+    if (between_bb(tfrom, tto) & mfrom)
       return true;
 
     // Threat's destination is defended by the move's piece
-    Bitboard t1_att = pos.attacks_from(pos.piece_on(t1), t1, pos.pieces() ^ f2);
-    if (t1_att & t2)
+    Bitboard matt = pos.attacks_from(pos.piece_on(mto), mto, pos.pieces() ^ tfrom);
+    if (matt & tto)
         return true;
 
     // Threat gives a discovered check through the move's checking piece
-    if (t1_att & pos.king_square(pos.side_to_move()))
+    if (matt & pos.king_square(pos.side_to_move()))
     {
-        assert(between_bb(t1, pos.king_square(pos.side_to_move())) & f2);
+        assert(between_bb(mto, pos.king_square(pos.side_to_move())) & tfrom);
         return true;
     }
 
@@ -1396,27 +1394,28 @@ split_point_start: // At split points actual search starts from here
   }
 
 
-  // connected_threat() tests whether it is safe to forward prune a move or if
-  // is somehow connected to the threat move returned by null search.
+  // prevents_threat() tests whether a move is able to defend against the so
+  // called threat move (the best move returned from a null search that fails
+  // low). In this case will not be pruned.
 
-  bool connected_threat(const Position& pos, Move m, Move threat) {
+  bool prevents_threat(const Position& pos, Move move, Move threat) {
 
-    assert(is_ok(m));
+    assert(is_ok(move));
     assert(is_ok(threat));
-    assert(!pos.is_capture_or_promotion(m));
-    assert(!pos.is_passed_pawn_push(m));
+    assert(!pos.is_capture_or_promotion(move));
+    assert(!pos.is_passed_pawn_push(move));
 
-    Square mfrom = from_sq(m);
-    Square mto = to_sq(m);
+    Square mfrom = from_sq(move);
+    Square mto = to_sq(move);
     Square tfrom = from_sq(threat);
     Square tto = to_sq(threat);
 
-    // Case 1: Don't prune moves which move the threatened piece
+    // Don't prune moves of the threatened piece
     if (mfrom == tto)
         return true;
 
-    // Case 2: If the threatened piece has value less than or equal to the
-    // value of the threatening piece, don't prune moves which defend it.
+    // If the threatened piece has value less than or equal to the value of the
+    // threat piece, don't prune moves which defend it.
     if (    pos.is_capture(threat)
         && (   PieceValue[MG][pos.piece_on(tfrom)] >= PieceValue[MG][pos.piece_on(tto)]
             || type_of(pos.piece_on(tfrom)) == KING))
@@ -1438,11 +1437,10 @@ split_point_start: // At split points actual search starts from here
             return true;
     }
 
-    // Case 3: If the moving piece in the threatened move is a slider, don't
-    // prune safe moves which block its ray.
+    // If the threat piece is a slider, don't prune safe moves which block it
     if (    piece_is_slider(pos.piece_on(tfrom))
         && (between_bb(tfrom, tto) & mto)
-        &&  pos.see_sign(m) >= 0)
+        &&  pos.see_sign(move) >= 0)
         return true;
 
     return false;