diff --git a/src/movegen.cpp b/src/movegen.cpp index 23f6c1bc..0af95e2d 100644 --- a/src/movegen.cpp +++ b/src/movegen.cpp @@ -191,74 +191,69 @@ MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bi } -/// generate_evasions() generates all check evasions when the side to move is -/// in check. Unlike the other move generation functions, this one generates -/// only legal moves. Returns a pointer to the end of the move list. +/// generate_evasions() generates all pseudo-legal check evasions when +/// the side to move is in check. Returns a pointer to the end of the move list. MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned) { assert(pos.is_ok()); assert(pos.is_check()); - Square from, to; + Bitboard b; + Square from, to, checksq; + int checkersCnt = 0; Color us = pos.side_to_move(); Color them = opposite_color(us); Square ksq = pos.king_square(us); - Bitboard sliderAttacks = EmptyBoardBB; Bitboard checkers = pos.checkers(); + Bitboard sliderAttacks = EmptyBoardBB; assert(pos.piece_on(ksq) == piece_of_color_and_type(us, KING)); - - // The bitboard of occupied pieces without our king - Bitboard b_noKing = pos.occupied_squares(); - clear_bit(&b_noKing, ksq); + assert(checkers); // Find squares attacked by slider checkers, we will remove - // them from the king evasions set so to avoid a couple - // of cycles in the slow king evasions legality check loop - // and to be able to use attackers_to(). - Bitboard b = checkers & pos.pieces(BISHOP, QUEEN); - while (b) + // them from the king evasions set so to early skip known + // illegal moves and avoid an useless legality check later. + b = checkers; + do { - from = pop_1st_bit(&b); - sliderAttacks |= bishop_attacks_bb(from, b_noKing); - } + checkersCnt++; + checksq = pop_1st_bit(&b); - b = checkers & pos.pieces(ROOK, QUEEN); - while (b) - { - from = pop_1st_bit(&b); - sliderAttacks |= rook_attacks_bb(from, b_noKing); - } + assert(pos.color_of_piece_on(checksq) == them); + + switch (pos.type_of_piece_on(checksq)) + { + case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break; + case ROOK: sliderAttacks |= RookPseudoAttacks[checksq]; break; + case QUEEN: + // In case of a queen remove also squares attacked in the other direction to + // avoid possible illegal moves when queen and king are on adjacent squares. + if (direction_is_straight(checksq, ksq)) + sliderAttacks |= RookPseudoAttacks[checksq] | pos.attacks_from(checksq); + else + sliderAttacks |= BishopPseudoAttacks[checksq] | pos.attacks_from(checksq); + default: + break; + } + } while (b); // Generate evasions for king, capture and non capture moves - Bitboard enemy = pos.pieces_of_color(them); - Bitboard b1 = pos.attacks_from(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks; - while (b1) - { - // Note that we can use attackers_to() only because we have already - // removed from b1 the squares attacked by slider checkers. - to = pop_1st_bit(&b1); - if (!(pos.attackers_to(to) & enemy)) - (*mlist++).move = make_move(ksq, to); - } + b = pos.attacks_from(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks; + from = ksq; + SERIALIZE_MOVES(b); - // Generate evasions for other pieces only if not double check. We use a - // simple bit twiddling hack here rather than calling count_1s in order to - // save some time (we know that pos.checkers() has at most two nonzero bits). - if (checkers & (checkers - 1)) // Two bits set? + // Generate evasions for other pieces only if not double check + if (checkersCnt > 1) return mlist; - Square checksq = first_1(checkers); Bitboard target = squares_between(checksq, ksq); - assert(pos.color_of_piece_on(checksq) == them); - // Pawn captures - b1 = pos.attacks_from(checksq, them) & pos.pieces(PAWN, us) & ~pinned; - while (b1) + b = pos.attacks_from(checksq, them) & pos.pieces(PAWN, us) & ~pinned; + while (b) { - from = pop_1st_bit(&b1); + from = pop_1st_bit(&b); if (relative_rank(us, checksq) == RANK_8) { (*mlist++).move = make_promotion_move(from, checksq, QUEEN); @@ -277,10 +272,10 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin target |= checkers; // Captures and blocking evasions for the other pieces - mlist = generate_piece_evasions(pos, mlist, us, target, pinned); - mlist = generate_piece_evasions(pos, mlist, us, target, pinned); - mlist = generate_piece_evasions(pos, mlist, us, target, pinned); - mlist = generate_piece_evasions(pos, mlist, us, target, pinned); + mlist = generate_piece_moves(pos, mlist, us, target); + mlist = generate_piece_moves(pos, mlist, us, target); + mlist = generate_piece_moves(pos, mlist, us, target); + mlist = generate_piece_moves(pos, mlist, us, target); // Finally, the special case of en passant captures. An en passant // capture can only be a check evasion if the check is not a discovered @@ -290,17 +285,17 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin if (pos.ep_square() != SQ_NONE && (checkers & pos.pieces(PAWN, them))) { to = pos.ep_square(); - b1 = pos.attacks_from(to, them) & pos.pieces(PAWN, us); + b = pos.attacks_from(to, them) & pos.pieces(PAWN, us); // The checking pawn cannot be a discovered (bishop) check candidate // otherwise we were in check also before last double push move. assert(!bit_is_set(pos.discovered_check_candidates(them), checksq)); - assert(count_1s(b1) == 1 || count_1s(b1) == 2); + assert(count_1s(b) == 1 || count_1s(b) == 2); - b1 &= ~pinned; - while (b1) + b &= ~pinned; + while (b) { - from = pop_1st_bit(&b1); + from = pop_1st_bit(&b); // Move is always legal because checking pawn is not a discovered // check candidate and our capturing pawn has been already tested // against pinned pieces. @@ -319,14 +314,16 @@ MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLega assert(pos.is_ok()); + MoveStack* last; Bitboard pinned = pos.pinned_pieces(pos.side_to_move()); - if (pos.is_check()) - return generate_evasions(pos, mlist, pinned); - // Generate pseudo-legal moves - MoveStack* last = generate_captures(pos, mlist); - last = generate_noncaptures(pos, last); + if (pos.is_check()) + last = generate_evasions(pos, mlist, pinned); + else { + last = generate_captures(pos, mlist); + last = generate_noncaptures(pos, last); + } if (pseudoLegal) return last; diff --git a/src/movepick.cpp b/src/movepick.cpp index fdf4b8d1..a2ea3a73 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -318,11 +318,16 @@ Move MovePicker::get_next_move() { return move; break; - case PH_EVASIONS: case PH_BAD_CAPTURES: move = pick_best(curMove++, lastMove).move; return move; + case PH_EVASIONS: + move = pick_best(curMove++, lastMove).move; + if (pos.pl_move_is_legal(move, pinned)) + return move; + break; + case PH_QCAPTURES: move = pick_best(curMove++, lastMove).move; if ( move != ttMoves[0].move diff --git a/src/position.cpp b/src/position.cpp index 4a0075cb..be4e234d 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -470,7 +470,6 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { assert(is_ok()); assert(move_is_ok(m)); assert(pinned == pinned_pieces(side_to_move())); - assert(!is_check()); // Castling moves are checked for legality during move generation. if (move_is_castle(m)) @@ -482,7 +481,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { assert(color_of_piece_on(from) == us); assert(piece_on(king_square(us)) == piece_of_color_and_type(us, KING)); - // En passant captures are a tricky special case. Because they are + // En passant captures are a tricky special case. Because they are // rather uncommon, we do it simply by testing whether the king is attacked // after the move is made if (move_is_ep(m)) @@ -1706,8 +1705,7 @@ bool Position::is_draw() const { bool Position::is_mate() const { MoveStack moves[256]; - - return is_check() && (generate_evasions(*this, moves, pinned_pieces(sideToMove)) == moves); + return is_check() && (generate_moves(*this, moves, false) == moves); }