Greatly speedup has_mate_threat()

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index 36db8d2b65200a9bb5e2f829d35a0ae0722ef253..abe75807e2869044b05aad7b1cdfd696c31594bf 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -755,7 +755,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
     st->capture = type_of_piece_on(to);
 
     if (st->capture)
-      do_capture_move(m, st->capture, them, to);
+      do_capture_move(st->capture, them, to);
 
     // Move the piece
     clear_bit(&(byColorBB[us]), from);
@@ -848,7 +848,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
 /// Position::do_capture_move() is a private method used to update captured
 /// piece info. It is called from the main Position::do_move function.
 
-void Position::do_capture_move(Move m, PieceType capture, Color them, Square to) {
+void Position::do_capture_move(PieceType capture, Color them, Square to) {
 
     assert(capture != KING);
 
@@ -867,8 +867,6 @@ void Position::do_capture_move(Move m, PieceType capture, Color them, Square to)
     st->mgValue -= pst<MidGame>(them, capture, to);
     st->egValue -= pst<EndGame>(them, capture, to);
 
-    assert(!move_promotion(m) || capture != PAWN);
-
     // Update material
     if (capture != PAWN)
         npMaterial[them] -= piece_value_midgame(capture);
@@ -1010,7 +1008,7 @@ void Position::do_promotion_move(Move m) {
   st->capture = type_of_piece_on(to);
 
   if (st->capture)
-    do_capture_move(m, st->capture, them, to);
+    do_capture_move(st->capture, them, to);
 
   // Remove pawn
   clear_bit(&(byColorBB[us]), from);
@@ -1618,7 +1616,7 @@ int Position::see(Square from, Square to) const {
       // Remove the attacker we just found from the 'attackers' bitboard,
       // and scan for new X-ray attacks behind the attacker.
       b = attackers & pieces_of_color_and_type(c, pt);
-      occ ^= (b & -b);
+      occ ^= (b & (~b + 1));
       attackers |=  (rook_attacks_bb(to, occ) & rooks_and_queens())
                   | (bishop_attacks_bb(to, occ) & bishops_and_queens());
 
@@ -1869,21 +1867,6 @@ Value Position::compute_non_pawn_material(Color c) const {
 }
 
 
-/// Position::is_mate() returns true or false depending on whether the
-/// side to move is checkmated. Note that this function is currently very
-/// slow, and shouldn't be used frequently inside the search.
-
-bool Position::is_mate() const {
-
-  if (is_check())
-  {
-      MovePicker mp = MovePicker(*this, false, MOVE_NONE, EmptySearchStack, Depth(0));
-      return mp.get_next_move() == MOVE_NONE;
-  }
-  return false;
-}
-
-
 /// Position::is_draw() tests whether the position is drawn by material,
 /// repetition, or the 50 moves rule. It does not detect stalemates, this
 /// must be done by the search.
@@ -1908,21 +1891,25 @@ bool Position::is_draw() const {
 }
 
 
+/// Position::is_mate() returns true or false depending on whether the
+/// side to move is checkmated.
+
+bool Position::is_mate() const {
+
+  MoveStack moves[256];
+
+  return is_check() && !generate_evasions(*this, moves, pinned_pieces(sideToMove));
+}
+
+
 /// Position::has_mate_threat() tests whether a given color has a mate in one
-/// from the current position. This function is quite slow, but it doesn't
-/// matter, because it is currently only called from PV nodes, which are rare.
+/// from the current position.
 
 bool Position::has_mate_threat(Color c) {
 
   StateInfo st1, st2;
   Color stm = side_to_move();
 
-  // The following lines are useless and silly, but prevents gcc from
-  // emitting a stupid warning stating that u1.lastMove and u1.epSquare might
-  // be used uninitialized.
-  st1.lastMove = st->lastMove;
-  st1.epSquare = st->epSquare;
-
   if (is_check())
       return false;
 
@@ -1933,18 +1920,26 @@ bool Position::has_mate_threat(Color c) {
   MoveStack mlist[120];
   int count;
   bool result = false;
+  Bitboard dc = discovered_check_candidates(sideToMove);
+  Bitboard pinned = pinned_pieces(sideToMove);
 
-  // Generate legal moves
-  count = generate_legal_moves(*this, mlist);
+  // Generate pseudo-legal non-capture and capture check moves
+  count = generate_non_capture_checks(*this, mlist, dc);
+  count += generate_captures(*this, mlist + count);
 
   // Loop through the moves, and see if one of them is mate
   for (int i = 0; i < count; i++)
   {
-      do_move(mlist[i].move, st2);
+      Move move = mlist[i].move;
+
+      if (!pl_move_is_legal(move, pinned))
+          continue;
+
+      do_move(move, st2);
       if (is_mate())
           result = true;
 
-      undo_move(mlist[i].move);
+      undo_move(move);
   }
 
   // Undo null move, if necessary
@@ -1960,26 +1955,26 @@ bool Position::has_mate_threat(Color c) {
 
 void Position::init_zobrist() {
 
-  for (int i = 0; i < 2; i++)
-      for (int j = 0; j < 8; j++)
-          for (int k = 0; k < 64; k++)
-              zobrist[i][j][k] = Key(genrand_int64());
+  for(Piece p = WP; p <= BK; p++)
+      for(Square s = SQ_A1; s <= SQ_H8; s++)
+          zobrist[color_of_piece(p)][type_of_piece(p)][s] = genrand_int64();
 
-  for (int i = 0; i < 64; i++)
-      zobEp[i] = Key(genrand_int64());
+  zobEp[0] = 0ULL;
+  for(int i = 1; i < 64; i++)
+      zobEp[i] = genrand_int64();
 
-  for (int i = 0; i < 16; i++)
-      zobCastle[i] = genrand_int64();
+  for(int i = 15; i >= 0; i--)
+      zobCastle[(i&8) | (i&1) | ((i&2) << 1) | ((i&4) >> 1)] = genrand_int64();
 
   zobSideToMove = genrand_int64();
 
   for (int i = 0; i < 2; i++)
       for (int j = 0; j < 8; j++)
           for (int k = 0; k < 16; k++)
-              zobMaterial[i][j][k] = (k > 0)? Key(genrand_int64()) : Key(0LL);
+              zobMaterial[i][j][k] = (k > 0)? genrand_int64() : 0LL;
 
   for (int i = 0; i < 16; i++)
-      zobMaterial[0][KING][i] = zobMaterial[1][KING][i] = Key(0ULL);
+      zobMaterial[0][KING][i] = zobMaterial[1][KING][i] = 0ULL;
 }