X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovegen.cpp;h=f83dded7c4bea3d5d15429ba45f08b18fa597bdc;hb=d9b920acfbc5c8fdc362111d00c962ad654595e6;hp=e9e412749b51ec8493159b37a26d34d6337c0cc1;hpb=21850536d54c3f142f1907e31ac0bfab8f4a8862;p=stockfish diff --git a/src/movegen.cpp b/src/movegen.cpp index e9e41274..f83dded7 100644 --- a/src/movegen.cpp +++ b/src/movegen.cpp @@ -47,7 +47,9 @@ namespace { enum MoveType { CAPTURE, - NON_CAPTURE + NON_CAPTURE, + CHECK, + EVASION }; // Functions @@ -57,71 +59,48 @@ namespace { template MoveStack* generate_castle_moves(const Position&, MoveStack*); - template - MoveStack* generate_pawn_blocking_evasions(const Position&, Bitboard, Bitboard, MoveStack*); + template + MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard = EmptyBoardBB, + Square = SQ_NONE, Bitboard = EmptyBoardBB); - template - MoveStack* generate_pawn_captures(const Position&, MoveStack*); + // Template generate_piece_moves (captures and non-captures) with specializations and overloads + template + MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard); - template - MoveStack* generate_pawn_captures_diagonal(MoveStack*, Bitboard, Bitboard, bool); + template<> + MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard); - template - MoveStack* generate_pawn_noncaptures(const Position&, MoveStack*, Bitboard = EmptyBoardBB, Square = SQ_NONE); + template + inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) { - template - inline Bitboard move_pawns(Bitboard p) { + assert(Piece == PAWN); + assert(Type == CAPTURE || Type == NON_CAPTURE); - 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; + return (us == WHITE ? generate_pawn_moves(p, m) + : generate_pawn_moves(p, m)); } - // Template generate_piece_checks() with specializations + // 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)); + return (us == WHITE ? generate_pawn_moves(p, m, dc, ksq) + : generate_pawn_moves(p, m, dc, ksq)); } - // Template generate_piece_moves() with specializations and overloads + // Template generate_piece_evasions with specializations template - MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard); + MoveStack* generate_piece_evasions(const Position&, MoveStack*, Color, Bitboard, Bitboard); template<> - MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard); - - template - inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) { - - assert(Piece == PAWN); + inline MoveStack* generate_piece_evasions(const Position& p, MoveStack* m, + Color us, Bitboard t, Bitboard pnd) { - 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)); - } - - template - MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard, Bitboard); - - template<> - inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, - Color us, Bitboard t, Bitboard pnd) { - - return (us == WHITE ? generate_pawn_blocking_evasions(p, pnd, t, m) - : generate_pawn_blocking_evasions(p, pnd, t, m)); + 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,127 +560,122 @@ namespace { return mlist; } - template - MoveStack* generate_pawn_captures(const Position& pos, MoveStack* mlist) { + template + 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); const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB); const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB); + const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB); + const SquareDelta TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE); + const SquareDelta TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW); const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S); + Bitboard b1, b2, dcPawns1, dcPawns2; Square to; - Bitboard pawns = pos.pieces(PAWN, Us); - Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us)); - bool possiblePromotion = (pawns & TRank7BB); + Bitboard pawns = (Type == EVASION ? pos.pieces(PAWN, Us) & ~dcp : pos.pieces(PAWN, 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); + 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); + } - // Non-capturing promotions if (possiblePromotion) { - Bitboard b1 = move_pawns(pawns) & pos.empty_squares() & TRank8BB; - while (b1) + // 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 && Type != CAPTURE) { - to = pop_1st_bit(&b1); - (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN); + Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us)); + + // Underpromotion captures in the a1-h8 (a8-h1 for black) direction + b1 = move_pawns(pp) & ~FileABB & enemyPieces & TRank8BB; + while (b1) + { + to = pop_1st_bit(&b1); + (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, ROOK); + (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, BISHOP); + (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, KNIGHT); + } + + // Underpromotion captures in the h1-a8 (h8-a1 for black) direction + b1 = move_pawns(pp) & ~FileHBB & enemyPieces & TRank8BB; + while (b1) + { + to = pop_1st_bit(&b1); + (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, ROOK); + (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, BISHOP); + (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, KNIGHT); + } } - } - // 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); + // Underpromotion pawn pushes. Also queen promotions for evasions and captures. + b1 = move_pawns(pp) & TRank8BB; + b1 &= (Type == EVASION ? blockSquares : pos.empty_squares()); while (b1) { to = pop_1st_bit(&b1); - (*mlist++).move = make_ep_move(to, pos.ep_square()); + if (Type == EVASION || Type == CAPTURE) + (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN); + + 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); + } } } - return mlist; - } - - template - MoveStack* generate_pawn_noncaptures(const Position& pos, MoveStack* mlist, Bitboard dc, Square ksq) { - - // 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 Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB); - const SquareDelta TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE); - const SquareDelta TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW); - const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S); - - Bitboard b1, b2, dcPawns1, dcPawns2; - Square to; - Bitboard pawns = pos.pieces(PAWN, Us); - Bitboard emptySquares = pos.empty_squares(); - if (pawns & TRank7BB) // There is some promotion candidate ? + if (Type != CAPTURE) { - // When generating checks consider under-promotion moves (both captures - // and non captures) only if can give a discovery check. - Bitboard pp = GenerateChecks ? pawns & dc : pawns; - Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us)); - - // Underpromotion captures in the a1-h8 (a8-h1 for black) direction - b1 = move_pawns(pp) & ~FileABB & enemyPieces & TRank8BB; - while (b1) + Bitboard emptySquares = pos.empty_squares(); + dcPawns1 = dcPawns2 = EmptyBoardBB; + if (Type == CHECK && (pawns & dcp)) { - to = pop_1st_bit(&b1); - (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, ROOK); - (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, BISHOP); - (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, KNIGHT); + // 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; } - // Underpromotion captures in the h1-a8 (h8-a1 for black) direction - b1 = move_pawns(pp) & ~FileHBB & enemyPieces & TRank8BB; - while (b1) - { - to = pop_1st_bit(&b1); - (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, ROOK); - (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, BISHOP); - (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, KNIGHT); - } + // 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); + + b1 = pawns & pos.attacks_from(pos.ep_square(), Them); + assert(b1 != EmptyBoardBB); - // Underpromotion pawn pushes - b1 = move_pawns(pp) & emptySquares & TRank8BB; while (b1) { to = pop_1st_bit(&b1); - (*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); + (*mlist++).move = make_ep_move(to, pos.ep_square()); } } - - dcPawns1 = dcPawns2 = EmptyBoardBB; - if (GenerateChecks && (pawns & dc)) - { - // 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 & dc & ~file_bb(ksq)) & emptySquares & ~TRank8BB; - dcPawns2 = move_pawns(dcPawns1 & TRank3BB) & emptySquares; - } - - // Single pawn pushes - b1 = move_pawns(pawns) & emptySquares & ~TRank8BB; - b2 = GenerateChecks ? (b1 & pos.attacks_from(ksq, Them)) | dcPawns1 : b1; - SERIALIZE_MOVES_D(b2, -TDELTA_N); - - // Double pawn pushes - b1 = move_pawns(b1 & TRank3BB) & emptySquares; - b2 = GenerateChecks ? (b1 & pos.attacks_from(ksq, Them)) | dcPawns2 : b1; - SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N); return mlist; } @@ -716,60 +703,20 @@ 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) - { - 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; - } - - template - MoveStack* generate_pawn_blocking_evasions(const Position& pos, Bitboard pinned, - Bitboard blockSquares, MoveStack* mlist) { - - // Calculate our parametrized parameters at compile time - const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB); - const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB); - const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB); - const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S); - - Bitboard b1, b2; - Square to; - Bitboard pawns = pos.pieces(PAWN, Us) & ~pinned; - Bitboard emptySquares = pos.empty_squares(); - - if (pawns & TRank7BB) // There is some promotion candidate ? + if (Piece != KING && checkSqs) { - // Note that blockSquares are always empty - b1 = move_pawns(pawns) & blockSquares & TRank8BB; - while (b1) + while (b) { - to = pop_1st_bit(&b1); - (*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); + 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); } } - - // Single pawn pushes - b1 = move_pawns(pawns) & emptySquares & ~TRank8BB; - b2 = b1 & blockSquares; - SERIALIZE_MOVES_D(b2, -TDELTA_N); - - // Double pawn pushes. Note that blockSquares are always empty - b1 = move_pawns(b1 & TRank3BB) & blockSquares; - SERIALIZE_MOVES_D(b1, -TDELTA_N -TDELTA_N); return mlist; }