X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovegen.cpp;h=7273ca9ad6ebbf50a1aca42734381446a8e948e5;hp=ecda2c2d4640cd10b620ec5f85230850d089b6ac;hb=8a0dd93c56f63de467190145116ed6c5cfd54bc1;hpb=2f8961beef5fe63aabeb77a8d4f20c59f6470b5e

diff --git a/src/movegen.cpp b/src/movegen.cpp
index ecda2c2d..7273ca9a 100644
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -122,15 +122,16 @@ int generate_captures(const Position& pos, MoveStack* mlist) {
   Bitboard target = pos.pieces_of_color(opposite_color(us));
   MoveStack* mlist_start = mlist;
 
+  mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
+  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
+  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
+  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
+
   if (us == WHITE)
       mlist = generate_pawn_captures<WHITE>(pos, mlist);
   else
       mlist = generate_pawn_captures<BLACK>(pos, mlist);
 
-  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);
   return int(mlist - mlist_start);
 }
@@ -306,26 +307,26 @@ int generate_evasions(const Position& pos, MoveStack* mlist) {
           // Pawn moves. Because a blocking evasion can never be a capture, we
           // only generate pawn pushes.
           if (us == WHITE)
-              generate_pawn_blocking_evasions<WHITE>(pos, not_pinned, blockSquares, mlist);
+              mlist = generate_pawn_blocking_evasions<WHITE>(pos, not_pinned, blockSquares, mlist);
           else
-              generate_pawn_blocking_evasions<BLACK>(pos, not_pinned, blockSquares, mlist);
+              mlist = generate_pawn_blocking_evasions<BLACK>(pos, not_pinned, blockSquares, mlist);
 
           // Pieces moves
           b1 = pos.knights(us) & not_pinned;
           if (b1)
-              generate_piece_blocking_evasions<KNIGHT>(pos, b1, blockSquares, mlist);
+              mlist = generate_piece_blocking_evasions<KNIGHT>(pos, b1, blockSquares, mlist);
 
           b1 = pos.bishops(us) & not_pinned;
           if (b1)
-              generate_piece_blocking_evasions<BISHOP>(pos, b1, blockSquares, mlist);
+              mlist = generate_piece_blocking_evasions<BISHOP>(pos, b1, blockSquares, mlist);
 
           b1 = pos.rooks(us) & not_pinned;
           if (b1)
-              generate_piece_blocking_evasions<ROOK>(pos, b1, blockSquares, mlist);
+              mlist = generate_piece_blocking_evasions<ROOK>(pos, b1, blockSquares, mlist);
 
           b1 = pos.queens(us) & not_pinned;
           if (b1)
-              generate_piece_blocking_evasions<QUEEN>(pos, b1, blockSquares, mlist);
+              mlist = generate_piece_blocking_evasions<QUEEN>(pos, b1, blockSquares, mlist);
     }
 
     // Finally, the ugly special case of en passant captures. An en passant
@@ -385,24 +386,25 @@ int generate_legal_moves(const Position& pos, MoveStack* mlist) {
 
   // Remove illegal moves from the list
   for (int i = 0; i < n; i++)
-      if (!pos.move_is_legal(mlist[i].move, pinned))
+      if (!pos.pl_move_is_legal(mlist[i].move, pinned))
           mlist[i--].move = mlist[--n].move;
 
   return n;
 }
 
 
-/// generate_move_if_legal() takes a position and a (not necessarily
-/// pseudo-legal) move and a pinned pieces bitboard as input, and tests
-/// whether the move is legal.  If the move is legal, the move itself is
-/// returned.  If not, the function returns MOVE_NONE.  This function must
+/// move_is_legal() takes a position and a (not necessarily pseudo-legal)
+/// move and a pinned pieces bitboard as input, and tests whether
+/// the move is legal.  If the move is legal, the move itself is
+/// returned. If not, the function returns false.  This function must
 /// only be used when the side to move is not in check.
 
-Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
+bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
   assert(move_is_ok(m));
+  assert(pinned == pos.pinned_pieces(pos.side_to_move()));
 
   Color us = pos.side_to_move();
   Color them = opposite_color(us);
@@ -412,7 +414,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
   // If the from square is not occupied by a piece belonging to the side to
   // move, the move is obviously not legal.
   if (color_of_piece(pc) != us)
-      return MOVE_NONE;
+      return false;
 
   Square to = move_to(m);
 
@@ -423,13 +425,13 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // en passant square.
       if (   type_of_piece(pc) != PAWN
           || to != pos.ep_square())
-          return MOVE_NONE;
+          return false;
 
       assert(pos.square_is_empty(to));
       assert(pos.piece_on(to - pawn_push(us)) == pawn_of_color(them));
 
-      // The move is pseudo-legal.  If it is legal, return it.
-      return (pos.move_is_legal(m) ? m : MOVE_NONE);
+      // The move is pseudo-legal, check if it is also legal
+      return pos.pl_move_is_legal(m, pinned);
   }
 
   // Castling moves
@@ -439,7 +441,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // the right to castle kingside.
       if (   type_of_piece(pc) != KING
           ||!pos.can_castle_kingside(us))
-          return MOVE_NONE;
+          return false;
 
       assert(from == pos.king_square(us));
       assert(to == pos.initial_kr_square(us));
@@ -463,7 +465,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
           if (s != from && s != to && !pos.square_is_empty(s))
               illegal = true;
 
-      return (!illegal ? m : MOVE_NONE);
+      return !illegal;
   }
 
   if (move_is_long_castle(m))
@@ -472,7 +474,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // the right to castle kingside.
       if (   type_of_piece(pc) != KING
           ||!pos.can_castle_queenside(us))
-          return MOVE_NONE;
+          return false;
 
       assert(from == pos.king_square(us));
       assert(to == pos.initial_qr_square(us));
@@ -497,14 +499,14 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
               || pos.piece_on(to + DELTA_W) == queen_of_color(them)))
           illegal = true;
 
-      return (!illegal ? m : MOVE_NONE);
+      return !illegal;
   }
 
   // Normal moves
 
   // The destination square cannot be occupied by a friendly piece
   if (pos.color_of_piece_on(to) == us)
-      return MOVE_NONE;
+      return false;
 
   // Proceed according to the type of the moving piece.
   if (type_of_piece(pc) == PAWN)
@@ -514,7 +516,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       if (   (  (square_rank(to) == RANK_8 && us == WHITE)
               ||(square_rank(to) == RANK_1 && us != WHITE))
            && !move_promotion(m))
-          return MOVE_NONE;
+          return false;
 
       // Proceed according to the square delta between the source and
       // destionation squares.
@@ -527,14 +529,14 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // Capture. The destination square must be occupied by an enemy
       // piece (en passant captures was handled earlier).
           if (pos.color_of_piece_on(to) != them)
-              return MOVE_NONE;
+              return false;
           break;
 
       case DELTA_N:
       case DELTA_S:
       // Pawn push. The destination square must be empty.
           if (!pos.square_is_empty(to))
-              return MOVE_NONE;
+              return false;
           break;
 
       case DELTA_NN:
@@ -544,7 +546,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       if (   square_rank(to) != RANK_4
           || !pos.square_is_empty(to)
           || !pos.square_is_empty(from + DELTA_N))
-          return MOVE_NONE;
+          return false;
           break;
 
       case DELTA_SS:
@@ -554,20 +556,20 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
           if (   square_rank(to) != RANK_5
               || !pos.square_is_empty(to)
               || !pos.square_is_empty(from + DELTA_S))
-              return MOVE_NONE;
+              return false;
           break;
 
       default:
-          return MOVE_NONE;
+          return false;
       }
-      // The move is pseudo-legal.  Return it if it is legal.
-      return (pos.move_is_legal(m) ? m : MOVE_NONE);
+      // The move is pseudo-legal, check if it is also legal
+      return pos.pl_move_is_legal(m, pinned);
   }
 
   // Luckly we can handle all the other pieces in one go
   return (   pos.piece_attacks_square(from, to)
-          && pos.move_is_legal(m)
-          && !move_promotion(m) ? m : MOVE_NONE);
+          && pos.pl_move_is_legal(m, pinned)
+          && !move_promotion(m));
 }
 
 
@@ -615,7 +617,7 @@ namespace {
   template<Color Us, Color Them, Bitboard TRank8BB, SquareDelta TDELTA_NE,
            SquareDelta TDELTA_NW, SquareDelta TDELTA_N
           >
-  MoveStack* do_generate_pawn_captures(const Position& pos, MoveStack* mlist) {    
+  MoveStack* do_generate_pawn_captures(const Position& pos, MoveStack* mlist) {
 
     Square to;
     Bitboard pawns = pos.pawns(Us);
@@ -688,7 +690,7 @@ namespace {
   template<Color Us, Color Them, Bitboard TRank8BB, Bitboard TRank3BB,
            SquareDelta TDELTA_NE, SquareDelta TDELTA_NW, SquareDelta TDELTA_N
           >
-  MoveStack* do_generate_pawn_noncaptures(const Position& pos, MoveStack* mlist) {   
+  MoveStack* do_generate_pawn_noncaptures(const Position& pos, MoveStack* mlist) {
 
     Bitboard pawns = pos.pawns(Us);
     Bitboard enemyPieces = pos.pieces_of_color(Them);