X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovegen.cpp;h=00e1adf5caa293bcff46b0b263f55196319d2fb7;hp=c4b43539bc280e9227cf4b772d8e53378dcebc65;hb=23de3e16f153f91601e0a6a19b793c54a1ba35cd;hpb=0179a32cf5b22fdeeaf9a14aa88f49eb51f476ed

diff --git a/src/movegen.cpp b/src/movegen.cpp
index c4b43539..00e1adf5 100644
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -47,81 +47,61 @@ namespace {
 
   enum MoveType {
     CAPTURE,
-    NON_CAPTURE
+    NON_CAPTURE,
+    CHECK,
+    EVASION
   };
 
-  // Functions
-  bool castling_is_check(const Position&, CastlingSide);
-
   // Helper templates
   template<CastlingSide Side>
   MoveStack* generate_castle_moves(const Position&, MoveStack*);
 
-  template<Color Us>
-  MoveStack* generate_pawn_blocking_evasions(const Position&, Bitboard, Bitboard, MoveStack*);
+  template<Color Us, MoveType Type>
+  MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard = EmptyBoardBB,
+                                 Square = SQ_NONE, Bitboard = EmptyBoardBB);
 
-  template<Color Us>
-  MoveStack* generate_pawn_captures(const Position&, MoveStack*);
+  // Template generate_piece_moves (captures and non-captures) with specializations and overloads
+  template<PieceType>
+  MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard);
 
-  template<Color Us, SquareDelta Diagonal>
-  MoveStack* generate_pawn_captures_diagonal(MoveStack*, Bitboard, Bitboard, bool);
+  template<>
+  MoveStack* generate_piece_moves<KING>(const Position&, MoveStack*, Color, Bitboard);
 
-  template<Color Us, bool Checks>
-  MoveStack* generate_pawn_noncaptures(const Position&, MoveStack*, Bitboard = EmptyBoardBB, Square = SQ_NONE);
+  template<PieceType Piece, MoveType Type>
+  inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) {
 
-  template<Color Us, SquareDelta Direction>
-  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<WHITE, Type>(p, m)
+                        : generate_pawn_moves<BLACK, Type>(p, m));
   }
 
-  // Template generate_piece_checks() with specializations
-  template<PieceType>
-  MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square);
-
-  template<>
-  inline MoveStack* generate_piece_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
+  // Templates for non-capture checks generation
 
-    return (us == WHITE ? generate_pawn_noncaptures<WHITE, true>(p, m, dc, ksq)
-                        : generate_pawn_noncaptures<BLACK, true>(p, m, dc, ksq));
-  }
+  template<PieceType Piece>
+  MoveStack* generate_discovered_checks(const Position& pos, Square from, MoveStack* mlist);
 
-  // Template generate_piece_moves() with specializations and overloads
   template<PieceType>
-  MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard);
+  MoveStack* generate_direct_checks(const Position&, MoveStack*, Color, Bitboard, Square);
 
   template<>
-  MoveStack* generate_piece_moves<KING>(const Position&, MoveStack*, Color, Bitboard);
-
-  template<PieceType Piece, MoveType Type>
-  inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) {
-
-      assert(Piece == PAWN);
+  inline MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
 
-      if (Type == CAPTURE)
-          return (us == WHITE ? generate_pawn_captures<WHITE>(p, m)
-                              : generate_pawn_captures<BLACK>(p, m));
-      else
-          return (us == WHITE ? generate_pawn_noncaptures<WHITE, false>(p, m)
-                              : generate_pawn_noncaptures<BLACK, false>(p, m));
+    return (us == WHITE ? generate_pawn_moves<WHITE, CHECK>(p, m, dc, ksq)
+                        : generate_pawn_moves<BLACK, CHECK>(p, m, dc, ksq));
   }
 
+  // Template generate_piece_evasions with specializations
   template<PieceType>
-  MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard, Bitboard);
+  MoveStack* generate_piece_evasions(const Position&, MoveStack*, Color, Bitboard, Bitboard);
 
   template<>
-  inline MoveStack* generate_piece_moves<PAWN>(const Position& p, MoveStack* m,
-                                               Color us, Bitboard t, Bitboard pnd) {
+  inline MoveStack* generate_piece_evasions<PAWN>(const Position& p, MoveStack* m,
+                                                  Color us, Bitboard t, Bitboard pnd) {
 
-    return (us == WHITE ? generate_pawn_blocking_evasions<WHITE>(p, pnd, t, m)
-                        : generate_pawn_blocking_evasions<BLACK>(p, pnd, t, m));
+    return (us == WHITE ? generate_pawn_moves<WHITE, EVASION>(p, m, pnd, SQ_NONE, t)
+                        : generate_pawn_moves<BLACK, EVASION>(p, m, pnd, SQ_NONE, t));
   }
 }
 
@@ -186,26 +166,28 @@ MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bi
 
   assert(pos.piece_on(ksq) == piece_of_color_and_type(opposite_color(us), KING));
 
-  // Pieces moves
-  mlist = generate_piece_checks<PAWN>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<KNIGHT>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<BISHOP>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<ROOK>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<QUEEN>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<KING>(pos, mlist, us, dc, ksq);
-
-  // Castling moves that give check. Very rare but nice to have!
-  if (   pos.can_castle_queenside(us)
-      && (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_D)
-      && castling_is_check(pos, QUEEN_SIDE))
-      mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist);
-
-  if (   pos.can_castle_kingside(us)
-      && (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_F)
-      && castling_is_check(pos, KING_SIDE))
-      mlist = generate_castle_moves<KING_SIDE>(pos, mlist);
+  // Discovered non-capture checks
+  Bitboard b = dc;
+  while (b)
+  {
+     Square from = pop_1st_bit(&b);
+     switch (pos.type_of_piece_on(from))
+     {
+      case PAWN:   /* Will be generated togheter with pawns direct checks */     break;
+      case KNIGHT: mlist = generate_discovered_checks<KNIGHT>(pos, from, mlist); break;
+      case BISHOP: mlist = generate_discovered_checks<BISHOP>(pos, from, mlist); break;
+      case ROOK:   mlist = generate_discovered_checks<ROOK>(pos, from, mlist);   break;
+      case KING:   mlist = generate_discovered_checks<KING>(pos, from, mlist);   break;
+      default: assert(false); break;
+     }
+  }
 
-  return mlist;
+  // Direct non-capture checks
+  mlist = generate_direct_checks<PAWN>(pos, mlist, us, dc, ksq);
+  mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, dc, ksq);
+  mlist = generate_direct_checks<BISHOP>(pos, mlist, us, dc, ksq);
+  mlist = generate_direct_checks<ROOK>(pos, mlist, us, dc, ksq);
+  return  generate_direct_checks<QUEEN>(pos, mlist, us, dc, ksq);
 }
 
 
@@ -307,11 +289,11 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin
 
           if (blockSquares)
           {
-              mlist = generate_piece_moves<PAWN>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_moves<BISHOP>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_moves<ROOK>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_moves<QUEEN>(pos, mlist, us, blockSquares, pinned);
+              mlist = generate_piece_evasions<PAWN>(pos, mlist, us, blockSquares, pinned);
+              mlist = generate_piece_evasions<KNIGHT>(pos, mlist, us, blockSquares, pinned);
+              mlist = generate_piece_evasions<BISHOP>(pos, mlist, us, blockSquares, pinned);
+              mlist = generate_piece_evasions<ROOK>(pos, mlist, us, blockSquares, pinned);
+              mlist = generate_piece_evasions<QUEEN>(pos, mlist, us, blockSquares, pinned);
           }
       }
 
@@ -436,7 +418,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
           return false;
 
       // Proceed according to the square delta between the origin and
-      // destionation squares.
+      // destination squares.
       switch (direction)
       {
       case DELTA_NW:
@@ -497,25 +479,36 @@ 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<Piece>(from) & target;
         SERIALIZE_MOVES(b);
     }
     return mlist;
   }
 
+  template<>
+  MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
+
+    Bitboard b;
+    Square from = pos.king_square(us);
+
+    b = pos.attacks_from<KING>(from) & target;
+    SERIALIZE_MOVES(b);
+    return mlist;
+  }
+
   template<PieceType Piece>
-  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;
 
@@ -525,19 +518,21 @@ namespace {
     return mlist;
   }
 
-  template<>
-  MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
-    Bitboard b;
-    Square from = pos.king_square(us);
+  template<Color Us, SquareDelta Direction>
+  inline Bitboard move_pawns(Bitboard p) {
 
-    b = pos.attacks_from<KING>(from) & target;
-    SERIALIZE_MOVES(b);
-    return mlist;
+    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<Color Us, SquareDelta Diagonal>
-  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,42 +563,114 @@ namespace {
     return mlist;
   }
 
-  template<Color Us>
-  MoveStack* generate_pawn_captures(const Position& pos, MoveStack* mlist) {
+  template<Color Us, MoveType Type>
+  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<Us, DELTA_NE>(mlist, pawns, enemyPieces, possiblePromotion);
-    mlist = generate_pawn_captures_diagonal<Us, DELTA_NW>(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<Us, DELTA_NE>(mlist, pawns, enemyPieces, possiblePromotion);
+        mlist = generate_pawn_diagonal_captures<Us, DELTA_NW>(mlist, pawns, enemyPieces, possiblePromotion);
+    }
 
-    // Non-capturing promotions
     if (possiblePromotion)
     {
-        Bitboard b1 = move_pawns<Us, DELTA_N>(pawns) & pos.empty_squares() & TRank8BB;
+        // 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)
+        {
+            Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us));
+
+            // Underpromotion captures in the a1-h8 (a8-h1 for black) direction
+            b1 = move_pawns<Us, DELTA_NE>(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<Us, DELTA_NW>(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);
+            }
+        }
+
+        // Underpromotion pawn pushes. Also queen promotions for evasions and captures.
+        b1 = move_pawns<Us, DELTA_N>(pp) & TRank8BB;
+        b1 &= (Type == EVASION ? blockSquares : pos.empty_squares());
+
         while (b1)
         {
             to = pop_1st_bit(&b1);
-            (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN);
+            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);
+            }
         }
     }
 
-    // En passant captures
-    if (pos.ep_square() != SQ_NONE)
+    if (Type != CAPTURE)
+    {
+        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<Us, DELTA_N>(pawns & dcp & ~file_bb(ksq)) & emptySquares & ~TRank8BB;
+            dcPawns2 = move_pawns<Us, DELTA_N>(dcPawns1 & TRank3BB) & emptySquares;
+        }
+
+        // Single pawn pushes
+        b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares & ~TRank8BB;
+        b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns1 :
+             (Type == EVASION ? b1 & blockSquares : b1));
+        SERIALIZE_MOVES_D(b2, -TDELTA_N);
+
+        // Double pawn pushes
+        b1 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
+        b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(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);
 
-        Bitboard b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
+        b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
         assert(b1 != EmptyBoardBB);
 
         while (b1)
@@ -615,167 +682,50 @@ namespace {
     return mlist;
   }
 
-  template<Color Us, bool GenerateChecks>
-  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 ?
-    {
-        // 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<Us, DELTA_NE>(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<Us, DELTA_NW>(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);
-        }
+  template<PieceType Piece>
+  MoveStack* generate_discovered_checks(const Position& pos, Square from, MoveStack* mlist) {
 
-        // Underpromotion pawn pushes
-        b1 = move_pawns<Us, DELTA_N>(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);
-        }
-    }
+    assert(Piece != QUEEN);
 
-    dcPawns1 = dcPawns2 = EmptyBoardBB;
-    if (GenerateChecks && (dc & pawns))
+    Bitboard b = pos.attacks_from<Piece>(from) & pos.empty_squares();
+    if (Piece == KING)
     {
-        // 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<Us, DELTA_N>(pawns & dc & ~file_bb(ksq)) & emptySquares & ~TRank8BB;
-        dcPawns2 = move_pawns<Us, DELTA_N>(dcPawns1 & TRank3BB) & emptySquares;
+        Square ksq = pos.king_square(opposite_color(pos.side_to_move()));
+        b &= ~QueenPseudoAttacks[ksq];
     }
-
-    // Single pawn pushes
-    b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares & ~TRank8BB;
-    b2 = GenerateChecks ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns1 : b1;
-    SERIALIZE_MOVES_D(b2, -TDELTA_N);
-
-    // Double pawn pushes
-    b1 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
-    b2 = GenerateChecks ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns2 : b1;
-    SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N);
+    SERIALIZE_MOVES(b);
     return mlist;
   }
 
   template<PieceType Piece>
-  MoveStack* generate_piece_checks(const Position& pos, MoveStack* mlist, Color us,
+  MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
                                    Bitboard dc, Square ksq) {
+    assert(Piece != KING);
 
-    Bitboard target = pos.pieces(Piece, us);
-
-    // Discovered checks
-    Bitboard b = target & dc;
-    while (b)
-    {
-        Square from = pop_1st_bit(&b);
-        Bitboard bb = pos.attacks_from<Piece>(from) & pos.empty_squares();
-        if (Piece == KING)
-            bb &= ~QueenPseudoAttacks[ksq];
-
-        SERIALIZE_MOVES(bb);
-    }
+    Square from;
+    Bitboard checkSqs;
+    const Square* ptr = pos.piece_list_begin(us, Piece);
 
-    // Direct checks
-    b = target & ~dc;
-    Bitboard checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
-    if (Piece == KING || !checkSqs)
+    if ((from = *ptr++) == SQ_NONE)
         return mlist;
 
-    while (b)
+    checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
+
+    do
     {
-        Square from = pop_1st_bit(&b);
         if (   (Piece == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
             || (Piece == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
             || (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
             continue;
 
+        if (dc && bit_is_set(dc, from))
+            continue;
+
         Bitboard bb = pos.attacks_from<Piece>(from) & checkSqs;
         SERIALIZE_MOVES(bb);
-    }
-    return mlist;
-  }
 
-  template<Color Us>
-  MoveStack* generate_pawn_blocking_evasions(const Position& pos, Bitboard pinned,
-                                             Bitboard blockSquares, MoveStack* mlist) {
-
-    // Calculate our parametrized parameters at compile time
-    const Rank TRANK_8 = (Us == WHITE ? RANK_8 : RANK_1);
-    const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
-    const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S);
+    } while ((from = *ptr++) != SQ_NONE);
 
-    Square to;
-
-    // Find non-pinned pawns and push them one square
-    Bitboard b1 = move_pawns<Us, DELTA_N>(pos.pieces(PAWN, Us) & ~pinned);
-
-    // We don't have to AND with empty squares here,
-    // because the blocking squares will always be empty.
-    Bitboard b2 = b1 & blockSquares;
-    while (b2)
-    {
-        to = pop_1st_bit(&b2);
-
-        assert(pos.piece_on(to) == EMPTY);
-
-        if (square_rank(to) == TRANK_8)
-        {
-            (*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);
-        } else
-            (*mlist++).move = make_move(to - TDELTA_N, to);
-    }
-
-    // Double pawn pushes
-    b2 = b1 & pos.empty_squares() & TRank3BB;
-    b2 = move_pawns<Us, DELTA_N>(b2) & blockSquares;
-    while (b2)
-    {
-        to = pop_1st_bit(&b2);
-
-        assert(pos.piece_on(to) == EMPTY);
-        assert(Us != WHITE || square_rank(to) == RANK_4);
-        assert(Us != BLACK || square_rank(to) == RANK_5);
-
-        (*mlist++).move = make_move(to - TDELTA_N - TDELTA_N, to);
-    }
     return mlist;
   }
 
@@ -821,17 +771,4 @@ namespace {
     }
     return mlist;
   }
-
-  bool castling_is_check(const Position& pos, CastlingSide side) {
-
-    // After castling opponent king is attacked by the castled rook?
-    File rookFile = (side == QUEEN_SIDE ? FILE_D : FILE_F);
-    Color us = pos.side_to_move();
-    Square ksq = pos.king_square(us);
-    Bitboard occ = pos.occupied_squares();
-
-    clear_bit(&occ, ksq); // Remove our king from the board
-    Square rsq = make_square(rookFile, square_rank(ksq));
-    return bit_is_set(rook_attacks_bb(rsq, occ), pos.king_square(opposite_color(us)));
-  }
 }