X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovegen.cpp;h=f83dded7c4bea3d5d15429ba45f08b18fa597bdc;hb=eddfd46a1016c544cc0f18600677fe121f3cbbff;hp=a6826981a1cc1796348dc7744c4ad6484cf1d8e6;hpb=4346445be3ec26f74b8d4141d1f7478a240278ca;p=stockfish diff --git a/src/movegen.cpp b/src/movegen.cpp index a6826981..f83dded7 100644 --- a/src/movegen.cpp +++ b/src/movegen.cpp @@ -59,41 +59,11 @@ namespace { template MoveStack* generate_castle_moves(const Position&, MoveStack*); - template - MoveStack* generate_pawn_captures(const Position&, MoveStack*); - - template - MoveStack* generate_pawn_captures_diagonal(MoveStack*, Bitboard, Bitboard, bool); - template - MoveStack* generate_pawn_noncaptures(const Position&, MoveStack*, Bitboard = EmptyBoardBB, - Square = SQ_NONE, Bitboard = EmptyBoardBB); + MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard = EmptyBoardBB, + Square = SQ_NONE, Bitboard = EmptyBoardBB); - template - inline Bitboard move_pawns(Bitboard p) { - - if (Direction == DELTA_N) - return Us == WHITE ? p << 8 : p >> 8; - else if (Direction == DELTA_NE) - return Us == WHITE ? p << 9 : p >> 7; - else if (Direction == DELTA_NW) - return Us == WHITE ? p << 7 : p >> 9; - else - return p; - } - - // Template generate_piece_checks() with specializations - template - MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square); - - template<> - inline MoveStack* generate_piece_checks(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) { - - return (us == WHITE ? generate_pawn_noncaptures(p, m, dc, ksq) - : generate_pawn_noncaptures(p, m, dc, ksq)); - } - - // Template generate_piece_moves() with specializations and overloads + // Template generate_piece_moves (captures and non-captures) with specializations and overloads template MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard); @@ -103,25 +73,34 @@ namespace { template inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) { - assert(Piece == PAWN); + assert(Piece == PAWN); + assert(Type == CAPTURE || Type == NON_CAPTURE); - if (Type == CAPTURE) - return (us == WHITE ? generate_pawn_captures(p, m) - : generate_pawn_captures(p, m)); - else - return (us == WHITE ? generate_pawn_noncaptures(p, m) - : generate_pawn_noncaptures(p, m)); + return (us == WHITE ? generate_pawn_moves(p, m) + : generate_pawn_moves(p, m)); } + // Template generate_piece_checks with specializations template - MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard, Bitboard); + MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square); template<> - inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, - Color us, Bitboard t, Bitboard pnd) { + inline MoveStack* generate_piece_checks(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) { - return (us == WHITE ? generate_pawn_noncaptures(p, m, pnd, SQ_NONE, t) - : generate_pawn_noncaptures(p, m, pnd, SQ_NONE, t)); + return (us == WHITE ? generate_pawn_moves(p, m, dc, ksq) + : generate_pawn_moves(p, m, dc, ksq)); + } + + // Template generate_piece_evasions with specializations + template + MoveStack* generate_piece_evasions(const Position&, MoveStack*, Color, Bitboard, Bitboard); + + template<> + inline MoveStack* generate_piece_evasions(const Position& p, MoveStack* m, + Color us, Bitboard t, Bitboard pnd) { + + return (us == WHITE ? generate_pawn_moves(p, m, pnd, SQ_NONE, t) + : generate_pawn_moves(p, m, pnd, SQ_NONE, t)); } } @@ -307,11 +286,11 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin if (blockSquares) { - mlist = generate_piece_moves(pos, mlist, us, blockSquares, pinned); - mlist = generate_piece_moves(pos, mlist, us, blockSquares, pinned); - mlist = generate_piece_moves(pos, mlist, us, blockSquares, pinned); - mlist = generate_piece_moves(pos, mlist, us, blockSquares, pinned); - mlist = generate_piece_moves(pos, mlist, us, blockSquares, pinned); + mlist = generate_piece_evasions(pos, mlist, us, blockSquares, pinned); + mlist = generate_piece_evasions(pos, mlist, us, blockSquares, pinned); + mlist = generate_piece_evasions(pos, mlist, us, blockSquares, pinned); + mlist = generate_piece_evasions(pos, mlist, us, blockSquares, pinned); + mlist = generate_piece_evasions(pos, mlist, us, blockSquares, pinned); } } @@ -497,10 +476,10 @@ namespace { Square from; Bitboard b; + const Square* ptr = pos.piece_list_begin(us, Piece); - for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++) + while ((from = *ptr++) != SQ_NONE) { - from = pos.piece_list(us, Piece, i); b = pos.attacks_from(from) & target; SERIALIZE_MOVES(b); } @@ -519,14 +498,14 @@ namespace { } template - MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, - Color us, Bitboard target, Bitboard pinned) { + MoveStack* generate_piece_evasions(const Position& pos, MoveStack* mlist, + Color us, Bitboard target, Bitboard pinned) { Square from; Bitboard b; + const Square* ptr = pos.piece_list_begin(us, Piece); - for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++) + while ((from = *ptr++) != SQ_NONE) { - from = pos.piece_list(us, Piece, i); if (pinned && bit_is_set(pinned, from)) continue; @@ -536,8 +515,21 @@ namespace { return mlist; } + template + inline Bitboard move_pawns(Bitboard p) { + + if (Direction == DELTA_N) + return Us == WHITE ? p << 8 : p >> 8; + else if (Direction == DELTA_NE) + return Us == WHITE ? p << 9 : p >> 7; + else if (Direction == DELTA_NW) + return Us == WHITE ? p << 7 : p >> 9; + else + return p; + } + template - MoveStack* generate_pawn_captures_diagonal(MoveStack* mlist, Bitboard pawns, Bitboard enemyPieces, bool promotion) { + MoveStack* generate_pawn_diagonal_captures(MoveStack* mlist, Bitboard pawns, Bitboard enemyPieces, bool promotion) { // Calculate our parametrized parameters at compile time const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB); @@ -568,56 +560,9 @@ namespace { return mlist; } - template - MoveStack* generate_pawn_captures(const Position& pos, MoveStack* mlist) { - - // Calculate our parametrized parameters at compile time - const Color Them = (Us == WHITE ? BLACK : WHITE); - const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB); - const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB); - const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S); - - Square to; - Bitboard pawns = pos.pieces(PAWN, Us); - Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us)); - bool possiblePromotion = (pawns & TRank7BB); - - // Standard captures and capturing promotions in both directions - mlist = generate_pawn_captures_diagonal(mlist, pawns, enemyPieces, possiblePromotion); - mlist = generate_pawn_captures_diagonal(mlist, pawns, enemyPieces, possiblePromotion); - - // Non-capturing promotions - if (possiblePromotion) - { - Bitboard b1 = move_pawns(pawns) & pos.empty_squares() & TRank8BB; - while (b1) - { - to = pop_1st_bit(&b1); - (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN); - } - } - - // En passant captures - if (pos.ep_square() != SQ_NONE) - { - assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6); - assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3); - - Bitboard b1 = pawns & pos.attacks_from(pos.ep_square(), Them); - assert(b1 != EmptyBoardBB); - - while (b1) - { - to = pop_1st_bit(&b1); - (*mlist++).move = make_ep_move(to, pos.ep_square()); - } - } - return mlist; - } - template - MoveStack* generate_pawn_noncaptures(const Position& pos, MoveStack* mlist, Bitboard dcp, - Square ksq, Bitboard blockSquares) { + MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard dcp, + Square ksq, Bitboard blockSquares) { // Calculate our parametrized parameters at compile time const Color Them = (Us == WHITE ? BLACK : WHITE); @@ -630,17 +575,25 @@ namespace { Bitboard b1, b2, dcPawns1, dcPawns2; Square to; - Bitboard pawns = (Type != EVASION ? pos.pieces(PAWN, Us) : pos.pieces(PAWN, Us) & ~dcp); - Bitboard emptySquares = pos.empty_squares(); + Bitboard pawns = (Type == EVASION ? pos.pieces(PAWN, Us) & ~dcp : pos.pieces(PAWN, Us)); + bool possiblePromotion = pawns & TRank7BB; - if (pawns & TRank7BB) // There is some promotion candidate ? + if (Type == CAPTURE) + { + // Standard captures and capturing promotions in both directions + Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us)); + mlist = generate_pawn_diagonal_captures(mlist, pawns, enemyPieces, possiblePromotion); + mlist = generate_pawn_diagonal_captures(mlist, pawns, enemyPieces, possiblePromotion); + } + + if (possiblePromotion) { // When generating checks consider under-promotion moves (both captures // and non captures) only if can give a discovery check. Note that dcp // is dc bitboard or pinned bitboard when Type == EVASION. Bitboard pp = (Type == CHECK ? pawns & dcp : pawns); - if (Type != EVASION) + if (Type != EVASION && Type != CAPTURE) { Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us)); @@ -665,43 +618,64 @@ namespace { } } - // Underpromotion pawn pushes + // Underpromotion pawn pushes. Also queen promotions for evasions and captures. b1 = move_pawns(pp) & TRank8BB; - b1 &= (Type == EVASION ? blockSquares : emptySquares); + b1 &= (Type == EVASION ? blockSquares : pos.empty_squares()); while (b1) { to = pop_1st_bit(&b1); - if (Type == EVASION) + if (Type == EVASION || Type == CAPTURE) (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN); - (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK); - (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP); - (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT); + if (Type != CAPTURE) + { + (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK); + (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP); + (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT); + } } } - dcPawns1 = dcPawns2 = EmptyBoardBB; - if (Type == CHECK && (pawns & dcp)) + if (Type != CAPTURE) { - // Pawn moves which gives discovered check. This is possible only if the - // pawn is not on the same file as the enemy king, because we don't - // generate captures. - dcPawns1 = move_pawns(pawns & dcp & ~file_bb(ksq)) & emptySquares & ~TRank8BB; - dcPawns2 = move_pawns(dcPawns1 & TRank3BB) & emptySquares; + Bitboard emptySquares = pos.empty_squares(); + dcPawns1 = dcPawns2 = EmptyBoardBB; + if (Type == CHECK && (pawns & dcp)) + { + // Pawn moves which gives discovered check. This is possible only if the + // pawn is not on the same file as the enemy king, because we don't + // generate captures. + dcPawns1 = move_pawns(pawns & dcp & ~file_bb(ksq)) & emptySquares & ~TRank8BB; + dcPawns2 = move_pawns(dcPawns1 & TRank3BB) & emptySquares; + } + + // Single pawn pushes + b1 = move_pawns(pawns) & emptySquares & ~TRank8BB; + b2 = (Type == CHECK ? (b1 & pos.attacks_from(ksq, Them)) | dcPawns1 : + (Type == EVASION ? b1 & blockSquares : b1)); + SERIALIZE_MOVES_D(b2, -TDELTA_N); + + // Double pawn pushes + b1 = move_pawns(b1 & TRank3BB) & emptySquares; + b2 = (Type == CHECK ? (b1 & pos.attacks_from(ksq, Them)) | dcPawns2 : + (Type == EVASION ? b1 & blockSquares : b1)); + SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N); } + else if (pos.ep_square() != SQ_NONE) // En passant captures + { + assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6); + assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3); - // Single pawn pushes - b1 = move_pawns(pawns) & emptySquares & ~TRank8BB; - b2 = (Type == CHECK ? (b1 & pos.attacks_from(ksq, Them)) | dcPawns1 : - (Type == EVASION ? b1 & blockSquares : b1)); - SERIALIZE_MOVES_D(b2, -TDELTA_N); - - // Double pawn pushes - b1 = move_pawns(b1 & TRank3BB) & emptySquares; - b2 = (Type == CHECK ? (b1 & pos.attacks_from(ksq, Them)) | dcPawns2 : - (Type == EVASION ? b1 & blockSquares : b1)); - SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N); + b1 = pawns & pos.attacks_from(pos.ep_square(), Them); + assert(b1 != EmptyBoardBB); + + while (b1) + { + to = pop_1st_bit(&b1); + (*mlist++).move = make_ep_move(to, pos.ep_square()); + } + } return mlist; } @@ -729,19 +703,19 @@ namespace { // Direct non-capture checks b = target & ~dc; Bitboard checkSqs = pos.attacks_from(ksq) & pos.empty_squares(); - if (Piece == KING || !checkSqs) - return mlist; - - while (b) + if (Piece != KING && checkSqs) { - Square from = pop_1st_bit(&b); - if ( (Piece == QUEEN && !(QueenPseudoAttacks[from] & checkSqs)) - || (Piece == ROOK && !(RookPseudoAttacks[from] & checkSqs)) - || (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs))) - continue; - - Bitboard bb = pos.attacks_from(from) & checkSqs; - SERIALIZE_MOVES(bb); + while (b) + { + Square from = pop_1st_bit(&b); + if ( (Piece == QUEEN && !(QueenPseudoAttacks[from] & checkSqs)) + || (Piece == ROOK && !(RookPseudoAttacks[from] & checkSqs)) + || (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs))) + continue; + + Bitboard bb = pos.attacks_from(from) & checkSqs; + SERIALIZE_MOVES(bb); + } } return mlist; }