X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=fdf3e911e9db32250781f6f8287451cc6eccbedf;hp=83a83c1887eddbfa7731c1f1b537a5d995822fba;hb=683e6dc6566719f8737fad9bc30580bb0b4d8d20;hpb=1d2247aea39074d8ecea4a5ce81b1cf85165538e diff --git a/src/position.cpp b/src/position.cpp index 83a83c18..fdf3e911 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -118,7 +118,7 @@ void Position::from_fen(const std::string& fen) { } sideToMove = (fen[i] == 'w' ? WHITE : BLACK); - // Castling rights: + // Castling rights i++; if (fen[i] != ' ') { @@ -128,8 +128,10 @@ void Position::from_fen(const std::string& fen) { i++; while(strchr("KQkqabcdefghABCDEFGH-", fen[i])) { - if(fen[i] == '-') { - i++; break; + if (fen[i] == '-') + { + i++; + break; } else if(fen[i] == 'K') allow_oo(WHITE); else if(fen[i] == 'Q') allow_ooo(WHITE); @@ -321,29 +323,42 @@ void Position::copy(const Position &pos) { /// king) pieces for the given color. Bitboard Position::pinned_pieces(Color c) const { + if (pinned[c] != ~EmptyBoardBB) + return pinned[c]; + + Bitboard p1, p2; Square ksq = king_square(c); - return hidden_checks(c, ksq) | hidden_checks(c, ksq); + pinned[c] = hidden_checks(c, ksq, p1) | hidden_checks(c, ksq, p2); + pinners[c] = p1 | p2; + return pinned[c]; } +Bitboard Position::pinned_pieces(Color c, Bitboard& p) const { + + if (pinned[c] == ~EmptyBoardBB) + pinned_pieces(c); -/// Position:discovered_check_candidates() returns a bitboard containing all -/// pieces for the given side which are candidates for giving a discovered -/// check. The code is almost the same as the function for finding pinned -/// pieces. + p = pinners[c]; + return pinned[c]; +} Bitboard Position::discovered_check_candidates(Color c) const { + if (dcCandidates[c] != ~EmptyBoardBB) + return dcCandidates[c]; + + Bitboard dummy; Square ksq = king_square(opposite_color(c)); - return hidden_checks(c, ksq) | hidden_checks(c, ksq); + dcCandidates[c] = hidden_checks(c, ksq, dummy) | hidden_checks(c, ksq, dummy); + return dcCandidates[c]; } - /// Position:hidden_checks<>() returns a bitboard of all pinned (against the /// king) pieces for the given color and for the given pinner type. Or, when /// template parameter FindPinned is false, the pinned pieces of opposite color /// that are, indeed, the pieces candidate for a discovery check. template -Bitboard Position::hidden_checks(Color c, Square ksq) const { +Bitboard Position::hidden_checks(Color c, Square ksq, Bitboard& pinners) const { Square s; Bitboard sliders, result = EmptyBoardBB; @@ -360,7 +375,7 @@ Bitboard Position::hidden_checks(Color c, Square ksq) const { // Pinners are sliders, not checkers, that give check when // candidate pinned are removed. - Bitboard pinners = (FindPinned ? sliders & ~checkersBB : sliders); + pinners = (FindPinned ? sliders & ~checkersBB : sliders); if (Piece == ROOK) pinners &= rook_attacks_bb(ksq, occupied_squares() ^ candidate_pinned); @@ -369,12 +384,16 @@ Bitboard Position::hidden_checks(Color c, Square ksq) const { // Finally for each pinner find the corresponding pinned piece (if same color of king) // or discovery checker (if opposite color) among the candidates. - while (pinners) + Bitboard p = pinners; + while (p) { - s = pop_1st_bit(&pinners); + s = pop_1st_bit(&p); result |= (squares_between(s, ksq) & candidate_pinned); } } + else + pinners = EmptyBoardBB; + return result; } @@ -397,12 +416,12 @@ Bitboard Position::attacks_to(Square s) const { /// Position::piece_attacks_square() tests whether the piece on square f /// attacks square t. -bool Position::piece_attacks_square(Square f, Square t) const { +bool Position::piece_attacks_square(Piece p, Square f, Square t) const { assert(square_is_ok(f)); assert(square_is_ok(t)); - switch (piece_on(f)) + switch (p) { case WP: return pawn_attacks_square(WHITE, f, t); case BP: return pawn_attacks_square(BLACK, f, t); @@ -418,8 +437,7 @@ bool Position::piece_attacks_square(Square f, Square t) const { /// Position::move_attacks_square() tests whether a move from the current -/// position attacks a given square. Only attacks by the moving piece are -/// considered; the function does not handle X-ray attacks. +/// position attacks a given square. bool Position::move_attacks_square(Move m, Square s) const { @@ -430,18 +448,20 @@ bool Position::move_attacks_square(Move m, Square s) const { assert(square_is_occupied(f)); - switch (piece_on(f)) - { - case WP: return pawn_attacks_square(WHITE, t, s); - case BP: return pawn_attacks_square(BLACK, t, s); - case WN: case BN: return piece_attacks_square(t, s); - case WB: case BB: return piece_attacks_square(t, s); - case WR: case BR: return piece_attacks_square(t, s); - case WQ: case BQ: return piece_attacks_square(t, s); - case WK: case BK: return piece_attacks_square(t, s); - default: break; - } - return false; + if (piece_attacks_square(piece_on(f), t, s)) + return true; + + // Move the piece and scan for X-ray attacks behind it + Bitboard occ = occupied_squares(); + Color us = color_of_piece_on(f); + clear_bit(&occ, f); + set_bit(&occ, t); + Bitboard xray = ( (rook_attacks_bb(s, occ) & rooks_and_queens()) + |(bishop_attacks_bb(s, occ) & bishops_and_queens())) & pieces_of_color(us); + + // If we have attacks we need to verify that are caused by our move + // and are not already existent ones. + return xray && (xray ^ (xray & piece_attacks(s))); } @@ -458,22 +478,12 @@ void Position::find_checkers() { } -/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal. -/// There are two versions of this function: One which takes only a -/// move as input, and one which takes a move and a bitboard of pinned -/// pieces. The latter function is faster, and should always be preferred -/// when a pinned piece bitboard has already been computed. - -bool Position::pl_move_is_legal(Move m) const { - - return pl_move_is_legal(m, pinned_pieces(side_to_move())); -} +/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal -bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { +bool Position::pl_move_is_legal(Move m) const { assert(is_ok()); assert(move_is_ok(m)); - assert(pinned == pinned_pieces(side_to_move())); // If we're in check, all pseudo-legal moves are legal, because our // check evasion generator only generates true legal moves. @@ -490,7 +500,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { Square ksq = king_square(us); assert(color_of_piece_on(from) == us); - assert(piece_on(ksq) == king_of_color(us)); + assert(piece_on(ksq) == piece_of_color_and_type(us, KING)); // En passant captures are a tricky special case. Because they are // rather uncommon, we do it simply by testing whether the king is attacked @@ -502,8 +512,8 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { Bitboard b = occupied_squares(); assert(to == ep_square()); - assert(piece_on(from) == pawn_of_color(us)); - assert(piece_on(capsq) == pawn_of_color(them)); + assert(piece_on(from) == piece_of_color_and_type(us, PAWN)); + assert(piece_on(capsq) == piece_of_color_and_type(them, PAWN)); assert(piece_on(to) == EMPTY); clear_bit(&b, from); @@ -521,37 +531,27 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) 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 ( !bit_is_set(pinned, from) + return ( !bit_is_set(pinned_pieces(us), from) || (direction_between_squares(from, ksq) == direction_between_squares(move_to(m), ksq))); } -/// Position::move_is_check() tests whether a pseudo-legal move is a check. -/// There are two versions of this function: One which takes only a move as -/// input, and one which takes a move and a bitboard of discovered check -/// candidates. The latter function is faster, and should always be preferred -/// when a discovered check candidates bitboard has already been computed. +/// Position::move_is_check() tests whether a pseudo-legal move is a check bool Position::move_is_check(Move m) const { - Bitboard dc = discovered_check_candidates(side_to_move()); - return move_is_check(m, dc); -} - -bool Position::move_is_check(Move m, Bitboard dcCandidates) const { - assert(is_ok()); assert(move_is_ok(m)); - assert(dcCandidates == discovered_check_candidates(side_to_move())); Color us = side_to_move(); Color them = opposite_color(us); Square from = move_from(m); Square to = move_to(m); Square ksq = king_square(them); + Bitboard dcCandidates = discovered_check_candidates(us); assert(color_of_piece_on(from) == us); - assert(piece_on(ksq) == king_of_color(them)); + assert(piece_on(ksq) == piece_of_color_and_type(them, KING)); // Proceed according to the type of the moving piece switch (type_of_piece_on(from)) @@ -663,7 +663,7 @@ bool Position::move_is_capture(Move m) const { assert(m != MOVE_NONE); return ( !square_is_empty(move_to(m)) - && (color_of_piece_on(move_to(m)) == opposite_color(side_to_move())) + && (color_of_piece_on(move_to(m)) != color_of_piece_on(move_from(m))) ) || move_is_ep(m); } @@ -689,6 +689,13 @@ void Position::backup(UndoInfo& u) const { u.mgValue = mgValue; u.egValue = egValue; u.capture = NO_PIECE_TYPE; + + for (Color c = WHITE; c <= BLACK; c++) + { + u.pinners[c] = pinners[c]; + u.pinned[c] = pinned[c]; + u.dcCandidates[c] = dcCandidates[c]; + } } @@ -708,10 +715,21 @@ void Position::restore(const UndoInfo& u) { mgValue = u.mgValue; egValue = u.egValue; // u.capture is restored in undo_move() + + for (Color c = WHITE; c <= BLACK; c++) + { + pinners[c] = u.pinners[c]; + pinned[c] = u.pinned[c]; + dcCandidates[c] = u.dcCandidates[c]; + } } + +/// Position::update_checkers() is a private method to udpate chekers info + template -inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square from, Square to, Bitboard dcCandidates) { +inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square from, + Square to, Bitboard dcCandidates) { if (Piece != KING && bit_is_set(piece_attacks(ksq), to)) set_bit(pCheckersBB, to); @@ -726,25 +744,20 @@ inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square } } + /// Position::do_move() makes a move, and backs up all information necessary /// to undo the move to an UndoInfo object. The move is assumed to be legal. /// Pseudo-legal moves should be filtered out before this function is called. -/// There are two versions of this function, one which takes only the move and -/// the UndoInfo as input, and one which takes a third parameter, a bitboard of -/// discovered check candidates. The second version is faster, because knowing -/// the discovered check candidates makes it easier to update the checkersBB -/// member variable in the position object. void Position::do_move(Move m, UndoInfo& u) { - do_move(m, u, discovered_check_candidates(side_to_move())); -} - -void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) { - assert(is_ok()); assert(move_is_ok(m)); + // Get now the current (pre-move) dc candidates that we will use + // in update_checkers(). + Bitboard oldDcCandidates = discovered_check_candidates(side_to_move()); + // Back up the necessary information to our UndoInfo object (except the // captured piece, which is taken care of later. backup(u); @@ -757,6 +770,10 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) { // case of non-reversible moves is taken care of later. rule50++; + // Reset pinned bitboard and its friends + for (Color c = WHITE; c <= BLACK; c++) + pinners[c] = pinned[c] = dcCandidates[c] = ~EmptyBoardBB; + if (move_is_castle(m)) do_castle_move(m); else if (move_promotion(m)) @@ -848,38 +865,13 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) { Square ksq = king_square(them); switch (piece) { - case PAWN: - if (bit_is_set(pawn_attacks(them, ksq), to)) - set_bit(&checkersBB, to); - - if (bit_is_set(dcCandidates, from)) - checkersBB |= ( (piece_attacks(ksq) & rooks_and_queens(us)) - |(piece_attacks(ksq) & bishops_and_queens(us))); - break; - - case KNIGHT: - update_checkers(&checkersBB, ksq, from, to, dcCandidates); - break; - - case BISHOP: - update_checkers(&checkersBB, ksq, from, to, dcCandidates); - break; - - case ROOK: - update_checkers(&checkersBB, ksq, from, to, dcCandidates); - break; - - case QUEEN: - update_checkers(&checkersBB, ksq, from, to, dcCandidates); - break; - - case KING: - update_checkers(&checkersBB, ksq, from, to, dcCandidates); - break; - - default: - assert(false); - break; + case PAWN: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case KNIGHT: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case BISHOP: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case ROOK: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case QUEEN: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case KING: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + default: assert(false); break; } } @@ -894,6 +886,7 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) { assert(is_ok()); } + /// Position::do_capture_move() is a private method used to update captured /// piece info. It is called from the main Position::do_move function. @@ -956,8 +949,8 @@ void Position::do_castle_move(Move m) { Square rfrom = move_to(m); // HACK: See comment at beginning of function Square kto, rto; - assert(piece_on(kfrom) == king_of_color(us)); - assert(piece_on(rfrom) == rook_of_color(us)); + assert(piece_on(kfrom) == piece_of_color_and_type(us, KING)); + assert(piece_on(rfrom) == piece_of_color_and_type(us, ROOK)); // Find destination squares for king and rook if (rfrom > kfrom) // O-O @@ -987,8 +980,8 @@ void Position::do_castle_move(Move m) { // Update board array board[kfrom] = board[rfrom] = EMPTY; - board[kto] = king_of_color(us); - board[rto] = rook_of_color(us); + board[kto] = piece_of_color_and_type(us, KING); + board[rto] = piece_of_color_and_type(us, ROOK); // Update king square kingSquare[us] = kto; @@ -1015,7 +1008,7 @@ void Position::do_castle_move(Move m) { key ^= zobrist[us][ROOK][rfrom] ^ zobrist[us][ROOK][rto]; // Clear en passant square - if(epSquare != SQ_NONE) + if (epSquare != SQ_NONE) { key ^= zobEp[epSquare]; epSquare = SQ_NONE; @@ -1055,7 +1048,7 @@ void Position::do_promotion_move(Move m, UndoInfo &u) { to = move_to(m); assert(relative_rank(us, to) == RANK_8); - assert(piece_on(from) == pawn_of_color(us)); + assert(piece_on(from) == piece_of_color_and_type(us, PAWN)); assert(color_of_piece_on(to) == them || square_is_empty(to)); capture = type_of_piece_on(to); @@ -1152,8 +1145,8 @@ void Position::do_ep_move(Move m) { assert(to == epSquare); assert(relative_rank(us, to) == RANK_6); assert(piece_on(to) == EMPTY); - assert(piece_on(from) == pawn_of_color(us)); - assert(piece_on(capsq) == pawn_of_color(them)); + assert(piece_on(from) == piece_of_color_and_type(us, PAWN)); + assert(piece_on(capsq) == piece_of_color_and_type(them, PAWN)); // Remove captured piece clear_bit(&(byColorBB[them]), capsq); @@ -1213,8 +1206,8 @@ void Position::do_ep_move(Move m) { } -/// Position::undo_move() unmakes a move. When it returns, the position should -/// be restored to exactly the same state as before the move was made. It is +/// Position::undo_move() unmakes a move. When it returns, the position should +/// be restored to exactly the same state as before the move was made. It is /// important that Position::undo_move is called with the same move and UndoInfo /// object as the earlier call to Position::do_move. @@ -1330,8 +1323,8 @@ void Position::undo_castle_move(Move m) { rto = relative_square(us, SQ_D1); } - assert(piece_on(kto) == king_of_color(us)); - assert(piece_on(rto) == rook_of_color(us)); + assert(piece_on(kto) == piece_of_color_and_type(us, KING)); + assert(piece_on(rto) == piece_of_color_and_type(us, ROOK)); // Remove pieces from destination squares clear_bit(&(byColorBB[us]), kto); @@ -1351,8 +1344,8 @@ void Position::undo_castle_move(Move m) { // Update board board[rto] = board[kto] = EMPTY; - board[rfrom] = rook_of_color(us); - board[kfrom] = king_of_color(us); + board[rfrom] = piece_of_color_and_type(us, ROOK); + board[kfrom] = piece_of_color_and_type(us, KING); // Update king square kingSquare[us] = kfrom; @@ -1403,7 +1396,7 @@ void Position::undo_promotion_move(Move m, const UndoInfo &u) { set_bit(&(byColorBB[us]), from); set_bit(&(byTypeBB[PAWN]), from); set_bit(&(byTypeBB[0]), from); // HACK: byTypeBB[0] == occupied squares - board[from] = pawn_of_color(us); + board[from] = piece_of_color_and_type(us, PAWN); // Update material npMaterial[us] -= piece_value_midgame(promotion); @@ -1468,7 +1461,7 @@ void Position::undo_ep_move(Move m) { assert(to == ep_square()); assert(relative_rank(us, to) == RANK_6); - assert(piece_on(to) == pawn_of_color(us)); + assert(piece_on(to) == piece_of_color_and_type(us, PAWN)); assert(piece_on(from) == EMPTY); assert(piece_on(capsq) == EMPTY); @@ -1476,7 +1469,7 @@ void Position::undo_ep_move(Move m) { set_bit(&(byColorBB[them]), capsq); set_bit(&(byTypeBB[PAWN]), capsq); set_bit(&(byTypeBB[0]), capsq); - board[capsq] = pawn_of_color(them); + board[capsq] = piece_of_color_and_type(them, PAWN); // Remove moving piece from destination square clear_bit(&(byColorBB[us]), to); @@ -1488,7 +1481,7 @@ void Position::undo_ep_move(Move m) { set_bit(&(byColorBB[us]), from); set_bit(&(byTypeBB[PAWN]), from); set_bit(&(byTypeBB[0]), from); - board[from] = pawn_of_color(us); + board[from] = piece_of_color_and_type(us, PAWN); // Update piece list: pieceList[us][PAWN][index[to]] = from; @@ -1504,7 +1497,7 @@ void Position::undo_ep_move(Move m) { /// Position::do_null_move makes() a "null move": It switches the side to move /// and updates the hash key without executing any move on the board. -void Position::do_null_move(UndoInfo &u) { +void Position::do_null_move(UndoInfo& u) { assert(is_ok()); assert(!is_check()); @@ -1562,11 +1555,11 @@ void Position::undo_null_move(const UndoInfo &u) { } -/// Position::see() is a static exchange evaluator: It tries to estimate the +/// Position::see() is a static exchange evaluator: It tries to estimate the /// material gain or loss resulting from a move. There are three versions of /// this function: One which takes a destination square as input, one takes a -/// move, and one which takes a 'from' and a 'to' square. The function does -/// not yet understand promotions or en passant captures. +/// move, and one which takes a 'from' and a 'to' square. The function does +/// not yet understand promotions captures. int Position::see(Square to) const { @@ -1608,8 +1601,8 @@ int Position::see(Square from, Square to) const { // removed, but possibly an X-ray attacker added behind it. occ = occupied_squares(); - // Handle enpassant moves - if (ep_square() == to && type_of_piece_on(from) == PAWN) + // Handle en passant moves + if (epSquare == to && type_of_piece_on(from) == PAWN) { assert(capture == EMPTY); @@ -1735,6 +1728,8 @@ void Position::clear() { } checkersBB = EmptyBoardBB; + for (Color c = WHITE; c <= BLACK; c++) + pinners[c] = pinned[c] = dcCandidates[c] = ~EmptyBoardBB; lastMove = MOVE_NONE; @@ -1749,7 +1744,7 @@ void Position::clear() { } -/// Position::reset_game_ply() simply sets gamePly to 0. It is used from the +/// Position::reset_game_ply() simply sets gamePly to 0. It is used from the /// UCI interface code, whenever a non-reversible move is made in a /// 'position fen moves m1 m2 ...' command. This makes it possible /// for the program to handle games of arbitrary length, as long as the GUI @@ -1826,7 +1821,7 @@ Key Position::compute_key() const { } -/// Position::compute_pawn_key() computes the hash key of the position. The +/// Position::compute_pawn_key() computes the hash key of the position. The /// hash key is usually updated incrementally as moves are made and unmade, /// the compute_pawn_key() function is only used when a new position is set /// up, and to verify the correctness of the pawn hash key when running in @@ -1872,7 +1867,7 @@ Key Position::compute_material_key() const { /// Position::compute_mg_value() and Position::compute_eg_value() compute the -/// incremental scores for the middle game and the endgame. These functions +/// incremental scores for the middle game and the endgame. These functions /// are used to initialize the incremental scores when a new position is set /// up, and to verify that the scores are correctly updated by do_move /// and undo_move when the program is running in debug mode. @@ -1921,7 +1916,7 @@ Value Position::compute_eg_value() const { /// Position::compute_non_pawn_material() computes the total non-pawn middle -/// game material score for the given side. Material scores are updated +/// game material score for the given side. Material scores are updated /// incrementally during the search, this function is only used while /// initializing a new Position object. @@ -1960,7 +1955,7 @@ bool Position::is_mate() const { /// Position::is_draw() tests whether the position is drawn by material, -/// repetition, or the 50 moves rule. It does not detect stalemates, this +/// repetition, or the 50 moves rule. It does not detect stalemates, this /// must be done by the search. bool Position::is_draw() const { @@ -2086,7 +2081,7 @@ void Position::init_piece_square_tables() { /// Position::flipped_copy() makes a copy of the input position, but with -/// the white and black sides reversed. This is only useful for debugging, +/// the white and black sides reversed. This is only useful for debugging, /// especially for finding evaluation symmetry bugs. void Position::flipped_copy(const Position &pos) { @@ -2197,7 +2192,7 @@ bool Position::is_ok(int* failedStep) const { if (type_of_piece_on(s) == KING) kingCount[color_of_piece_on(s)]++; - if(kingCount[0] != 1 || kingCount[1] != 1) + if (kingCount[0] != 1 || kingCount[1] != 1) return false; } @@ -2277,10 +2272,10 @@ bool Position::is_ok(int* failedStep) const { if (failedStep) (*failedStep)++; if (debugNonPawnMaterial) { - if(npMaterial[WHITE] != compute_non_pawn_material(WHITE)) + if (npMaterial[WHITE] != compute_non_pawn_material(WHITE)) return false; - if(npMaterial[BLACK] != compute_non_pawn_material(BLACK)) + if (npMaterial[BLACK] != compute_non_pawn_material(BLACK)) return false; }