X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovegen.cpp;h=349d3b71e2c940d54b4657b2019b259212ff4871;hb=12f4bbc8f2b6122d9dc0949f3483e7dd3f26a829;hp=f688bfef67054c138a5d96c72ef3a1478150fb9f;hpb=57c51dd1ef2037801b7b8a97837bec65eb98d827;p=stockfish

diff --git a/src/movegen.cpp b/src/movegen.cpp
index f688bfef..349d3b71 100644
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -52,19 +52,65 @@ namespace {
     EVASION
   };
 
-  // Helper templates
   template<CastlingSide Side>
   MoveStack* generate_castle_moves(const Position&, MoveStack*);
 
   template<Color Us, MoveType Type>
   MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard, Square);
 
-  // Template generate_piece_moves (captures and non-captures) with specializations and overloads
-  template<PieceType>
-  MoveStack* generate_piece_moves(const Position&, MoveStack*, Color, Bitboard);
+  template<PieceType Piece>
+  inline MoveStack* generate_discovered_checks(const Position& pos, MoveStack* mlist, Square from) {
+
+    assert(Piece != QUEEN);
+
+    Bitboard b = pos.attacks_from<Piece>(from) & pos.empty_squares();
+    if (Piece == KING)
+    {
+        Square ksq = pos.king_square(opposite_color(pos.side_to_move()));
+        b &= ~QueenPseudoAttacks[ksq];
+    }
+    SERIALIZE_MOVES(b);
+    return mlist;
+  }
+
+  template<PieceType Piece>
+  inline MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
+                                           Bitboard dc, Square ksq) {
+    assert(Piece != KING);
+
+    Bitboard checkSqs, b;
+    Square from;
+    const Square* ptr = pos.piece_list_begin(us, Piece);
+
+    if ((from = *ptr++) == SQ_NONE)
+        return mlist;
+
+    checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
+
+    do
+    {
+        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;
+
+        b = pos.attacks_from<Piece>(from) & checkSqs;
+        SERIALIZE_MOVES(b);
+
+    } while ((from = *ptr++) != SQ_NONE);
+
+    return mlist;
+  }
 
   template<>
-  MoveStack* generate_piece_moves<KING>(const Position&, MoveStack*, Color, Bitboard);
+  inline MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
+
+    return (us == WHITE ? generate_pawn_moves<WHITE, CHECK>(p, m, dc, ksq)
+                        : generate_pawn_moves<BLACK, CHECK>(p, m, dc, ksq));
+  }
 
   template<PieceType Piece, MoveType Type>
   inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
@@ -76,20 +122,35 @@ namespace {
                         : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE));
   }
 
-  // Templates for non-capture checks generation
-
   template<PieceType Piece>
-  MoveStack* generate_discovered_checks(const Position&, MoveStack*, Square);
+  inline MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 
-  template<PieceType>
-  MoveStack* generate_direct_checks(const Position&, MoveStack*, Color, Bitboard, Square);
+    Bitboard b;
+    Square from;
+    const Square* ptr = pos.piece_list_begin(us, Piece);
+
+    if (*ptr != SQ_NONE)
+    {
+        do {
+            from = *ptr;
+            b = pos.attacks_from<Piece>(from) & target;
+            SERIALIZE_MOVES(b);
+        } while (*++ptr != SQ_NONE);
+    }
+    return mlist;
+  }
 
   template<>
-  inline MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
+  inline MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 
-    return (us == WHITE ? generate_pawn_moves<WHITE, CHECK>(p, m, dc, ksq)
-                        : generate_pawn_moves<BLACK, CHECK>(p, m, dc, ksq));
+    Bitboard b;
+    Square from = pos.king_square(us);
+
+    b = pos.attacks_from<KING>(from) & target;
+    SERIALIZE_MOVES(b);
+    return mlist;
   }
+
 }
 
 
@@ -100,8 +161,8 @@ namespace {
 
 /// generate_captures() generates all pseudo-legal captures and queen
 /// promotions. Returns a pointer to the end of the move list.
-
-MoveStack* generate_captures(const Position& pos, MoveStack* mlist) {
+template<>
+MoveStack* generate<CAPTURES>(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
@@ -120,8 +181,8 @@ MoveStack* generate_captures(const Position& pos, MoveStack* mlist) {
 
 /// generate_noncaptures() generates all pseudo-legal non-captures and
 /// underpromotions. Returns a pointer to the end of the move list.
-
-MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist) {
+template<>
+MoveStack* generate<NON_CAPTURES>(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
@@ -142,8 +203,8 @@ MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist) {
 
 /// generate_non_evasions() generates all pseudo-legal captures and
 /// non-captures. Returns a pointer to the end of the move list.
-
-MoveStack* generate_non_evasions(const Position& pos, MoveStack* mlist) {
+template<>
+MoveStack* generate<NON_EVASIONS>(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
@@ -168,8 +229,8 @@ MoveStack* generate_non_evasions(const Position& pos, MoveStack* mlist) {
 
 /// 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.
-
-MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist) {
+template<>
+MoveStack* generate<NON_CAPTURE_CHECKS>(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
@@ -209,8 +270,8 @@ MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* 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.
-
-MoveStack* generate_evasions(const Position& pos, MoveStack* mlist) {
+template<>
+MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
   assert(pos.is_check());
@@ -286,8 +347,8 @@ MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLega
   Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
 
   // Generate pseudo-legal moves
-  last = pos.is_check() ? generate_evasions(pos, mlist)
-                        : generate_non_evasions(pos, mlist);
+  last = pos.is_check() ? generate<EVASIONS>(pos, mlist)
+                        : generate<NON_EVASIONS>(pos, mlist);
   if (pseudoLegal)
       return last;
 
@@ -325,7 +386,6 @@ bool move_is_legal(const Position& pos, const Move m) {
 bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
   assert(pos.is_ok());
-  assert(move_is_ok(m));
   assert(pinned == pos.pinned_pieces(pos.side_to_move()));
 
   Color us = pos.side_to_move();
@@ -415,35 +475,6 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
 namespace {
 
-  template<PieceType Piece>
-  MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
-    Bitboard b;
-    Square from;
-    const Square* ptr = pos.piece_list_begin(us, Piece);
-
-    if (*ptr != SQ_NONE)
-    {
-        do {
-            from = *ptr;
-            b = pos.attacks_from<Piece>(from) & target;
-            SERIALIZE_MOVES(b);
-        } while (*++ptr != SQ_NONE);
-    }
-    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<SquareDelta Delta>
   inline Bitboard move_pawns(Bitboard p) {
 
@@ -607,53 +638,6 @@ namespace {
     return mlist;
   }
 
-  template<PieceType Piece>
-  MoveStack* generate_discovered_checks(const Position& pos, MoveStack* mlist, Square from) {
-
-    assert(Piece != QUEEN);
-
-    Bitboard b = pos.attacks_from<Piece>(from) & pos.empty_squares();
-    if (Piece == KING)
-    {
-        Square ksq = pos.king_square(opposite_color(pos.side_to_move()));
-        b &= ~QueenPseudoAttacks[ksq];
-    }
-    SERIALIZE_MOVES(b);
-    return mlist;
-  }
-
-  template<PieceType Piece>
-  MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
-                                   Bitboard dc, Square ksq) {
-    assert(Piece != KING);
-
-    Bitboard checkSqs, b;
-    Square from;
-    const Square* ptr = pos.piece_list_begin(us, Piece);
-
-    if ((from = *ptr++) == SQ_NONE)
-        return mlist;
-
-    checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
-
-    do
-    {
-        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;
-
-        b = pos.attacks_from<Piece>(from) & checkSqs;
-        SERIALIZE_MOVES(b);
-
-    } while ((from = *ptr++) != SQ_NONE);
-
-    return mlist;
-  }
-
   template<CastlingSide Side>
   MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist) {