X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=ce48e33fb6fedd5721b7a890da8665c7cda85046;hp=5f19403035313eddc8e7694c4f9ce52f9bdc60d6;hb=5c81602d14539f8259a715477315e28b5de7cb54;hpb=5a7876d0d04144f8822c236a174838d537539c5f

diff --git a/src/position.cpp b/src/position.cpp
index 5f194030..ce48e33f 100644
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -460,7 +460,9 @@ void Position::find_checkers() {
 
 bool Position::pl_move_is_legal(Move m) const {
 
-  return pl_move_is_legal(m, pinned_pieces(side_to_move()));
+  // 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 {
@@ -468,11 +470,7 @@ 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()));
-
-  // If we're in check, all pseudo-legal moves are legal, because our
-  // check evasion generator only generates true legal moves.
-  if (is_check())
-      return true;
+  assert(!is_check());
 
   // Castling moves are checked for legality during move generation.
   if (move_is_castle(m))
@@ -1513,7 +1511,7 @@ int Position::see(Square from, Square to) const {
     0, 0
   };
 
-  Bitboard attackers, occ, b;
+  Bitboard attackers, stmAttackers, occ, b;
 
   assert(square_is_ok(from) || from == SQ_NONE);
   assert(square_is_ok(to));
@@ -1537,7 +1535,6 @@ int Position::see(Square from, Square to) const {
 
       Square capQq = (side_to_move() == WHITE)? (to - DELTA_N) : (to - DELTA_S);
       capture = piece_on(capQq);
-
       assert(type_of_piece_on(capQq) == PAWN);
 
       // Remove the captured pawn
@@ -1572,7 +1569,8 @@ int Position::see(Square from, Square to) const {
   }
 
   // If the opponent has no attackers we are finished
-  if ((attackers & pieces_of_color(them)) == EmptyBoardBB)
+  stmAttackers = attackers & pieces_of_color(them);
+  if (!stmAttackers)
       return seeValues[capture];
 
   attackers &= occ; // Remove the moving piece
@@ -1594,12 +1592,12 @@ int Position::see(Square from, Square to) const {
       // Locate the least valuable attacker for the side to move. The loop
       // below looks like it is potentially infinite, but it isn't. We know
       // that the side to move still has at least one attacker left.
-      for (pt = PAWN; !(attackers & pieces_of_color_and_type(c, pt)); pt++)
+      for (pt = PAWN; !(stmAttackers & pieces_of_type(pt)); pt++)
           assert(pt < KING);
 
       // 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);
+      b = stmAttackers & pieces_of_type(pt);
       occ ^= (b & (~b + 1));
       attackers |=  (rook_attacks_bb(to, occ) & rooks_and_queens())
                   | (bishop_attacks_bb(to, occ) & bishops_and_queens());
@@ -1615,15 +1613,16 @@ int Position::see(Square from, Square to) const {
       // before beginning the next iteration
       lastCapturingPieceValue = seeValues[pt];
       c = opposite_color(c);
+      stmAttackers = attackers & pieces_of_color(c);
 
       // Stop after a king capture
-      if (pt == KING && (attackers & pieces_of_color(c)))
+      if (pt == KING && stmAttackers)
       {
           assert(n < 32);
           swapList[n++] = 100;
           break;
       }
-  } while (attackers & pieces_of_color(c));
+  } while (stmAttackers);
 
   // Having built the swap list, we negamax through it to find the best
   // achievable score from the point of view of the side to move