X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=a999b4c6f0e5ee5a67981184e8bd2e89cf52cb90;hp=31176c9d42ead1a504a57c426b1b40c748a7f6c1;hb=5f142ec2098531bac1780f67579dedbd12d18dcc;hpb=088ecc242f6ef35e7785577482535ebfad56b975 diff --git a/src/position.cpp b/src/position.cpp index 31176c9d..a999b4c6 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] != ' ') { @@ -323,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 { -/// 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. + if (pinned[c] == ~EmptyBoardBB) + pinned_pieces(c); + + 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; @@ -362,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); @@ -371,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; } @@ -399,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); @@ -420,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 { @@ -432,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))); } @@ -492,7 +510,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 @@ -504,8 +522,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); @@ -553,7 +571,7 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const { Square ksq = king_square(them); 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)) @@ -665,7 +683,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); } @@ -691,6 +709,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]; + } } @@ -710,6 +735,13 @@ 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]; + } } @@ -747,7 +779,7 @@ 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) { +void Position::do_move(Move m, UndoInfo& u, Bitboard dc) { assert(is_ok()); assert(move_is_ok(m)); @@ -764,6 +796,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)) @@ -855,12 +891,12 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dcCandidates) { Square ksq = king_square(them); switch (piece) { - case PAWN: update_checkers(&checkersBB, ksq, from, to, dcCandidates); 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; + case PAWN: update_checkers(&checkersBB, ksq, from, to, dc); break; + case KNIGHT: update_checkers(&checkersBB, ksq, from, to, dc); break; + case BISHOP: update_checkers(&checkersBB, ksq, from, to, dc); break; + case ROOK: update_checkers(&checkersBB, ksq, from, to, dc); break; + case QUEEN: update_checkers(&checkersBB, ksq, from, to, dc); break; + case KING: update_checkers(&checkersBB, ksq, from, to, dc); break; default: assert(false); break; } } @@ -939,8 +975,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 @@ -970,8 +1006,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; @@ -1038,7 +1074,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); @@ -1135,8 +1171,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); @@ -1313,8 +1349,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); @@ -1334,8 +1370,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; @@ -1386,7 +1422,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); @@ -1451,7 +1487,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); @@ -1459,7 +1495,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); @@ -1471,7 +1507,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; @@ -1718,6 +1754,8 @@ void Position::clear() { } checkersBB = EmptyBoardBB; + for (Color c = WHITE; c <= BLACK; c++) + pinners[c] = pinned[c] = dcCandidates[c] = ~EmptyBoardBB; lastMove = MOVE_NONE;