X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fposition.cpp;h=eda26014c32c49330a57cbdd996102a555011b0d;hb=856a5f3aaaf8b9d53599963decacd4476b55c034;hp=87067ea56f644187cf52bf4c4adce75900da9d78;hpb=3184852bdce27e387852f4e250c3c5b502706cb3;p=stockfish diff --git a/src/position.cpp b/src/position.cpp index 87067ea5..eda26014 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -19,7 +19,7 @@ #include #include -#include // For std::memset, std::memcmp +#include // For std::memset #include #include @@ -381,7 +381,7 @@ void Position::set_state(StateInfo* si) const { if (sideToMove == BLACK) si->key ^= Zobrist::side; - si->key ^= Zobrist::castling[si->castlingRights]; + si->key ^= Zobrist::castling[st->castlingRights]; for (Bitboard b = pieces(PAWN); b; ) { @@ -690,24 +690,28 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { void Position::do_move(Move m, StateInfo& newSt) { CheckInfo ci(*this); - do_move(m, newSt, ci, gives_check(m, ci)); + do_move(m, newSt, gives_check(m, ci)); } -void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool givesCheck) { +void Position::do_move(Move m, StateInfo& newSt, bool moveIsCheck) { assert(is_ok(m)); assert(&newSt != st); ++nodes; - Key k = st->key ^ Zobrist::side; + Key k = st->key; // Copy some fields of the old state to our new StateInfo object except the // ones which are going to be recalculated from scratch anyway and then switch // our state pointer to point to the new (ready to be updated) state. - std::memcpy(&newSt, st, offsetof(StateInfo, key)); + std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t)); + newSt.previous = st; st = &newSt; + // Update side to move + k ^= Zobrist::side; + // Increment ply counters. In particular, rule50 will be reset to zero later on // in case of a capture or a pawn move. ++gamePly; @@ -718,16 +722,17 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool gives Color them = ~us; Square from = from_sq(m); Square to = to_sq(m); - PieceType pt = type_of(piece_on(from)); + Piece pc = piece_on(from); + PieceType pt = type_of(pc); PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); - assert(color_of(piece_on(from)) == us); - assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == (type_of(m) != CASTLING ? them : us)); + assert(color_of(pc) == us); + assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING); assert(captured != KING); if (type_of(m) == CASTLING) { - assert(pt == KING); + assert(pc == make_piece(us, KING)); Square rfrom, rto; do_castling(from, to, rfrom, rto); @@ -747,7 +752,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool gives { if (type_of(m) == ENPASSANT) { - capsq -= pawn_push(us); + capsq += pawn_push(them); assert(pt == PAWN); assert(to == st->epSquare); @@ -755,7 +760,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool gives assert(piece_on(to) == NO_PIECE); assert(piece_on(capsq) == make_piece(them, PAWN)); - board[capsq] = NO_PIECE; // Not done by remove_piece() + board[capsq] = NO_PIECE; } st->pawnKey ^= Zobrist::psq[them][PAWN][capsq]; @@ -769,7 +774,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool gives // Update material hash key and prefetch access to materialTable k ^= Zobrist::psq[them][captured][capsq]; st->materialKey ^= Zobrist::psq[them][captured][pieceCount[them][captured]]; - prefetch(thisThread->materialTable[st->materialKey]); + prefetch((char*)thisThread->materialTable[st->materialKey]); // Update incremental scores st->psq -= psq[them][captured][capsq]; @@ -805,9 +810,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool gives { // Set en-passant square if the moved pawn can be captured if ( (int(to) ^ int(from)) == 16 - && (attacks_from(to - pawn_push(us), us) & pieces(them, PAWN))) + && (attacks_from(from + pawn_push(us), us) & pieces(them, PAWN))) { - st->epSquare = (from + to) / 2; + st->epSquare = Square((from + to) / 2); k ^= Zobrist::enpassant[file_of(st->epSquare)]; } @@ -836,7 +841,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool gives // Update pawn hash key and prefetch access to pawnsTable st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to]; - prefetch(thisThread->pawnsTable[st->pawnKey]); + prefetch((char*)thisThread->pawnsTable[st->pawnKey]); // Reset rule 50 draw counter st->rule50 = 0; @@ -851,32 +856,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool gives // Update the key with the final value st->key = k; - // Update checkers bitboard: piece must be already moved due to attacks_from() - st->checkersBB = 0; - - if (givesCheck) - { - if (type_of(m) != NORMAL) - st->checkersBB = attackers_to(king_square(them)) & pieces(us); - else - { - // Direct checks - if (ci.checkSq[pt] & to) - st->checkersBB |= to; - - // Discovered checks - if (ci.dcCandidates && (ci.dcCandidates & from)) - { - assert(pt != QUEEN); - - if (pt != ROOK) - st->checkersBB |= attacks_from(king_square(them)) & pieces(us, QUEEN, ROOK); - - if (pt != BISHOP) - st->checkersBB |= attacks_from(king_square(them)) & pieces(us, QUEEN, BISHOP); - } - } - } + // Calculate checkers bitboard (if move is check) + st->checkersBB = moveIsCheck ? attackers_to(king_square(them)) & pieces(us) : 0; sideToMove = ~sideToMove; @@ -903,11 +884,11 @@ void Position::undo_move(Move m) { if (type_of(m) == PROMOTION) { - assert(relative_rank(us, to) == RANK_8); assert(pt == promotion_type(m)); - assert(pt >= KNIGHT && pt <= QUEEN); + assert(relative_rank(us, to) == RANK_8); + assert(promotion_type(m) >= KNIGHT && promotion_type(m) <= QUEEN); - remove_piece(to, us, pt); + remove_piece(to, us, promotion_type(m)); put_piece(to, us, PAWN); pt = PAWN; } @@ -933,7 +914,6 @@ void Position::undo_move(Move m) { assert(to == st->previous->epSquare); assert(relative_rank(us, to) == RANK_6); assert(piece_on(capsq) == NO_PIECE); - assert(st->capturedType == PAWN); } put_piece(capsq, ~us, st->capturedType); // Restore the captured piece @@ -973,9 +953,9 @@ void Position::do_castling(Square from, Square& to, Square& rfrom, Square& rto) void Position::do_null_move(StateInfo& newSt) { assert(!checkers()); - assert(&newSt != st); - std::memcpy(&newSt, st, sizeof(StateInfo)); + std::memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here + newSt.previous = st; st = &newSt; @@ -986,7 +966,7 @@ void Position::do_null_move(StateInfo& newSt) { } st->key ^= Zobrist::side; - prefetch(TT.first_entry(st->key)); + prefetch((char*)TT.first_entry(st->key)); ++st->rule50; st->pliesFromNull = 0; @@ -1096,11 +1076,21 @@ Value Position::see(Move m) const { // Locate and remove the next least valuable attacker captured = min_attacker(byTypeBB, to, stmAttackers, occupied, attackers); + + // Stop before processing a king capture + if (captured == KING) + { + if (stmAttackers == attackers) + ++slIndex; + + break; + } + stm = ~stm; stmAttackers = attackers & pieces(stm); ++slIndex; - } while (stmAttackers && (captured != KING || (--slIndex, false))); // Stop before a king capture + } 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. @@ -1135,6 +1125,10 @@ bool Position::is_draw() const { /// Position::flip() flips position with the white and black sides reversed. This /// is only useful for debugging e.g. for finding evaluation symmetry bugs. +static char toggle_case(char c) { + return char(islower(c) ? toupper(c) : tolower(c)); +} + void Position::flip() { string f, token; @@ -1152,8 +1146,7 @@ void Position::flip() { ss >> token; // Castling availability f += token + " "; - std::transform(f.begin(), f.end(), f.begin(), - [](char c) { return char(islower(c) ? toupper(c) : tolower(c)); }); + std::transform(f.begin(), f.end(), f.begin(), toggle_case); ss >> token; // En passant square f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3")); @@ -1170,77 +1163,96 @@ void Position::flip() { /// Position::pos_is_ok() performs some consistency checks for the position object. /// This is meant to be helpful when debugging. -bool Position::pos_is_ok(int* failedStep) const { +bool Position::pos_is_ok(int* step) const { - const bool Fast = true; // Quick (default) or full check? + // Which parts of the position should be verified? + const bool all = false; - enum { Default, King, Bitboards, State, Lists, Castling }; + const bool testBitboards = all || false; + const bool testState = all || false; + const bool testKingCount = all || false; + const bool testKingCapture = all || false; + const bool testPieceCounts = all || false; + const bool testPieceList = all || false; + const bool testCastlingSquares = all || false; - for (int step = Default; step <= (Fast ? Default : Castling); step++) + if (step) + *step = 1; + + if ( (sideToMove != WHITE && sideToMove != BLACK) + || piece_on(king_square(WHITE)) != W_KING + || piece_on(king_square(BLACK)) != B_KING + || ( ep_square() != SQ_NONE + && relative_rank(sideToMove, ep_square()) != RANK_6)) + return false; + + if (step && ++*step, testBitboards) { - if (failedStep) - *failedStep = step; - - if (step == Default) - if ( (sideToMove != WHITE && sideToMove != BLACK) - || piece_on(king_square(WHITE)) != W_KING - || piece_on(king_square(BLACK)) != B_KING - || ( ep_square() != SQ_NONE - && relative_rank(sideToMove, ep_square()) != RANK_6)) - return false; + // The intersection of the white and black pieces must be empty + if (pieces(WHITE) & pieces(BLACK)) + return false; - if (step == King) - if ( std::count(board, board + SQUARE_NB, W_KING) != 1 - || std::count(board, board + SQUARE_NB, B_KING) != 1 - || attackers_to(king_square(~sideToMove)) & pieces(sideToMove)) - return false; + // The union of the white and black pieces must be equal to all + // occupied squares + if ((pieces(WHITE) | pieces(BLACK)) != pieces()) + return false; - if (step == Bitboards) - { - if ( (pieces(WHITE) & pieces(BLACK)) - ||(pieces(WHITE) | pieces(BLACK)) != pieces()) - return false; + // Separate piece type bitboards must have empty intersections + for (PieceType p1 = PAWN; p1 <= KING; ++p1) + for (PieceType p2 = PAWN; p2 <= KING; ++p2) + if (p1 != p2 && (pieces(p1) & pieces(p2))) + return false; + } - for (PieceType p1 = PAWN; p1 <= KING; ++p1) - for (PieceType p2 = PAWN; p2 <= KING; ++p2) - if (p1 != p2 && (pieces(p1) & pieces(p2))) - return false; - } + if (step && ++*step, testState) + { + StateInfo si; + set_state(&si); + if ( st->key != si.key + || st->pawnKey != si.pawnKey + || st->materialKey != si.materialKey + || st->nonPawnMaterial[WHITE] != si.nonPawnMaterial[WHITE] + || st->nonPawnMaterial[BLACK] != si.nonPawnMaterial[BLACK] + || st->psq != si.psq + || st->checkersBB != si.checkersBB) + return false; + } - if (step == State) - { - StateInfo si = *st; - set_state(&si); - if (std::memcmp(&si, st, sizeof(StateInfo))) - return false; - } + if (step && ++*step, testKingCount) + if ( std::count(board, board + SQUARE_NB, W_KING) != 1 + || std::count(board, board + SQUARE_NB, B_KING) != 1) + return false; - if (step == Lists) - for (Color c = WHITE; c <= BLACK; ++c) - for (PieceType pt = PAWN; pt <= KING; ++pt) - { - if (pieceCount[c][pt] != popcount(pieces(c, pt))) - return false; + if (step && ++*step, testKingCapture) + if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove)) + return false; - for (int i = 0; i < pieceCount[c][pt]; ++i) - if ( board[pieceList[c][pt][i]] != make_piece(c, pt) - || index[pieceList[c][pt][i]] != i) - return false; - } - - if (step == Castling) - for (Color c = WHITE; c <= BLACK; ++c) - for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) - { - if (!can_castle(c | s)) - continue; - - if ( piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK) - || castlingRightsMask[castlingRookSquare[c | s]] != (c | s) - ||(castlingRightsMask[king_square(c)] & (c | s)) != (c | s)) + if (step && ++*step, testPieceCounts) + for (Color c = WHITE; c <= BLACK; ++c) + for (PieceType pt = PAWN; pt <= KING; ++pt) + if (pieceCount[c][pt] != popcount(pieces(c, pt))) + return false; + + if (step && ++*step, testPieceList) + for (Color c = WHITE; c <= BLACK; ++c) + for (PieceType pt = PAWN; pt <= KING; ++pt) + for (int i = 0; i < pieceCount[c][pt]; ++i) + if ( board[pieceList[c][pt][i]] != make_piece(c, pt) + || index[pieceList[c][pt][i]] != i) return false; - } - } + + if (step && ++*step, testCastlingSquares) + for (Color c = WHITE; c <= BLACK; ++c) + for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) + { + if (!can_castle(c | s)) + continue; + + if ( (castlingRightsMask[king_square(c)] & (c | s)) != (c | s) + || piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK) + || castlingRightsMask[castlingRookSquare[c | s]] != (c | s)) + return false; + } return true; }