X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovegen.cpp;h=0686bf8d93aad1922859d93b19ea3ac0873be695;hp=cc635b84e37160a59cf004fff974d18124397869;hb=6dddcecb09df268d93810a1a38deb116f97672af;hpb=01a191936eeb3dc3366554b1423c53da2a1ae56a

diff --git a/src/movegen.cpp b/src/movegen.cpp
index cc635b84..88c31cfa 100644
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -1,7 +1,6 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -19,522 +18,347 @@
 
 #include <cassert>
 
-#include "bitcount.h"
 #include "movegen.h"
-
-// Simple macro to wrap a very common while loop, no facny, no flexibility,
-// hardcoded list name 'mlist' and from square 'from'.
-#define SERIALIZE_MOVES(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
-
-// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
-#define SERIALIZE_MOVES_D(b, d) while (b) { to = pop_1st_bit(&b); (*mlist++).move = make_move(to + (d), to); }
+#include "position.h"
 
 namespace {
 
-  enum CastlingSide {
-    KING_SIDE,
-    QUEEN_SIDE
-  };
-
-  template<CastlingSide>
-  MoveStack* generate_castle_moves(const Position&, MoveStack*, Color us);
-
-  template<Color, MoveType>
-  MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard, Square);
-
-  template<PieceType Pt>
-  inline MoveStack* generate_discovered_checks(const Position& pos, MoveStack* mlist, Square from) {
+  template<GenType Type, Direction D>
+  ExtMove* make_promotions(ExtMove* moveList, Square to, Square ksq) {
 
-    assert(Pt != QUEEN);
-
-    Bitboard b = pos.attacks_from<Pt>(from) & pos.empty_squares();
-    if (Pt == KING)
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
     {
-        Square ksq = pos.king_square(opposite_color(pos.side_to_move()));
-        b &= ~QueenPseudoAttacks[ksq];
+        *moveList++ = make<PROMOTION>(to - D, to, QUEEN);
+        if (attacks_bb<KNIGHT>(to) & ksq)
+            *moveList++ = make<PROMOTION>(to - D, to, KNIGHT);
     }
-    SERIALIZE_MOVES(b);
-    return mlist;
-  }
-
-  template<PieceType Pt>
-  inline MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
-                                           Bitboard dc, Square ksq) {
-    assert(Pt != KING);
-
-    Bitboard checkSqs, b;
-    Square from;
-    const Square* ptr = pos.piece_list_begin(us, Pt);
 
-    if ((from = *ptr++) == SQ_NONE)
-        return mlist;
-
-    checkSqs = pos.attacks_from<Pt>(ksq) & pos.empty_squares();
-
-    do
+    if (Type == QUIETS || Type == EVASIONS || Type == NON_EVASIONS)
     {
-        if (   (Pt == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
-            || (Pt == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
-            || (Pt == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
-            continue;
-
-        if (dc && bit_is_set(dc, from))
-            continue;
-
-        b = pos.attacks_from<Pt>(from) & checkSqs;
-        SERIALIZE_MOVES(b);
-
-    } while ((from = *ptr++) != SQ_NONE);
+        *moveList++ = make<PROMOTION>(to - D, to, ROOK);
+        *moveList++ = make<PROMOTION>(to - D, to, BISHOP);
+        if (!(attacks_bb<KNIGHT>(to) & ksq))
+            *moveList++ = make<PROMOTION>(to - D, to, KNIGHT);
+    }
 
-    return mlist;
+    return moveList;
   }
 
-  template<>
-  FORCE_INLINE MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
-
-    return (us == WHITE ? generate_pawn_moves<WHITE, MV_CHECK>(p, m, dc, ksq)
-                        : generate_pawn_moves<BLACK, MV_CHECK>(p, m, dc, ksq));
-  }
 
-  template<PieceType Pt, MoveType Type>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
+  template<Color Us, GenType Type>
+  ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) {
 
-    assert(Pt == PAWN);
-    assert(Type == MV_CAPTURE || Type == MV_NON_CAPTURE || Type == MV_EVASION);
+    constexpr Color     Them     = ~Us;
+    constexpr Bitboard  TRank7BB = (Us == WHITE ? Rank7BB    : Rank2BB);
+    constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB    : Rank6BB);
+    constexpr Direction Up       = pawn_push(Us);
+    constexpr Direction UpRight  = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
+    constexpr Direction UpLeft   = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
 
-    return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
-                        : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE));
-  }
+    const Square ksq = pos.square<KING>(Them);
+    Bitboard emptySquares;
 
-  template<PieceType Pt>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
+    Bitboard pawnsOn7    = pos.pieces(Us, PAWN) &  TRank7BB;
+    Bitboard pawnsNotOn7 = pos.pieces(Us, PAWN) & ~TRank7BB;
 
-    Bitboard b;
-    Square from;
-    const Square* ptr = pos.piece_list_begin(us, Pt);
+    Bitboard enemies = (Type == EVASIONS ? pos.pieces(Them) & target:
+                        Type == CAPTURES ? target : pos.pieces(Them));
 
-    if (*ptr != SQ_NONE)
+    // Single and double pawn pushes, no promotions
+    if (Type != CAPTURES)
     {
-        do {
-            from = *ptr;
-            b = pos.attacks_from<Pt>(from) & target;
-            SERIALIZE_MOVES(b);
-        } while (*++ptr != SQ_NONE);
-    }
-    return mlist;
-  }
-
-  template<>
-  FORCE_INLINE MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
+        emptySquares = (Type == QUIETS || Type == QUIET_CHECKS ? target : ~pos.pieces());
 
-    Bitboard b;
-    Square from = pos.king_square(us);
+        Bitboard b1 = shift<Up>(pawnsNotOn7)   & emptySquares;
+        Bitboard b2 = shift<Up>(b1 & TRank3BB) & emptySquares;
 
-    b = pos.attacks_from<KING>(from) & target;
-    SERIALIZE_MOVES(b);
-    return mlist;
-  }
+        if (Type == EVASIONS) // Consider only blocking squares
+        {
+            b1 &= target;
+            b2 &= target;
+        }
 
-}
+        if (Type == QUIET_CHECKS)
+        {
+            b1 &= pawn_attacks_bb(Them, ksq);
+            b2 &= pawn_attacks_bb(Them, ksq);
 
+            // Add pawn pushes which give 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. Note that a possible discovered check
+            // promotion has been already generated amongst the captures.
+            Bitboard dcCandidateQuiets = pos.blockers_for_king(Them) & pawnsNotOn7;
+            if (dcCandidateQuiets)
+            {
+                Bitboard dc1 = shift<Up>(dcCandidateQuiets) & emptySquares & ~file_bb(ksq);
+                Bitboard dc2 = shift<Up>(dc1 & TRank3BB) & emptySquares;
 
-/// generate<MV_CAPTURE> generates all pseudo-legal captures and queen
-/// promotions. Returns a pointer to the end of the move list.
-///
-/// generate<MV_NON_CAPTURE> generates all pseudo-legal non-captures and
-/// underpromotions. Returns a pointer to the end of the move list.
-///
-/// generate<MV_NON_EVASION> generates all pseudo-legal captures and
-/// non-captures. Returns a pointer to the end of the move list.
+                b1 |= dc1;
+                b2 |= dc2;
+            }
+        }
 
-template<MoveType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
+        while (b1)
+        {
+            Square to = pop_lsb(&b1);
+            *moveList++ = make_move(to - Up, to);
+        }
 
-  assert(pos.is_ok());
-  assert(!pos.in_check());
+        while (b2)
+        {
+            Square to = pop_lsb(&b2);
+            *moveList++ = make_move(to - Up - Up, to);
+        }
+    }
 
-  Color us = pos.side_to_move();
-  Bitboard target;
+    // Promotions and underpromotions
+    if (pawnsOn7)
+    {
+        if (Type == CAPTURES)
+            emptySquares = ~pos.pieces();
 
-  if (Type == MV_CAPTURE || Type == MV_NON_EVASION)
-      target = pos.pieces_of_color(opposite_color(us));
-  else if (Type == MV_NON_CAPTURE)
-      target = pos.empty_squares();
-  else
-      assert(false);
+        if (Type == EVASIONS)
+            emptySquares &= target;
 
-  if (Type == MV_NON_EVASION)
-  {
-      mlist = generate_piece_moves<PAWN, MV_CAPTURE>(pos, mlist, us, target);
-      mlist = generate_piece_moves<PAWN, MV_NON_CAPTURE>(pos, mlist, us, pos.empty_squares());
-      target |= pos.empty_squares();
-  }
-  else
-      mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
+        Bitboard b1 = shift<UpRight>(pawnsOn7) & enemies;
+        Bitboard b2 = shift<UpLeft >(pawnsOn7) & enemies;
+        Bitboard b3 = shift<Up     >(pawnsOn7) & emptySquares;
 
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KING>(pos, mlist, us, target);
+        while (b1)
+            moveList = make_promotions<Type, UpRight>(moveList, pop_lsb(&b1), ksq);
 
-  if (Type != MV_CAPTURE && pos.can_castle(us))
-  {
-      if (pos.can_castle(us == WHITE ? WHITE_OO : BLACK_OO))
-          mlist = generate_castle_moves<KING_SIDE>(pos, mlist, us);
+        while (b2)
+            moveList = make_promotions<Type, UpLeft >(moveList, pop_lsb(&b2), ksq);
 
-      if (pos.can_castle(us == WHITE ? WHITE_OOO : BLACK_OOO))
-          mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist, us);
-  }
+        while (b3)
+            moveList = make_promotions<Type, Up     >(moveList, pop_lsb(&b3), ksq);
+    }
 
-  return mlist;
-}
+    // Standard and en passant captures
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+    {
+        Bitboard b1 = shift<UpRight>(pawnsNotOn7) & enemies;
+        Bitboard b2 = shift<UpLeft >(pawnsNotOn7) & enemies;
 
-// Explicit template instantiations
-template MoveStack* generate<MV_CAPTURE>(const Position& pos, MoveStack* mlist);
-template MoveStack* generate<MV_NON_CAPTURE>(const Position& pos, MoveStack* mlist);
-template MoveStack* generate<MV_NON_EVASION>(const Position& pos, MoveStack* mlist);
+        while (b1)
+        {
+            Square to = pop_lsb(&b1);
+            *moveList++ = make_move(to - UpRight, to);
+        }
 
+        while (b2)
+        {
+            Square to = pop_lsb(&b2);
+            *moveList++ = make_move(to - UpLeft, to);
+        }
 
-/// generate_non_capture_checks() generates all pseudo-legal non-captures and knight
-/// underpromotions that give check. Returns a pointer to the end of the move list.
-template<>
-MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist) {
+        if (pos.ep_square() != SQ_NONE)
+        {
+            assert(rank_of(pos.ep_square()) == relative_rank(Us, RANK_6));
 
-  assert(pos.is_ok());
-  assert(!pos.in_check());
+            // An en passant capture cannot resolve a discovered check.
+            if (Type == EVASIONS && (target & (pos.ep_square() + Up)))
+                return moveList;
 
-  Bitboard b, dc;
-  Square from;
-  Color us = pos.side_to_move();
-  Square ksq = pos.king_square(opposite_color(us));
+            b1 = pawnsNotOn7 & pawn_attacks_bb(Them, pos.ep_square());
 
-  assert(pos.piece_on(ksq) == make_piece(opposite_color(us), KING));
+            assert(b1);
 
-  // Discovered non-capture checks
-  b = dc = pos.discovered_check_candidates(us);
+            while (b1)
+                *moveList++ = make<EN_PASSANT>(pop_lsb(&b1), pos.ep_square());
+        }
+    }
 
-  while (b)
-  {
-     from = pop_1st_bit(&b);
-     switch (piece_type(pos.piece_on(from)))
-     {
-      case PAWN:   /* Will be generated togheter with pawns direct checks */     break;
-      case KNIGHT: mlist = generate_discovered_checks<KNIGHT>(pos, mlist, from); break;
-      case BISHOP: mlist = generate_discovered_checks<BISHOP>(pos, mlist, from); break;
-      case ROOK:   mlist = generate_discovered_checks<ROOK>(pos, mlist, from);   break;
-      case KING:   mlist = generate_discovered_checks<KING>(pos, mlist, from);   break;
-      default: assert(false); break;
-     }
+    return moveList;
   }
 
-  // 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);
-}
-
 
-/// 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.
-template<>
-MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
-
-  assert(pos.is_ok());
-  assert(pos.in_check());
-
-  Bitboard b, target;
-  Square from, checksq;
-  int checkersCnt = 0;
-  Color us = pos.side_to_move();
-  Square ksq = pos.king_square(us);
-  Bitboard checkers = pos.checkers();
-  Bitboard sliderAttacks = EmptyBoardBB;
-
-  assert(pos.piece_on(ksq) == make_piece(us, KING));
-  assert(checkers);
-
-  // Find squares attacked by slider checkers, we will remove
-  // them from the king evasions set so to early skip known
-  // illegal moves and avoid an useless legality check later.
-  b = checkers;
-  do
-  {
-      checkersCnt++;
-      checksq = pop_1st_bit(&b);
-
-      assert(piece_color(pos.piece_on(checksq)) == opposite_color(us));
-
-      switch (piece_type(pos.piece_on(checksq)))
-      {
-      case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
-      case ROOK:   sliderAttacks |= RookPseudoAttacks[checksq];   break;
-      case QUEEN:
-          // If queen and king are far we can safely remove all the squares attacked
-          // in the other direction becuase are not reachable by the king anyway.
-          if (squares_between(ksq, checksq) || (RookPseudoAttacks[checksq] & (1ULL << ksq)))
-              sliderAttacks |= QueenPseudoAttacks[checksq];
-
-          // Otherwise, if king and queen are adjacent and on a diagonal line, we need to
-          // use real rook attacks to check if king is safe to move in the other direction.
-          // For example: king in B2, queen in A1 a knight in B1, and we can safely move to C1.
-          else
-              sliderAttacks |= BishopPseudoAttacks[checksq] | pos.attacks_from<ROOK>(checksq);
-
-      default:
-          break;
-      }
-  } while (b);
+  template<PieceType Pt, bool Checks>
+  ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Bitboard piecesToMove, Bitboard target) {
 
-  // Generate evasions for king, capture and non capture moves
-  b = pos.attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks;
-  from = ksq;
-  SERIALIZE_MOVES(b);
-
-  // Generate evasions for other pieces only if not double check
-  if (checkersCnt > 1)
-      return mlist;
-
-  // Find squares where a blocking evasion or a capture of the
-  // checker piece is possible.
-  target = squares_between(checksq, ksq) | checkers;
-
-  mlist = generate_piece_moves<PAWN, MV_EVASION>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  return  generate_piece_moves<QUEEN>(pos, mlist, us, target);
-}
+    static_assert(Pt != KING && Pt != PAWN, "Unsupported piece type in generate_moves()");
 
+    Bitboard bb = piecesToMove & pos.pieces(Pt);
 
-/// generate<MV_LEGAL> computes a complete list of legal moves in the current position
+    if (!bb)
+        return moveList;
 
-template<>
-MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
+    [[maybe_unused]] const Bitboard checkSquares = pos.check_squares(Pt);
 
-  assert(pos.is_ok());
+    while (bb) {
+        Square from = pop_lsb(&bb);
 
-  MoveStack *last, *cur = mlist;
-  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+        Bitboard b = attacks_bb<Pt>(from, pos.pieces()) & target;
+        if constexpr (Checks)
+            b &= checkSquares;
 
-  last = pos.in_check() ? generate<MV_EVASION>(pos, mlist)
-                        : generate<MV_NON_EVASION>(pos, mlist);
+        while (b)
+            *moveList++ = make_move(from, pop_lsb(&b));
+    }
 
-  // Remove illegal moves from the list
-  while (cur != last)
-      if (!pos.pl_move_is_legal(cur->move, pinned))
-          cur->move = (--last)->move;
-      else
-          cur++;
+    return moveList;
+  }
 
-  return last;
-}
 
+  template<Color Us, GenType Type>
+  ExtMove* generate_all(const Position& pos, ExtMove* moveList) {
 
-namespace {
+    static_assert(Type != LEGAL, "Unsupported type in generate_all()");
 
-  template<Square Delta>
-  inline Bitboard move_pawns(Bitboard p) {
+    constexpr bool Checks = Type == QUIET_CHECKS; // Reduce template instantations
+    Bitboard target, piecesToMove = pos.pieces(Us);
 
-    return Delta == DELTA_N  ? p << 8 : Delta == DELTA_S  ? p >> 8 :
-           Delta == DELTA_NE ? p << 9 : Delta == DELTA_SE ? p >> 7 :
-           Delta == DELTA_NW ? p << 7 : Delta == DELTA_SW ? p >> 9 : p;
-  }
+    if(Type == QUIET_CHECKS)
+        piecesToMove &= ~pos.blockers_for_king(~Us);
 
-  template<MoveType Type, Square Delta>
-  inline MoveStack* generate_pawn_captures(MoveStack* mlist, Bitboard pawns, Bitboard target) {
+    switch (Type)
+    {
+        case CAPTURES:
+            target =  pos.pieces(~Us);
+            break;
+        case QUIETS:
+        case QUIET_CHECKS:
+            target = ~pos.pieces();
+            break;
+        case EVASIONS:
+        {
+            Square checksq = lsb(pos.checkers());
+            target = between_bb(pos.square<KING>(Us), checksq) | checksq;
+            break;
+        }
+        case NON_EVASIONS:
+            target = ~pos.pieces(Us);
+            break;
+    }
 
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
+    moveList = generate_pawn_moves<Us, Type>(pos, moveList, target);
+    moveList = generate_moves<KNIGHT, Checks>(pos, moveList, piecesToMove, target);
+    moveList = generate_moves<BISHOP, Checks>(pos, moveList, piecesToMove, target);
+    moveList = generate_moves<  ROOK, Checks>(pos, moveList, piecesToMove, target);
+    moveList = generate_moves< QUEEN, Checks>(pos, moveList, piecesToMove, target);
 
-    Bitboard b;
-    Square to;
+    if (Type != QUIET_CHECKS && Type != EVASIONS)
+    {
+        Square ksq = pos.square<KING>(Us);
+        Bitboard b = attacks_bb<KING>(ksq) & target;
+        while (b)
+            *moveList++ = make_move(ksq, pop_lsb(&b));
+
+        if ((Type != CAPTURES) && pos.can_castle(Us & ANY_CASTLING))
+            for (CastlingRights cr : { Us & KING_SIDE, Us & QUEEN_SIDE } )
+                if (!pos.castling_impeded(cr) && pos.can_castle(cr))
+                    *moveList++ = make<CASTLING>(ksq, pos.castling_rook_square(cr));
+    }
 
-    // Captures in the a1-h8 (a8-h1 for black) diagonal or in the h1-a8 (h8-a1 for black)
-    b = move_pawns<Delta>(pawns) & target & ~TFileABB;
-    SERIALIZE_MOVES_D(b, -Delta);
-    return mlist;
+    return moveList;
   }
 
-  template<Color Us, MoveType Type, Square Delta>
-  inline MoveStack* generate_promotions(const Position& pos, MoveStack* mlist, Bitboard pawnsOn7, Bitboard target) {
-
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
-
-    Bitboard b;
-    Square to;
-
-    // Promotions and under-promotions, both captures and non-captures
-    b = move_pawns<Delta>(pawnsOn7) & target;
+} // namespace
 
-    if (Delta != DELTA_N && Delta != DELTA_S)
-        b &= ~TFileABB;
 
-    while (b)
-    {
-        to = pop_1st_bit(&b);
+/// <CAPTURES>     Generates all pseudo-legal captures plus queen and checking knight promotions
+/// <QUIETS>       Generates all pseudo-legal non-captures and underpromotions(except checking knight)
+/// <NON_EVASIONS> Generates all pseudo-legal captures and non-captures
+///
+/// Returns a pointer to the end of the move list.
 
-        if (Type == MV_CAPTURE || Type == MV_EVASION)
-            (*mlist++).move = make_promotion_move(to - Delta, to, QUEEN);
+template<GenType Type>
+ExtMove* generate(const Position& pos, ExtMove* moveList) {
 
-        if (Type == MV_NON_CAPTURE || Type == MV_EVASION)
-        {
-            (*mlist++).move = make_promotion_move(to - Delta, to, ROOK);
-            (*mlist++).move = make_promotion_move(to - Delta, to, BISHOP);
-            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
-        }
-
-        // This is the only possible under promotion that can give a check
-        // not already included in the queen-promotion.
-        if (   Type == MV_CHECK
-            && bit_is_set(pos.attacks_from<KNIGHT>(to), pos.king_square(opposite_color(Us))))
-            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
-        else (void)pos; // Silence a warning under MSVC
-    }
-    return mlist;
-  }
+  static_assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS, "Unsupported type in generate()");
+  assert(!pos.checkers());
 
-  template<Color Us, MoveType Type>
-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard target, Square ksq) {
-
-    // Calculate our parametrized parameters at compile time, named
-    // according to the point of view of white side.
-    const Color    Them      = (Us == WHITE ? BLACK    : WHITE);
-    const Bitboard TRank7BB  = (Us == WHITE ? Rank7BB  : Rank2BB);
-    const Bitboard TRank3BB  = (Us == WHITE ? Rank3BB  : Rank6BB);
-    const Square   TDELTA_N  = (Us == WHITE ? DELTA_N  : DELTA_S);
-    const Square   TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE);
-    const Square   TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW);
-
-    Square to;
-    Bitboard b1, b2, dc1, dc2, pawnPushes, emptySquares;
-    Bitboard pawns = pos.pieces(PAWN, Us);
-    Bitboard pawnsOn7 = pawns & TRank7BB;
-    Bitboard enemyPieces = (Type == MV_CAPTURE ? target : pos.pieces_of_color(Them));
-
-    // Pre-calculate pawn pushes before changing emptySquares definition
-    if (Type != MV_CAPTURE)
-    {
-        emptySquares = (Type == MV_NON_CAPTURE ? target : pos.empty_squares());
-        pawnPushes = move_pawns<TDELTA_N>(pawns & ~TRank7BB) & emptySquares;
-    }
+  Color us = pos.side_to_move();
 
-    if (Type == MV_EVASION)
-    {
-        emptySquares &= target; // Only blocking squares
-        enemyPieces  &= target; // Capture only the checker piece
-    }
+  return us == WHITE ? generate_all<WHITE, Type>(pos, moveList)
+                     : generate_all<BLACK, Type>(pos, moveList);
+}
 
-    // Promotions and underpromotions
-    if (pawnsOn7)
-    {
-        if (Type == MV_CAPTURE)
-            emptySquares = pos.empty_squares();
+// Explicit template instantiations
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);
 
-        pawns &= ~TRank7BB;
-        mlist = generate_promotions<Us, Type, TDELTA_NE>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Us, Type, TDELTA_NW>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Us, Type, TDELTA_N >(pos, mlist, pawnsOn7, emptySquares);
-    }
 
-    // Standard captures
-    if (Type == MV_CAPTURE || Type == MV_EVASION)
-    {
-        mlist = generate_pawn_captures<Type, TDELTA_NE>(mlist, pawns, enemyPieces);
-        mlist = generate_pawn_captures<Type, TDELTA_NW>(mlist, pawns, enemyPieces);
-    }
+/// generate<QUIET_CHECKS> generates all pseudo-legal non-captures.
+/// Returns a pointer to the end of the move list.
+template<>
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* moveList) {
 
-    // Single and double pawn pushes
-    if (Type != MV_CAPTURE)
-    {
-        b1 = (Type != MV_EVASION ? pawnPushes : pawnPushes & emptySquares);
-        b2 = move_pawns<TDELTA_N>(pawnPushes & TRank3BB) & emptySquares;
+  assert(!pos.checkers());
 
-        if (Type == MV_CHECK)
-        {
-            // Consider only pawn moves which give direct checks
-            b1 &= pos.attacks_from<PAWN>(ksq, Them);
-            b2 &= pos.attacks_from<PAWN>(ksq, Them);
+  Color us = pos.side_to_move();
+  Bitboard dc = pos.blockers_for_king(~us) & pos.pieces(us) & ~pos.pieces(PAWN);
 
-            // Add 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.
-            if (pawns & target) // For CHECK type target is dc bitboard
-            {
-                dc1 = move_pawns<TDELTA_N>(pawns & target & ~file_bb(ksq)) & emptySquares;
-                dc2 = move_pawns<TDELTA_N>(dc1 & TRank3BB) & emptySquares;
+  while (dc)
+  {
+     Square from = pop_lsb(&dc);
+     PieceType pt = type_of(pos.piece_on(from));
 
-                b1 |= dc1;
-                b2 |= dc2;
-            }
-        }
-        SERIALIZE_MOVES_D(b1, -TDELTA_N);
-        SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N);
-    }
+     Bitboard b = attacks_bb(pt, from, pos.pieces()) & ~pos.pieces();
 
-    // En passant captures
-    if ((Type == MV_CAPTURE || Type == MV_EVASION) && 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);
+     if (pt == KING)
+         b &= ~attacks_bb<QUEEN>(pos.square<KING>(~us));
 
-        // An en passant capture can be an evasion only if the checking piece
-        // is the double pushed pawn and so is in the target. Otherwise this
-        // is a discovery check and we are forced to do otherwise.
-        if (Type == MV_EVASION && !bit_is_set(target, pos.ep_square() - TDELTA_N))
-            return mlist;
+     while (b)
+         *moveList++ = make_move(from, pop_lsb(&b));
+  }
 
-        b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
+  return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, moveList)
+                     : generate_all<BLACK, QUIET_CHECKS>(pos, moveList);
+}
 
-        assert(b1 != EmptyBoardBB);
 
-        while (b1)
-        {
-            to = pop_1st_bit(&b1);
-            (*mlist++).move = make_ep_move(to, pos.ep_square());
-        }
-    }
-    return mlist;
-  }
+/// 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.
+template<>
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* moveList) {
 
-  template<CastlingSide Side>
-  MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist, Color us) {
+  assert(pos.checkers());
 
-    Color them = opposite_color(us);
-    Square ksq = pos.king_square(us);
-    CastleRight f = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us);
+  Color us = pos.side_to_move();
+  Square ksq = pos.square<KING>(us);
+  Bitboard sliderAttacks = 0;
+  Bitboard sliders = pos.checkers() & ~pos.pieces(KNIGHT, PAWN);
 
-    assert(pos.piece_on(ksq) == make_piece(us, KING));
+  // Find all the squares attacked by slider checkers. We will remove them from
+  // the king evasions in order to skip known illegal moves, which avoids any
+  // useless legality checks later on.
+  while (sliders)
+      sliderAttacks |= line_bb(ksq, pop_lsb(&sliders)) & ~pos.checkers();
 
-    Square rsq = pos.castle_rook_square(f);
-    Square s1 = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
-    Square s2 = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
-    Square s;
-    bool illegal = false;
+  // Generate evasions for king, capture and non capture moves
+  Bitboard b = attacks_bb<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
+  while (b)
+      *moveList++ = make_move(ksq, pop_lsb(&b));
 
-    assert(pos.piece_on(rsq) == make_piece(us, ROOK));
+  if (more_than_one(pos.checkers()))
+      return moveList; // Double check, only a king move can save the day
 
-    // It is a bit complicated to correctly handle Chess960
-    for (s = Min(ksq, s1); s <= Max(ksq, s1); s++)
-        if (  (s != ksq && s != rsq && !pos.square_is_empty(s))
-            ||(pos.attackers_to(s) & pos.pieces_of_color(them)))
-            illegal = true;
+  // Generate blocking evasions or captures of the checking piece
+  return us == WHITE ? generate_all<WHITE, EVASIONS>(pos, moveList)
+                     : generate_all<BLACK, EVASIONS>(pos, moveList);
+}
 
-    for (s = Min(rsq, s2); s <= Max(rsq, s2); s++)
-        if (s != ksq && s != rsq && !pos.square_is_empty(s))
-            illegal = true;
 
-    if (   Side == QUEEN_SIDE
-        && square_file(rsq) == FILE_B
-        && (   pos.piece_on(relative_square(us, SQ_A1)) == make_piece(them, ROOK)
-            || pos.piece_on(relative_square(us, SQ_A1)) == make_piece(them, QUEEN)))
-        illegal = true;
+/// generate<LEGAL> generates all the legal moves in the given position
 
-    if (!illegal)
-        (*mlist++).move = make_castle_move(ksq, rsq);
+template<>
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* moveList) {
 
-    return mlist;
-  }
+  Color us = pos.side_to_move();
+  Bitboard pinned = pos.blockers_for_king(us) & pos.pieces(us);
+  Square ksq = pos.square<KING>(us);
+  ExtMove* cur = moveList;
+
+  moveList = pos.checkers() ? generate<EVASIONS    >(pos, moveList)
+                            : generate<NON_EVASIONS>(pos, moveList);
+  while (cur != moveList)
+      if (   (pinned || from_sq(*cur) == ksq || type_of(*cur) == EN_PASSANT)
+          && !pos.legal(*cur))
+          *cur = (--moveList)->move;
+      else
+          ++cur;
 
-} // namespace
+  return moveList;
+}