X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fposition.cpp;h=6d416276c651aeb69cbd420a6335f02e84512596;hb=7b4f5c8f72435cf6b9862ecd445aaf4627cc4f59;hp=0c81763155d078275263430b17b4a044269daeab;hpb=0504a6975d8f32ee9638e05b53ed32e3f7a7f4e1;p=stockfish diff --git a/src/position.cpp b/src/position.cpp index 0c817631..6d416276 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -68,22 +68,19 @@ PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stm Bitboard& occupied, Bitboard& attackers) { Bitboard b = stmAttackers & bb[Pt]; + if (!b) + return min_attacker(bb, to, stmAttackers, occupied, attackers); - if (b) - { - occupied ^= b & ~(b - 1); - - if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN) - attackers |= attacks_bb(to, occupied) & (bb[BISHOP] | bb[QUEEN]); + occupied ^= b & ~(b - 1); - if (Pt == ROOK || Pt == QUEEN) - attackers |= attacks_bb(to, occupied) & (bb[ROOK] | bb[QUEEN]); + if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN) + attackers |= attacks_bb(to, occupied) & (bb[BISHOP] | bb[QUEEN]); - attackers &= occupied; // Remove the just found attacker + if (Pt == ROOK || Pt == QUEEN) + attackers |= attacks_bb(to, occupied) & (bb[ROOK] | bb[QUEEN]); - return (PieceType)Pt; - } - return min_attacker(bb, to, stmAttackers, occupied, attackers); + attackers &= occupied; // After X-ray that may add already processed pieces + return (PieceType)Pt; } template<> FORCE_INLINE @@ -395,16 +392,18 @@ const string Position::pretty(Move move) const { string brd = twoRows + twoRows + twoRows + twoRows + dottedLine; + for (Bitboard b = pieces(); b; ) + { + Square s = pop_lsb(&b); + brd[513 - 68 * rank_of(s) + 4 * file_of(s)] = PieceToChar[piece_on(s)]; + } + std::ostringstream ss; if (move) ss << "\nMove: " << (sideToMove == BLACK ? ".." : "") << move_to_san(*const_cast(this), move); - for (Square sq = SQ_A1; sq <= SQ_H8; sq++) - if (piece_on(sq) != NO_PIECE) - brd[513 - 68*rank_of(sq) + 4*file_of(sq)] = PieceToChar[piece_on(sq)]; - ss << brd << "\nFen: " << fen() << "\nKey: " << std::hex << std::uppercase << std::setfill('0') << std::setw(16) << st->key << "\nCheckers: "; @@ -545,7 +544,7 @@ bool Position::is_pseudo_legal(const Move m) const { return false; // The destination square cannot be occupied by a friendly piece - if (piece_on(to) != NO_PIECE && color_of(piece_on(to)) == us) + if (pieces(us) & to) return false; // Handle the special case of a pawn move @@ -655,7 +654,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { return true; // Discovery check ? - if (ci.dcCandidates && (ci.dcCandidates & from)) + if (unlikely(ci.dcCandidates) && (ci.dcCandidates & from)) { // For pawn and king moves we need to verify also direction if ( (pt != PAWN && pt != KING) @@ -798,17 +797,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI byTypeBB[capture] ^= capsq; byColorBB[them] ^= capsq; - // Update piece list, move the last piece at index[capsq] position and - // shrink the list. - // - // WARNING: This is a not reversible 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 lastSquare = pieceList[them][capture][--pieceCount[them][capture]]; - index[lastSquare] = index[capsq]; - pieceList[them][capture][index[lastSquare]] = lastSquare; - pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE; + // Update piece lists + remove_piece(capsq, them, capture); // Update material hash key and prefetch access to materialTable k ^= Zobrist::psq[them][capture][capsq]; @@ -854,10 +844,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI board[from] = NO_PIECE; board[to] = pc; - // Update piece lists, index[from] is not updated and becomes stale. This - // works as long as index[] is accessed just by known occupied squares. - index[to] = index[from]; - pieceList[us][pt][index[to]] = to; + move_piece(from, to, us, pt); } // If the moving piece is a pawn do some special extra work @@ -883,19 +870,14 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI byTypeBB[promotion] |= to; board[to] = make_piece(us, promotion); - // Update piece lists, move the last pawn at index[to] position - // and shrink the list. Add a new promotion piece to the list. - Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]]; - index[lastSquare] = index[to]; - pieceList[us][PAWN][index[lastSquare]] = lastSquare; - pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE; - index[to] = pieceCount[us][promotion]; - pieceList[us][promotion][index[to]] = to; + // Update piece lists and add a new promotion piece to the list + remove_piece(to, us, PAWN); + add_piece(to, us, promotion); // Update hash keys k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to]; st->pawnKey ^= Zobrist::psq[us][PAWN][to]; - st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]++] + st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]-1] ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]]; // Update incremental score @@ -985,14 +967,9 @@ void Position::undo_move(Move m) { byTypeBB[PAWN] |= to; board[to] = make_piece(us, PAWN); - // Update piece lists, move the last promoted piece at index[to] position - // and shrink the list. Add a new pawn to the list. - Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]]; - index[lastSquare] = index[to]; - pieceList[us][promotion][index[lastSquare]] = lastSquare; - pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE; - index[to] = pieceCount[us][PAWN]++; - pieceList[us][PAWN][index[to]] = to; + // Update piece lists and add new pawn to the list + remove_piece(to, us, promotion); + add_piece(to, us, PAWN); pt = PAWN; } @@ -1018,10 +995,7 @@ void Position::undo_move(Move m) { board[to] = NO_PIECE; board[from] = make_piece(us, pt); - // Update piece lists, index[to] is not updated and becomes stale. This - // works as long as index[] is accessed just by known occupied squares. - index[from] = index[to]; - pieceList[us][pt][index[from]] = from; + move_piece(to, from, us, pt); } if (capture) @@ -1046,8 +1020,7 @@ void Position::undo_move(Move m) { board[capsq] = make_piece(them, capture); // Update piece list, add a new captured piece in capsq square - index[capsq] = pieceCount[them][capture]++; - pieceList[them][capture][index[capsq]] = capsq; + add_piece(capsq, them, capture); } // Finally point our state pointer back to the previous state @@ -1136,7 +1109,7 @@ int Position::see_sign(Move m) const { // Early return if SEE cannot be negative because captured piece value // is not less then capturing one. Note that king moves always return // here because king midgame value is set to 0. - if (PieceValue[MG][piece_on(to_sq(m))] >= PieceValue[MG][piece_moved(m)]) + if (PieceValue[MG][piece_moved(m)] <= PieceValue[MG][piece_on(to_sq(m))]) return 1; return see(m); @@ -1154,36 +1127,31 @@ int Position::see(Move m, int asymmThreshold) const { from = from_sq(m); to = to_sq(m); - captured = type_of(piece_on(to)); + swapList[0] = PieceValue[MG][type_of(piece_on(to))]; + stm = color_of(piece_on(from)); occupied = pieces() ^ from; - // Handle en passant moves + // Castle moves are implemented as king capturing the rook so cannot be + // handled correctly. Simply return 0 that is always the correct value + // unless in the rare case the rook ends up under attack. + if (type_of(m) == CASTLE) + return 0; + if (type_of(m) == ENPASSANT) { - Square capQq = to - pawn_push(sideToMove); - - assert(!captured); - assert(type_of(piece_on(capQq)) == PAWN); - - // Remove the captured pawn - occupied ^= capQq; - captured = PAWN; + occupied ^= to - pawn_push(stm); // Remove the captured pawn + swapList[0] = PieceValue[MG][PAWN]; } - else if (type_of(m) == CASTLE) - // Castle moves are implemented as king capturing the rook so cannot be - // handled correctly. Simply return 0 that is always the correct value - // unless the rook is ends up under attack. - return 0; // Find all attackers to the destination square, with the moving piece // removed, but possibly an X-ray attacker added behind it. - attackers = attackers_to(to, occupied); + attackers = attackers_to(to, occupied) & occupied; // If the opponent has no attackers we are finished - stm = ~color_of(piece_on(from)); + stm = ~stm; stmAttackers = attackers & pieces(stm); if (!stmAttackers) - return PieceValue[MG][captured]; + return swapList[0]; // The destination square is defended, which makes things rather more // difficult to compute. We proceed by building up a "swap list" containing @@ -1191,7 +1159,6 @@ int Position::see(Move m, int asymmThreshold) const { // destination square, where the sides alternately capture, and always // capture with the least valuable piece. After each capture, we look for // new X-ray attacks from behind the capturing piece. - swapList[0] = PieceValue[MG][captured]; captured = type_of(piece_on(from)); do { @@ -1206,12 +1173,10 @@ int Position::see(Move m, int asymmThreshold) const { stm = ~stm; stmAttackers = attackers & pieces(stm); - if (captured == KING) + // Stop before processing a king capture + if (captured == KING && stmAttackers) { - // Stop before processing a king capture - if (stmAttackers) - swapList[slIndex++] = QueenValueMg * 16; - + swapList[slIndex++] = QueenValueMg * 16; break; } @@ -1259,8 +1224,7 @@ void Position::put_piece(Piece p, Square s) { PieceType pt = type_of(p); board[s] = p; - index[s] = pieceCount[c][pt]++; - pieceList[c][pt][index[s]] = s; + add_piece(s, c, pt); byTypeBB[ALL_PIECES] |= s; byTypeBB[pt] |= s;