Set LMRPVMoves to 10 instead of 14

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index fd2bf037acdb2f6968647b43e0b2c6ff7cd10431..9b8f779895a4337748abbc20b1e37b9dce54eaba 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -829,6 +829,10 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
       set_bit(&(byTypeBB[promotion]), to);
       board[to] = piece_of_color_and_type(us, promotion);
 
+      // Update material key
+      st->materialKey ^= zobMaterial[us][PAWN][pieceCount[us][PAWN]];
+      st->materialKey ^= zobMaterial[us][promotion][pieceCount[us][promotion]+1];
+
       // Update piece counts
       pieceCount[us][PAWN]--;
       pieceCount[us][promotion]++;
@@ -845,10 +849,6 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
       key ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to];
       st->pawnKey ^= zobrist[us][PAWN][to];
 
-      // Update material key
-      st->materialKey ^= zobMaterial[us][PAWN][pieceCount[us][PAWN]];
-      st->materialKey ^= zobMaterial[us][promotion][pieceCount[us][promotion]+1];
-
       // Partially revert and update incremental scores
       st->mgValue -= pst<MidGame>(us, PAWN, to);
       st->mgValue += pst<MidGame>(us, promotion, to);
@@ -886,6 +886,8 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
 
   st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
   st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
+
+  assert(is_ok());
 }
 
 
@@ -937,6 +939,12 @@ void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Squ
     pieceCount[them][capture]--;
 
     // Update piece list, move the last piece at index[capsq] position
+    //
+    // WARNING: This is a not perfectly revresible operation. When we
+    // will reinsert the captured piece in undo_move() we will put it
+    // at the end of the list and not in its original place, it means
+    // index[] and pieceList[] are not guaranteed to be invariant to a
+    // do_move() + undo_move() sequence.
     Square lastPieceSquare = pieceList[them][capture][pieceCount[them][capture]];
     index[lastPieceSquare] = index[capsq];
     pieceList[them][capture][index[lastPieceSquare]] = lastPieceSquare;
@@ -953,7 +961,6 @@ void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Squ
 
 void Position::do_castle_move(Move m) {
 
-  assert(is_ok());
   assert(move_is_ok(m));
   assert(move_is_castle(m));
 
@@ -1042,6 +1049,8 @@ void Position::do_castle_move(Move m) {
 
   st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
   st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
+
+  assert(is_ok());
 }
 
 
@@ -1146,6 +1155,8 @@ void Position::undo_move(Move m) {
 
   // Finally point our state pointer back to the previous state
   st = st->previous;
+
+  assert(is_ok());
 }
 
 
@@ -1210,6 +1221,8 @@ void Position::undo_castle_move(Move m) {
 
   // Finally point our state pointer back to the previous state
   st = st->previous;
+
+  assert(is_ok());
 }
 
 
@@ -1369,11 +1382,12 @@ int Position::see(Square from, Square to) const {
 
       // Locate the least valuable attacker to the destination square
       // and use it to initialize from square.
+      stmAttackers = attackers & pieces_of_color(us);
       PieceType pt;
-      for (pt = PAWN; !(attackers & pieces_of_color_and_type(us, pt)); pt++)
+      for (pt = PAWN; !(stmAttackers & pieces_of_type(pt)); pt++)
           assert(pt < KING);
 
-      from = first_1(attackers & pieces_of_color_and_type(us, pt));
+      from = first_1(stmAttackers & pieces_of_type(pt));
       piece = piece_on(from);
   }
 
@@ -1464,19 +1478,17 @@ void Position::clear() {
   memset(st, 0, sizeof(StateInfo));
   st->epSquare = SQ_NONE;
 
-  memset(index, 0, sizeof(int) * 64);
-  memset(byColorBB, 0, sizeof(Bitboard) * 2);
+  memset(byColorBB,  0, sizeof(Bitboard) * 2);
+  memset(byTypeBB,   0, sizeof(Bitboard) * 8);
+  memset(pieceCount, 0, sizeof(int) * 2 * 8);
+  memset(index,      0, sizeof(int) * 64);
 
   for (int i = 0; i < 64; i++)
       board[i] = EMPTY;
 
   for (int i = 0; i < 7; i++)
-  {
-      byTypeBB[i] = EmptyBoardBB;
-      pieceCount[0][i] = pieceCount[1][i] = 0;
       for (int j = 0; j < 8; j++)
           pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
-  }
 
   sideToMove = WHITE;
   gamePly = 0;
@@ -1622,7 +1634,7 @@ Value Position::compute_value() const {
   for (Color c = WHITE; c <= BLACK; c++)
       for (PieceType pt = PAWN; pt <= KING; pt++)
       {
-          b = pieces_of_color_and_type(c, pt);
+          b = pieces_of_color(c) & pieces_of_type(pt);
           while(b)
           {
               s = pop_1st_bit(&b);
@@ -1648,7 +1660,7 @@ Value Position::compute_non_pawn_material(Color c) const {
 
   for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
   {
-      Bitboard b = pieces_of_color_and_type(c, pt);
+      Bitboard b = pieces_of_color(c) & pieces_of_type(pt);
       while (b)
       {
           assert(piece_on(first_1(b)) == piece_of_color_and_type(c, pt));
@@ -1691,7 +1703,7 @@ bool Position::is_mate() const {
 
   MoveStack moves[256];
 
-  return is_check() && !generate_evasions(*this, moves, pinned_pieces(sideToMove));
+  return is_check() && (generate_evasions(*this, moves, pinned_pieces(sideToMove)) == moves);
 }
 
 
@@ -1711,20 +1723,18 @@ bool Position::has_mate_threat(Color c) {
       do_null_move(st1);
 
   MoveStack mlist[120];
-  int count;
   bool result = false;
   Bitboard dc = discovered_check_candidates(sideToMove);
   Bitboard pinned = pinned_pieces(sideToMove);
 
   // Generate pseudo-legal non-capture and capture check moves
-  count = generate_non_capture_checks(*this, mlist, dc);
-  count += generate_captures(*this, mlist + count);
+  MoveStack* last = generate_non_capture_checks(*this, mlist, dc);
+  last = generate_captures(*this, last);
 
   // Loop through the moves, and see if one of them is mate
-  for (int i = 0; i < count; i++)
+  for (MoveStack* cur = mlist; cur != last; cur++)
   {
-      Move move = mlist[i].move;
-
+      Move move = cur->move;
       if (!pl_move_is_legal(move, pinned))
           continue;
 
@@ -2002,7 +2012,7 @@ bool Position::is_ok(int* failedStep) const {
   if (debugPieceCounts)
       for (Color c = WHITE; c <= BLACK; c++)
           for (PieceType pt = PAWN; pt <= KING; pt++)
-              if (pieceCount[c][pt] != count_1s(pieces_of_color_and_type(c, pt)))
+              if (pieceCount[c][pt] != count_1s(pieces_of_color(c) & pieces_of_type(pt)))
                   return false;
 
   if (failedStep) (*failedStep)++;
@@ -2012,7 +2022,7 @@ bool Position::is_ok(int* failedStep) const {
           for(PieceType pt = PAWN; pt <= KING; pt++)
               for(int i = 0; i < pieceCount[c][pt]; i++)
               {
-                  if (piece_on(piece_list(c, pt, i)) != piece_of_color_and_type(c, pt))
+                  if (piece_on(piece_list(c, pt, i)) != (pieces_of_color(c) & pieces_of_type(pt)))
                       return false;
 
                   if (index[piece_list(c, pt, i)] != i)