X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=0be309ee60cac3d0ea78bcec0ad6c38237e7768b;hp=7e12fdcc433f10f53643bccfad7d08d9fa0b3617;hb=108f0da4d7f993732aa2e854b8f3fa8ca6d3b46c;hpb=9afa1d73306cb98e95acec5daf4efd65e592ceff diff --git a/src/position.cpp b/src/position.cpp index 7e12fdcc..0be309ee 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -52,30 +52,35 @@ namespace { const string PieceToChar(" PNBRQK pnbrqk"); -const Piece Pieces[] = { W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING, - B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING }; +constexpr Piece Pieces[] = { W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING, + B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING }; // min_attacker() is a helper function used by see_ge() to locate the least // valuable attacker for the side to move, remove the attacker we just found // from the bitboards and scan for new X-ray attacks behind it. template -PieceType min_attacker(const Bitboard* bb, Square to, Bitboard stmAttackers, +PieceType min_attacker(const Bitboard* byTypeBB, Square to, Bitboard stmAttackers, Bitboard& occupied, Bitboard& attackers) { - Bitboard b = stmAttackers & bb[Pt]; + Bitboard b = stmAttackers & byTypeBB[Pt]; if (!b) - return min_attacker(bb, to, stmAttackers, occupied, attackers); + return min_attacker(byTypeBB, to, stmAttackers, occupied, attackers); - occupied ^= b & ~(b - 1); + occupied ^= lsb(b); // Remove the attacker from occupied + // Add any X-ray attack behind the just removed piece. For instance with + // rooks in a8 and a7 attacking a1, after removing a7 we add rook in a8. + // Note that new added attackers can be of any color. if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN) - attackers |= attacks_bb(to, occupied) & (bb[BISHOP] | bb[QUEEN]); + attackers |= attacks_bb(to, occupied) & (byTypeBB[BISHOP] | byTypeBB[QUEEN]); if (Pt == ROOK || Pt == QUEEN) - attackers |= attacks_bb(to, occupied) & (bb[ROOK] | bb[QUEEN]); + attackers |= attacks_bb(to, occupied) & (byTypeBB[ROOK] | byTypeBB[QUEEN]); - attackers &= occupied; // After X-ray that may add already processed pieces + // X-ray may add already processed pieces because byTypeBB[] is constant: in + // the rook example, now attackers contains _again_ rook in a7, so remove it. + attackers &= occupied; return (PieceType)Pt; } @@ -317,8 +322,8 @@ void Position::set_castling_right(Color c, Square rfrom) { void Position::set_check_info(StateInfo* si) const { - si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square(WHITE), si->pinnersForKing[WHITE]); - si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square(BLACK), si->pinnersForKing[BLACK]); + si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square(WHITE), si->pinners[BLACK]); + si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square(BLACK), si->pinners[WHITE]); Square ksq = square(~sideToMove); @@ -459,7 +464,7 @@ const string Position::fen() const { Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const { - Bitboard result = 0; + Bitboard blockers = 0; pinners = 0; // Snipers are sliders that attack 's' when a piece is removed @@ -471,14 +476,14 @@ Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners Square sniperSq = pop_lsb(&snipers); Bitboard b = between_bb(s, sniperSq) & pieces(); - if (!more_than_one(b)) + if (b && !more_than_one(b)) { - result |= b; + blockers |= b; if (b & pieces(color_of(piece_on(s)))) pinners |= sniperSq; } } - return result; + return blockers; } @@ -535,7 +540,7 @@ bool Position::legal(Move m) const { // A non-king move is legal if and only if it is not pinned or it // is moving along the ray towards or away from the king. - return !(pinned_pieces(us) & from) + return !(blockers_for_king(us) & from) || aligned(from, to_sq(m), square(us)); } @@ -627,7 +632,7 @@ bool Position::gives_check(Move m) const { return true; // Is there a discovered check? - if ( (discovered_check_candidates() & from) + if ( (st->blockersForKing[~sideToMove] & from) && !aligned(from, to, square(~sideToMove))) return true; @@ -997,11 +1002,12 @@ bool Position::see_ge(Move m, Value threshold) const { if (type_of(m) != NORMAL) return VALUE_ZERO >= threshold; + Bitboard stmAttackers; Square from = from_sq(m), to = to_sq(m); PieceType nextVictim = type_of(piece_on(from)); - Color stm = ~color_of(piece_on(from)); // First consider opponent's move - Value balance; // Values of the pieces taken by us minus opponent's ones - Bitboard occupied, stmAttackers; + Color us = color_of(piece_on(from)); + Color stm = ~us; // First consider opponent's move + Value balance; // Values of the pieces taken by us minus opponent's ones // The opponent may be able to recapture so this is the best result // we can hope for. @@ -1014,65 +1020,57 @@ bool Position::see_ge(Move m, Value threshold) const { // capture our piece for free. balance -= PieceValue[MG][nextVictim]; - if (balance >= VALUE_ZERO) // Always true if nextVictim == KING + // If it is enough (like in PxQ) then return immediately. Note that + // in case nextVictim == KING we always return here, this is ok + // if the given move is legal. + if (balance >= VALUE_ZERO) return true; - bool opponentToMove = true; - occupied = pieces() ^ from ^ to; - - // Find all attackers to the destination square, with the moving piece removed, - // but possibly an X-ray attacker added behind it. + // Find all attackers to the destination square, with the moving piece + // removed, but possibly an X-ray attacker added behind it. + Bitboard occupied = pieces() ^ from ^ to; Bitboard attackers = attackers_to(to, occupied) & occupied; while (true) { - // The balance is negative only because we assumed we could win - // the last piece for free. We are truly winning only if we can - // win the last piece _cheaply enough_. Test if we can actually - // do this otherwise "give up". - assert(balance < VALUE_ZERO); - stmAttackers = attackers & pieces(stm); - // Don't allow pinned pieces to attack pieces except the king as long all - // pinners are on their original square. - if (!(st->pinnersForKing[stm] & ~occupied)) + // Don't allow pinned pieces to attack (except the king) as long as + // all pinners are on their original square. + if (!(st->pinners[~stm] & ~occupied)) stmAttackers &= ~st->blockersForKing[stm]; - // If we have no more attackers we must give up + // If stm has no more attackers then give up: stm loses if (!stmAttackers) break; - // Locate and remove the next least valuable attacker + // Locate and remove the next least valuable attacker, and add to + // the bitboard 'attackers' the possibly X-ray attackers behind it. nextVictim = min_attacker(byTypeBB, to, stmAttackers, occupied, attackers); - if (nextVictim == KING) - { - // Our only attacker is the king. If the opponent still has - // attackers we must give up. Otherwise we make the move and - // (having no more attackers) the opponent must give up. - if (!(attackers & pieces(~stm))) - opponentToMove = !opponentToMove; - break; - } + stm = ~stm; // Switch side to move - // Assume the opponent can win the next piece for free and switch sides - balance += PieceValue[MG][nextVictim]; - opponentToMove = !opponentToMove; + // Negamax the balance with alpha = balance, beta = balance+1 and + // add nextVictim's value. + // + // (balance, balance+1) -> (-balance-1, -balance) + // + assert(balance < VALUE_ZERO); - // If balance is negative after receiving a free piece then give up - if (balance < VALUE_ZERO) - break; + balance = -balance - 1 - PieceValue[MG][nextVictim]; - // Complete the process of switching sides. The first line swaps - // all negative numbers with non-negative numbers. The compiler - // probably knows that it is just the bitwise negation ~balance. - balance = -balance-1; - stm = ~stm; + // If balance is still non-negative after giving away nextVictim then we + // win. The only thing to be careful about it is that we should revert + // stm if we captured with the king when the opponent still has attackers. + if (balance >= VALUE_ZERO) + { + if (nextVictim == KING && (attackers & pieces(stm))) + stm = ~stm; + break; + } + assert(nextVictim != KING); } - - // If the opponent gave up we win, otherwise we lose. - return opponentToMove; + return us != stm; // We break the above loop when stm loses } @@ -1107,6 +1105,35 @@ bool Position::is_draw(int ply) const { } +// Position::has_repeated() tests whether there has been at least one repetition +// of positions since the last capture or pawn move. + +bool Position::has_repeated() const { + + StateInfo* stc = st; + while (true) + { + int i = 4, e = std::min(stc->rule50, stc->pliesFromNull); + + if (e < i) + return false; + + StateInfo* stp = st->previous->previous; + + do { + stp = stp->previous->previous; + + if (stp->key == stc->key) + return true; + + i += 2; + } while (i <= e); + + stc = stc->previous; + } +} + + /// Position::flip() flips position with the white and black sides reversed. This /// is only useful for debugging e.g. for finding evaluation symmetry bugs. @@ -1148,7 +1175,7 @@ void Position::flip() { bool Position::pos_is_ok() const { - const bool Fast = true; // Quick (default) or full check? + constexpr bool Fast = true; // Quick (default) or full check? if ( (sideToMove != WHITE && sideToMove != BLACK) || piece_on(square(WHITE)) != W_KING