X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=dc6ad98b10a937d07997f52f8cf5faed61e8914a;hp=eb7666afd5142b85c624fabaeeba71b7dce04b77;hb=853e2a9495afbe5789727c4c666c73c8276d8585;hpb=1d0159075e916c738760b788d605b71b3736cb7c

diff --git a/src/search.cpp b/src/search.cpp
index eb7666af..dc6ad98b 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -318,8 +318,8 @@ void init_search() {
 }
 
 
-/// perft() is our utility to verify move generation. All the legal moves up to
-/// given depth are generated and counted and the sum returned.
+/// perft() is our utility to verify move generation. All the leaf nodes up to
+/// the given depth are generated and counted and the sum returned.
 
 int64_t perft(Position& pos, Depth depth) {
 
@@ -341,7 +341,7 @@ int64_t perft(Position& pos, Depth depth) {
   for (MoveStack* cur = mlist; cur != last; cur++)
   {
       m = cur->move;
-      pos.do_move(m, st, ci, pos.move_is_check(m, ci));
+      pos.do_move(m, st, ci, pos.move_gives_check(m, ci));
       sum += perft(pos, depth - ONE_PLY);
       pos.undo_move(m);
   }
@@ -394,7 +394,7 @@ bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) {
 
   // Read UCI options
   UCIMultiPV = Options["MultiPV"].value<int>();
-  SkillLevel = Options["Skill level"].value<int>();
+  SkillLevel = Options["Skill Level"].value<int>();
 
   read_evaluation_uci_options(pos.side_to_move());
   Threads.read_uci_options();
@@ -512,7 +512,7 @@ namespace {
     if (Rml.size() == 0)
     {
         cout << "info depth 0 score "
-             << value_to_uci(pos.is_check() ? -VALUE_MATE : VALUE_DRAW)
+             << value_to_uci(pos.in_check() ? -VALUE_MATE : VALUE_DRAW)
              << endl;
 
         return MOVE_NONE;
@@ -681,14 +681,14 @@ namespace {
     ValueType vt;
     Value bestValue, value, oldAlpha;
     Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
-    bool isPvMove, isCheck, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous, isBadCap;
+    bool isPvMove, inCheck, singularExtensionNode, givesCheck, captureOrPromotion, dangerous;
     int moveCount = 0, playedMoveCount = 0;
     int threadID = pos.thread();
     SplitPoint* sp = NULL;
 
     refinedValue = bestValue = value = -VALUE_INFINITE;
     oldAlpha = alpha;
-    isCheck = pos.is_check();
+    inCheck = pos.in_check();
     ss->ply = (ss-1)->ply + 1;
 
     // Used to send selDepth info to GUI
@@ -753,7 +753,7 @@ namespace {
     }
 
     // Step 5. Evaluate the position statically and update parent's gain statistics
-    if (isCheck)
+    if (inCheck)
         ss->eval = ss->evalMargin = VALUE_NONE;
     else if (tte)
     {
@@ -775,7 +775,7 @@ namespace {
     // Step 6. Razoring (is omitted in PV nodes)
     if (   !PvNode
         &&  depth < RazorDepth
-        && !isCheck
+        && !inCheck
         &&  refinedValue + razor_margin(depth) < beta
         &&  ttMove == MOVE_NONE
         &&  abs(beta) < VALUE_MATE_IN_PLY_MAX
@@ -795,7 +795,7 @@ namespace {
     if (   !PvNode
         && !ss->skipNullMove
         &&  depth < RazorDepth
-        && !isCheck
+        && !inCheck
         &&  refinedValue - futility_margin(depth, 0) >= beta
         &&  abs(beta) < VALUE_MATE_IN_PLY_MAX
         &&  pos.non_pawn_material(pos.side_to_move()))
@@ -805,7 +805,7 @@ namespace {
     if (   !PvNode
         && !ss->skipNullMove
         &&  depth > ONE_PLY
-        && !isCheck
+        && !inCheck
         &&  refinedValue >= beta
         &&  abs(beta) < VALUE_MATE_IN_PLY_MAX
         &&  pos.non_pawn_material(pos.side_to_move()))
@@ -863,7 +863,7 @@ namespace {
     // Step 9. Internal iterative deepening
     if (   depth >= IIDDepth[PvNode]
         && ttMove == MOVE_NONE
-        && (PvNode || (!isCheck && ss->eval + IIDMargin >= beta)))
+        && (PvNode || (!inCheck && ss->eval + IIDMargin >= beta)))
     {
         Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2);
 
@@ -871,8 +871,8 @@ namespace {
         search<PvNode>(pos, ss, alpha, beta, d);
         ss->skipNullMove = false;
 
-        ttMove = ss->bestMove;
         tte = TT.probe(posKey);
+        ttMove = tte ? tte->move() : MOVE_NONE;
     }
 
 split_point_start: // At split points actual search starts from here
@@ -880,13 +880,13 @@ split_point_start: // At split points actual search starts from here
     // Initialize a MovePicker object for the current position
     MovePickerExt<SpNode, Root> mp(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
     CheckInfo ci(pos);
+    Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
     ss->bestMove = MOVE_NONE;
     futilityBase = ss->eval + ss->evalMargin;
     singularExtensionNode =   !Root
                            && !SpNode
                            && depth >= SingularExtensionDepth[PvNode]
-                           && tte
-                           && tte->move()
+                           && ttMove != MOVE_NONE
                            && !excludedMove // Do not allow recursive singular extension search
                            && (tte->type() & VALUE_TYPE_LOWER)
                            && tte->depth() >= depth - 3 * ONE_PLY;
@@ -904,13 +904,18 @@ split_point_start: // At split points actual search starts from here
     {
       assert(move_is_ok(move));
 
+      if (move == excludedMove)
+          continue;
+
+      // At PV and SpNode nodes we want the moves to be legal
+      if ((PvNode || SpNode) && !pos.pl_move_is_legal(move, pinned))
+          continue;
+
       if (SpNode)
       {
           moveCount = ++sp->moveCount;
           lock_release(&(sp->lock));
       }
-      else if (move == excludedMove)
-          continue;
       else
           moveCount++;
 
@@ -937,11 +942,11 @@ split_point_start: // At split points actual search starts from here
 
       // At Root and at first iteration do a PV search on all the moves to score root moves
       isPvMove = (PvNode && moveCount <= (Root ? depth <= ONE_PLY ? 1000 : MultiPV : 1));
-      moveIsCheck = pos.move_is_check(move, ci);
-      captureOrPromotion = pos.move_is_capture_or_promotion(move);
+      givesCheck = pos.move_gives_check(move, ci);
+      captureOrPromotion = pos.move_is_capture(move) || move_is_promotion(move);
 
       // Step 11. Decide the new search depth
-      ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, &dangerous);
+      ext = extension<PvNode>(pos, move, captureOrPromotion, givesCheck, &dangerous);
 
       // Singular extension search. If all moves but one fail low on a search of
       // (alpha-s, beta-s), and just one fails high on (alpha, beta), then that move
@@ -949,7 +954,8 @@ split_point_start: // At split points actual search starts from here
       // on all the other moves but the ttMove, if result is lower than ttValue minus
       // a margin then we extend ttMove.
       if (   singularExtensionNode
-          && move == tte->move()
+          && move == ttMove
+          && pos.pl_move_is_legal(move, pinned)
           && ext < ONE_PLY)
       {
           Value ttValue = value_from_tt(tte->value(), ss->ply);
@@ -969,13 +975,12 @@ split_point_start: // At split points actual search starts from here
       }
 
       // Update current move (this must be done after singular extension search)
-      ss->currentMove = move;
       newDepth = depth - ONE_PLY + ext;
 
       // Step 12. Futility pruning (is omitted in PV nodes)
       if (   !PvNode
           && !captureOrPromotion
-          && !isCheck
+          && !inCheck
           && !dangerous
           &&  move != ttMove
           && !move_is_castle(move))
@@ -1024,18 +1029,17 @@ split_point_start: // At split points actual search starts from here
           }
       }
 
-      // Bad capture detection. Will be used by prob-cut search
-      isBadCap =   depth >= 3 * ONE_PLY
-                && depth < 8 * ONE_PLY
-                && captureOrPromotion
-                && move != ttMove
-                && !dangerous
-                && !move_is_promotion(move)
-                &&  abs(alpha) < VALUE_MATE_IN_PLY_MAX
-                &&  pos.see_sign(move) < 0;
+      // Check for legality only before to do the move
+      if (!pos.pl_move_is_legal(move, pinned))
+      {
+          moveCount--;
+          continue;
+      }
+
+      ss->currentMove = move;
 
       // Step 13. Make the move
-      pos.do_move(move, st, ci, moveIsCheck);
+      pos.do_move(move, st, ci, givesCheck);
 
       if (!SpNode && !captureOrPromotion)
           movesSearched[playedMoveCount++] = move;
@@ -1067,7 +1071,6 @@ split_point_start: // At split points actual search starts from here
               ss->reduction = reduction<PvNode>(depth, moveCount);
               if (ss->reduction)
               {
-                  alpha = SpNode ? sp->alpha : alpha;
                   Depth d = newDepth - ss->reduction;
                   value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d);
 
@@ -1078,7 +1081,13 @@ split_point_start: // At split points actual search starts from here
 
           // Probcut search for bad captures. If a reduced search returns a value
           // very below beta then we can (almost) safely prune the bad capture.
-          if (isBadCap)
+          if (   depth >= 3 * ONE_PLY
+              && depth < 8 * ONE_PLY
+              && mp.isBadCapture()
+              && move != ttMove
+              && !dangerous
+              && !move_is_promotion(move)
+              &&  abs(alpha) < VALUE_MATE_IN_PLY_MAX)
           {
               ss->reduction = 3 * ONE_PLY;
               Value rAlpha = alpha - 300;
@@ -1202,7 +1211,7 @@ split_point_start: // At split points actual search starts from here
     // no legal moves, it must be mate or stalemate.
     // If one move was excluded return fail low score.
     if (!SpNode && !moveCount)
-        return excludedMove ? oldAlpha : isCheck ? value_mated_in(ss->ply) : VALUE_DRAW;
+        return excludedMove ? oldAlpha : inCheck ? value_mated_in(ss->ply) : VALUE_DRAW;
 
     // Step 20. Update tables
     // If the search is not aborted, update the transposition table,
@@ -1217,7 +1226,8 @@ split_point_start: // At split points actual search starts from here
 
         // Update killers and history only for non capture moves that fails high
         if (    bestValue >= beta
-            && !pos.move_is_capture_or_promotion(move))
+            && !pos.move_is_capture(move)
+            && !move_is_promotion(move))
         {
             if (move != ss->killers[0])
             {
@@ -1257,7 +1267,7 @@ split_point_start: // At split points actual search starts from here
     StateInfo st;
     Move ttMove, move;
     Value bestValue, value, evalMargin, futilityValue, futilityBase;
-    bool isCheck, enoughMaterial, moveIsCheck, evasionPrunable;
+    bool inCheck, enoughMaterial, givesCheck, evasionPrunable;
     const TTEntry* tte;
     Depth ttDepth;
     Value oldAlpha = alpha;
@@ -1272,8 +1282,8 @@ split_point_start: // At split points actual search starts from here
     // Decide whether or not to include checks, this fixes also the type of
     // TT entry depth that we are going to use. Note that in qsearch we use
     // only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS.
-    isCheck = pos.is_check();
-    ttDepth = (isCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS : DEPTH_QS_NO_CHECKS);
+    inCheck = pos.in_check();
+    ttDepth = (inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS : DEPTH_QS_NO_CHECKS);
 
     // Transposition table lookup. At PV nodes, we don't use the TT for
     // pruning, but only for move ordering.
@@ -1287,7 +1297,7 @@ split_point_start: // At split points actual search starts from here
     }
 
     // Evaluate the position statically
-    if (isCheck)
+    if (inCheck)
     {
         bestValue = futilityBase = -VALUE_INFINITE;
         ss->eval = evalMargin = VALUE_NONE;
@@ -1330,6 +1340,7 @@ split_point_start: // At split points actual search starts from here
     // be generated.
     MovePicker mp(pos, ttMove, depth, H);
     CheckInfo ci(pos);
+    Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
 
     // Loop through the moves until no moves remain or a beta cutoff occurs
     while (   alpha < beta
@@ -1337,12 +1348,12 @@ split_point_start: // At split points actual search starts from here
     {
       assert(move_is_ok(move));
 
-      moveIsCheck = pos.move_is_check(move, ci);
+      givesCheck = pos.move_gives_check(move, ci);
 
       // Futility pruning
       if (   !PvNode
-          && !isCheck
-          && !moveIsCheck
+          && !inCheck
+          && !givesCheck
           &&  move != ttMove
           &&  enoughMaterial
           && !move_is_promotion(move)
@@ -1367,14 +1378,15 @@ split_point_start: // At split points actual search starts from here
       }
 
       // Detect non-capture evasions that are candidate to be pruned
-      evasionPrunable =   isCheck
+      evasionPrunable =   !PvNode
+                       && inCheck
                        && bestValue > VALUE_MATED_IN_PLY_MAX
                        && !pos.move_is_capture(move)
                        && !pos.can_castle(pos.side_to_move());
 
       // Don't search moves with negative SEE values
       if (   !PvNode
-          && (!isCheck || evasionPrunable)
+          && (!inCheck || evasionPrunable)
           &&  move != ttMove
           && !move_is_promotion(move)
           &&  pos.see_sign(move) < 0)
@@ -1382,10 +1394,11 @@ split_point_start: // At split points actual search starts from here
 
       // Don't search useless checks
       if (   !PvNode
-          && !isCheck
-          &&  moveIsCheck
+          && !inCheck
+          &&  givesCheck
           &&  move != ttMove
-          && !pos.move_is_capture_or_promotion(move)
+          && !pos.move_is_capture(move)
+          && !move_is_promotion(move)
           &&  ss->eval + PawnValueMidgame / 4 < beta
           && !check_is_dangerous(pos, move, futilityBase, beta, &bestValue))
       {
@@ -1395,11 +1408,15 @@ split_point_start: // At split points actual search starts from here
           continue;
       }
 
+      // Check for legality only before to do the move
+      if (!pos.pl_move_is_legal(move, pinned))
+          continue;
+
       // Update current move
       ss->currentMove = move;
 
       // Make and search the move
-      pos.do_move(move, st, ci, moveIsCheck);
+      pos.do_move(move, st, ci, givesCheck);
       value = -qsearch<PvNode>(pos, ss+1, -beta, -alpha, depth-ONE_PLY);
       pos.undo_move(move);
 
@@ -1419,7 +1436,7 @@ split_point_start: // At split points actual search starts from here
 
     // All legal moves have been searched. A special case: If we're in check
     // and no legal moves were found, it is checkmate.
-    if (isCheck && bestValue == -VALUE_INFINITE)
+    if (inCheck && bestValue == -VALUE_INFINITE)
         return value_mated_in(ss->ply);
 
     // Update transposition table
@@ -1627,8 +1644,8 @@ split_point_start: // At split points actual search starts from here
 
     assert(move_is_ok(m));
     assert(threat && move_is_ok(threat));
-    assert(!pos.move_is_check(m));
-    assert(!pos.move_is_capture_or_promotion(m));
+    assert(!pos.move_gives_check(m));
+    assert(!pos.move_is_capture(m) && !move_is_promotion(m));
     assert(!pos.move_is_passed_pawn_push(m));
 
     Square mfrom, mto, tfrom, tto;
@@ -1983,13 +2000,14 @@ split_point_start: // At split points actual search starts from here
     TTEntry* tte;
     int ply = 1;
 
-    assert(pv[0] != MOVE_NONE && pos.move_is_legal(pv[0]));
+    assert(pv[0] != MOVE_NONE && pos.move_is_pl(pv[0]));
 
     pos.do_move(pv[0], *st++);
 
     while (   (tte = TT.probe(pos.get_key())) != NULL
            && tte->move() != MOVE_NONE
-           && pos.move_is_legal(tte->move())
+           && pos.move_is_pl(tte->move())
+           && pos.pl_move_is_legal(tte->move(), pos.pinned_pieces(pos.side_to_move()))
            && ply < PLY_MAX
            && (!pos.is_draw() || ply < 2))
     {
@@ -2013,7 +2031,7 @@ split_point_start: // At split points actual search starts from here
     Value v, m = VALUE_NONE;
     int ply = 0;
 
-    assert(pv[0] != MOVE_NONE && pos.move_is_legal(pv[0]));
+    assert(pv[0] != MOVE_NONE && pos.move_is_pl(pv[0]));
 
     do {
         k = pos.get_key();
@@ -2022,7 +2040,7 @@ split_point_start: // At split points actual search starts from here
         // Don't overwrite existing correct entries
         if (!tte || tte->move() != pv[ply])
         {
-            v = (pos.is_check() ? VALUE_NONE : evaluate(pos, m));
+            v = (pos.in_check() ? VALUE_NONE : evaluate(pos, m));
             TT.store(k, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[ply], v, m);
         }
         pos.do_move(pv[ply], *st++);