X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fposition.cpp;h=c6c20dbce73d40c2e4f45270de6689c1e1eee8bd;hb=94dcac1feeb142a56ed2ebddb96ef672460f1d49;hp=443ba88141b6ae9c3303b4c361efd52c62df64a0;hpb=48b74142efa52f0da9d4e27f9bbcbe9520499524;p=stockfish

diff --git a/src/position.cpp b/src/position.cpp
index 443ba881..c6c20dbc 100644
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -458,19 +458,11 @@ void Position::find_checkers() {
 
 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
 
-bool Position::pl_move_is_legal(Move m) const {
-
-  // If we're in check, all pseudo-legal moves are legal, because our
-  // check evasion generator only generates true legal moves.
-  return is_check() || pl_move_is_legal(m, pinned_pieces(side_to_move()));
-}
-
 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
 
   assert(is_ok());
   assert(move_is_ok(m));
   assert(pinned == pinned_pieces(side_to_move()));
-  assert(!is_check());
 
   // Castling moves are checked for legality during move generation.
   if (move_is_castle(m))
@@ -482,7 +474,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
   assert(color_of_piece_on(from) == us);
   assert(piece_on(king_square(us)) == piece_of_color_and_type(us, KING));
 
-  // En passant captures are a tricky special case.  Because they are
+  // En passant captures are a tricky special case. Because they are
   // rather uncommon, we do it simply by testing whether the king is attacked
   // after the move is made
   if (move_is_ep(m))
@@ -703,7 +695,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   // pointer to point to the new, ready to be updated, state.
   struct ReducedStateInfo {
     Key key, pawnKey, materialKey;
-    int castleRights, rule50;
+    int castleRights, rule50, pliesFromNull;
     Square epSquare;
     Value mgValue, egValue;
     Value npMaterial[2];
@@ -724,6 +716,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   // Increment the 50 moves rule draw counter. Resetting it to zero in the
   // case of non-reversible moves is taken care of later.
   st->rule50++;
+  st->pliesFromNull++;
 
   if (move_is_castle(m))
   {
@@ -985,17 +978,22 @@ void Position::do_castle_move(Move m) {
       rto = relative_square(us, SQ_D1);
   }
 
-  // Move the pieces
-  Bitboard kmove_bb = make_move_bb(kfrom, kto);
-  do_move_bb(&(byColorBB[us]), kmove_bb);
-  do_move_bb(&(byTypeBB[KING]), kmove_bb);
-  do_move_bb(&(byTypeBB[0]), kmove_bb); // HACK: byTypeBB[0] == occupied squares
-
-  Bitboard rmove_bb = make_move_bb(rfrom, rto);
-  do_move_bb(&(byColorBB[us]), rmove_bb);
-  do_move_bb(&(byTypeBB[ROOK]), rmove_bb);
-  do_move_bb(&(byTypeBB[0]), rmove_bb); // HACK: byTypeBB[0] == occupied squares
-
+  // Remove pieces from source squares:
+  clear_bit(&(byColorBB[us]), kfrom);
+  clear_bit(&(byTypeBB[KING]), kfrom);
+  clear_bit(&(byTypeBB[0]), kfrom); // HACK: byTypeBB[0] == occupied squares
+  clear_bit(&(byColorBB[us]), rfrom);
+  clear_bit(&(byTypeBB[ROOK]), rfrom);
+  clear_bit(&(byTypeBB[0]), rfrom); // HACK: byTypeBB[0] == occupied squares
+
+  // Put pieces on destination squares:
+  set_bit(&(byColorBB[us]), kto);
+  set_bit(&(byTypeBB[KING]), kto);
+  set_bit(&(byTypeBB[0]), kto); // HACK: byTypeBB[0] == occupied squares
+  set_bit(&(byColorBB[us]), rto);
+  set_bit(&(byTypeBB[ROOK]), rto);
+  set_bit(&(byTypeBB[0]), rto); // HACK: byTypeBB[0] == occupied squares
+  
   // Update board array
   Piece king = piece_of_color_and_type(us, KING);
   Piece rook = piece_of_color_and_type(us, ROOK);
@@ -1106,6 +1104,7 @@ void Position::undo_move(Move m) {
       pieceList[us][PAWN][index[to]] = to;
   }
 
+
   // Put the piece back at the source square
   Bitboard move_bb = make_move_bb(to, from);
   do_move_bb(&(byColorBB[us]), move_bb);
@@ -1183,17 +1182,22 @@ void Position::undo_castle_move(Move m) {
 
   assert(piece_on(kto) == piece_of_color_and_type(us, KING));
   assert(piece_on(rto) == piece_of_color_and_type(us, ROOK));
-
-  // Put the pieces back at the source square
-  Bitboard kmove_bb = make_move_bb(kto, kfrom);
-  do_move_bb(&(byColorBB[us]), kmove_bb);
-  do_move_bb(&(byTypeBB[KING]), kmove_bb);
-  do_move_bb(&(byTypeBB[0]), kmove_bb); // HACK: byTypeBB[0] == occupied squares
-
-  Bitboard rmove_bb = make_move_bb(rto, rfrom);
-  do_move_bb(&(byColorBB[us]), rmove_bb);
-  do_move_bb(&(byTypeBB[ROOK]), rmove_bb);
-  do_move_bb(&(byTypeBB[0]), rmove_bb); // HACK: byTypeBB[0] == occupied squares
+  
+  // Remove pieces from destination squares:
+  clear_bit(&(byColorBB[us]), kto);
+  clear_bit(&(byTypeBB[KING]), kto);
+  clear_bit(&(byTypeBB[0]), kto); // HACK: byTypeBB[0] == occupied squares
+  clear_bit(&(byColorBB[us]), rto);
+  clear_bit(&(byTypeBB[ROOK]), rto);
+  clear_bit(&(byTypeBB[0]), rto); // HACK: byTypeBB[0] == occupied squares
+ 
+  // Put pieces on source squares:
+  set_bit(&(byColorBB[us]), kfrom);
+  set_bit(&(byTypeBB[KING]), kfrom);
+  set_bit(&(byTypeBB[0]), kfrom); // HACK: byTypeBB[0] == occupied squares
+  set_bit(&(byColorBB[us]), rfrom);
+  set_bit(&(byTypeBB[ROOK]), rfrom);
+  set_bit(&(byTypeBB[0]), rfrom); // HACK: byTypeBB[0] == occupied squares
 
   // Update board
   board[rto] = board[kto] = EMPTY;
@@ -1231,6 +1235,7 @@ void Position::do_null_move(StateInfo& backupSt) {
   backupSt.mgValue  = st->mgValue;
   backupSt.egValue  = st->egValue;
   backupSt.previous = st->previous;
+  backupSt.pliesFromNull = st->pliesFromNull;
   st->previous = &backupSt;
 
   // Save the current key to the history[] array, in order to be able to
@@ -1247,6 +1252,7 @@ void Position::do_null_move(StateInfo& backupSt) {
   sideToMove = opposite_color(sideToMove);
   st->epSquare = SQ_NONE;
   st->rule50++;
+  st->pliesFromNull = 0;
   gamePly++;
 
   st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
@@ -1268,6 +1274,7 @@ void Position::undo_null_move() {
   st->mgValue  = backupSt->mgValue;
   st->egValue  = backupSt->egValue;
   st->previous = backupSt->previous;
+  st->pliesFromNull = backupSt->pliesFromNull;
 
   // Update the necessary information
   sideToMove = opposite_color(sideToMove);
@@ -1321,7 +1328,7 @@ int Position::see(Square from, Square to) const {
     0, 0
   };
 
-  Bitboard attackers, stmAttackers, occ, b;
+  Bitboard attackers, stmAttackers, b;
 
   assert(square_is_ok(from) || from == SQ_NONE);
   assert(square_is_ok(to));
@@ -1333,10 +1340,11 @@ int Position::see(Square from, Square to) const {
   // Initialize pieces
   Piece piece = piece_on(from);
   Piece capture = piece_on(to);
+  Bitboard occ = occupied_squares();
 
-  // Find all attackers to the destination square, with the moving piece
-  // removed, but possibly an X-ray attacker added behind it.
-  occ = occupied_squares();
+  // King cannot be recaptured
+  if (type_of_piece(piece) == KING)
+      return seeValues[capture];
 
   // Handle en passant moves
   if (st->epSquare == to && type_of_piece_on(from) == PAWN)
@@ -1353,6 +1361,8 @@ int Position::see(Square from, Square to) const {
 
   while (true)
   {
+      // Find all attackers to the destination square, with the moving piece
+      // removed, but possibly an X-ray attacker added behind it.
       clear_bit(&occ, from);
       attackers =  (rook_attacks_bb(to, occ)      & pieces(ROOK, QUEEN))
                  | (bishop_attacks_bb(to, occ)    & pieces(BISHOP, QUEEN))
@@ -1474,8 +1484,8 @@ void Position::clear() {
   for (int i = 0; i < 64; i++)
       board[i] = EMPTY;
 
-  for (int i = 0; i < 7; i++)
-      for (int j = 0; j < 8; j++)
+  for (int i = 0; i < 8; i++)
+      for (int j = 0; j < 16; j++)
           pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
 
   sideToMove = WHITE;
@@ -1673,7 +1683,7 @@ bool Position::is_draw() const {
       return true;
 
   // Draw by repetition?
-  for (int i = 2; i < Min(gamePly, st->rule50); i += 2)
+  for (int i = 2; i < Min(Min(gamePly, st->rule50), st->pliesFromNull); i += 2)
       if (history[gamePly - i] == st->key)
           return true;
 
@@ -1687,8 +1697,7 @@ bool Position::is_draw() const {
 bool Position::is_mate() const {
 
   MoveStack moves[256];
-
-  return is_check() && (generate_evasions(*this, moves, pinned_pieces(sideToMove)) == moves);
+  return is_check() && (generate_moves(*this, moves, false) == moves);
 }
 
 
@@ -1709,11 +1718,10 @@ bool Position::has_mate_threat(Color c) {
 
   MoveStack mlist[120];
   bool result = false;
-  Bitboard dc = discovered_check_candidates(sideToMove);
   Bitboard pinned = pinned_pieces(sideToMove);
 
   // Generate pseudo-legal non-capture and capture check moves
-  MoveStack* last = generate_non_capture_checks(*this, mlist, dc);
+  MoveStack* last = generate_non_capture_checks(*this, mlist);
   last = generate_captures(*this, last);
 
   // Loop through the moves, and see if one of them is mate