Fix compile in the debug mode

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index be5316d0534592657fd737e53e22edd532e8bfdf..063233111dea59066bffb702c3597ec31ca7b87f 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -190,7 +190,7 @@ void Position::from_fen(const std::string& fen) {
       i++;
 
   // En passant square
-  if (    i < fen.length() - 2
+  if (    i <= fen.length() - 2
       && (fen[i] >= 'a' && fen[i] <= 'h')
       && (fen[i+1] == '3' || fen[i+1] == '6'))
       st->epSquare = square_from_string(fen.substr(i, 2));
@@ -552,7 +552,8 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
       if (bit_is_set(pawn_attacks(them, ksq), to)) // Normal check?
           return true;
 
-      if (    bit_is_set(dcCandidates, from)      // Discovered check?
+      if (   dcCandidates // Discovered check?
+          && bit_is_set(dcCandidates, from)
           && (direction_between_squares(from, ksq) != direction_between_squares(to, ksq)))
           return true;
 
@@ -591,22 +592,26 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
       }
       return false;
 
+  // Test discovered check and normal check according to piece type
   case KNIGHT:
-    return   bit_is_set(dcCandidates, from)              // Discovered check?
-          || bit_is_set(piece_attacks<KNIGHT>(ksq), to); // Normal check?
+    return   (dcCandidates && bit_is_set(dcCandidates, from))
+          || bit_is_set(piece_attacks<KNIGHT>(ksq), to);
 
   case BISHOP:
-    return   bit_is_set(dcCandidates, from)              // Discovered check?
-          || bit_is_set(piece_attacks<BISHOP>(ksq), to); // Normal check?
+    return   (dcCandidates && bit_is_set(dcCandidates, from))
+          || (   direction_between_squares(ksq, to) != DIR_NONE
+              && bit_is_set(piece_attacks<BISHOP>(ksq), to));
 
   case ROOK:
-    return   bit_is_set(dcCandidates, from)              // Discovered check?
-          || bit_is_set(piece_attacks<ROOK>(ksq), to);   // Normal check?
+    return   (dcCandidates && bit_is_set(dcCandidates, from))
+          || (   direction_between_squares(ksq, to) != DIR_NONE
+              && bit_is_set(piece_attacks<ROOK>(ksq), to));
 
   case QUEEN:
       // Discovered checks are impossible!
       assert(!bit_is_set(dcCandidates, from));
-      return bit_is_set(piece_attacks<QUEEN>(ksq), to);  // Normal check?
+      return (   direction_between_squares(ksq, to) != DIR_NONE
+              && bit_is_set(piece_attacks<QUEEN>(ksq), to));
 
   case KING:
       // Discovered check?
@@ -750,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);
@@ -843,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);
 
@@ -862,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);
@@ -1005,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);
@@ -1613,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());
 
@@ -1849,15 +1852,14 @@ Value Position::compute_value() const {
 Value Position::compute_non_pawn_material(Color c) const {
 
   Value result = Value(0);
-  Square s;
 
   for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
   {
       Bitboard b = pieces_of_color_and_type(c, pt);
-      while(b)
+      while (b)
       {
-          s = pop_1st_bit(&b);
-          assert(piece_on(s) == piece_of_color_and_type(c, pt));
+          assert(piece_on(first_1(b)) == piece_of_color_and_type(c, pt));
+          pop_1st_bit(&b);
           result += piece_value_midgame(pt);
       }
   }
@@ -1956,26 +1958,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;
 }