X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovegen.cpp;h=612a87e577faec13cf342d1522a4b9abea107146;hb=2608b9249d9c25a699c8db8725e35bd4ec0b65ab;hp=cec98f00e3c189bb08c8c0af1ba5c3932ccb55e2;hpb=28892666bde225bdc13ce3e527f60dbc5f632b8f;p=stockfish

diff --git a/src/movegen.cpp b/src/movegen.cpp
index cec98f00..612a87e5 100644
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -74,7 +74,7 @@ namespace {
     if (pos.is_chess960())
     {
         Bitboard occ = pos.occupied_squares();
-        clear_bit(&occ, rfrom);
+        occ ^= rfrom;
         if (pos.attackers_to(kto, occ) & enemies)
             return mlist;
     }
@@ -112,7 +112,7 @@ namespace {
         if (Type == MV_CAPTURE || Type == MV_EVASION || Type == MV_NON_EVASION)
             (*mlist++).move = make_promotion(to - Delta, to, QUEEN);
 
-        if (Type == MV_NON_CAPTURE || Type == MV_EVASION || Type == MV_NON_EVASION)
+        if (Type == MV_QUIET || Type == MV_EVASION || Type == MV_NON_EVASION)
         {
             (*mlist++).move = make_promotion(to - Delta, to, ROOK);
             (*mlist++).move = make_promotion(to - Delta, to, BISHOP);
@@ -121,7 +121,7 @@ namespace {
 
         // Knight-promotion is the only one that can give a direct check not
         // already included in the queen-promotion.
-        if (Type == MV_NON_CAPTURE_CHECK && bit_is_set(StepAttacksBB[W_KNIGHT][to], ksq))
+        if (Type == MV_QUIET_CHECK && (StepAttacksBB[W_KNIGHT][to] & ksq))
             (*mlist++).move = make_promotion(to - Delta, to, KNIGHT);
         else
             (void)ksq; // Silence a warning under MSVC
@@ -155,7 +155,7 @@ namespace {
     // Single and double pawn pushes, no promotions
     if (Type != MV_CAPTURE)
     {
-        emptySquares = (Type == MV_NON_CAPTURE ? target : pos.empty_squares());
+        emptySquares = (Type == MV_QUIET ? target : ~pos.occupied_squares());
 
         b1 = move_pawns<UP>(pawnsNotOn7)   & emptySquares;
         b2 = move_pawns<UP>(b1 & TRank3BB) & emptySquares;
@@ -166,7 +166,7 @@ namespace {
             b2 &= target;
         }
 
-        if (Type == MV_NON_CAPTURE_CHECK)
+        if (Type == MV_QUIET_CHECK)
         {
             b1 &= pos.attacks_from<PAWN>(ksq, Them);
             b2 &= pos.attacks_from<PAWN>(ksq, Them);
@@ -193,7 +193,7 @@ namespace {
     if (pawnsOn7 && (Type != MV_EVASION || (target & TRank8BB)))
     {
         if (Type == MV_CAPTURE)
-            emptySquares = pos.empty_squares();
+            emptySquares = ~pos.occupied_squares();
 
         if (Type == MV_EVASION)
             emptySquares &= target;
@@ -219,7 +219,7 @@ namespace {
             // 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() - UP))
+            if (Type == MV_EVASION && !(target & (pos.ep_square() - UP)))
                 return mlist;
 
             b1 = pawnsNotOn7 & pos.attacks_from<PAWN>(pos.ep_square(), Them);
@@ -246,7 +246,7 @@ namespace {
 
     if (*pl != SQ_NONE)
     {
-        target = ci.checkSq[Pt] & pos.empty_squares(); // Non capture checks only
+        target = ci.checkSq[Pt] & ~pos.occupied_squares(); // Non capture checks only
 
         do {
             from = *pl;
@@ -255,7 +255,7 @@ namespace {
                 && !(PseudoAttacks[Pt][from] & target))
                 continue;
 
-            if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
+            if (ci.dcCandidates && (ci.dcCandidates & from))
                 continue;
 
             b = pos.attacks_from<Pt>(from) & target;
@@ -302,7 +302,7 @@ namespace {
 /// 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
+/// generate<MV_QUIET> 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
@@ -311,7 +311,7 @@ namespace {
 template<MoveType Type>
 MoveStack* generate(const Position& pos, MoveStack* mlist) {
 
-  assert(Type == MV_CAPTURE || Type == MV_NON_CAPTURE || Type == MV_NON_EVASION);
+  assert(Type == MV_CAPTURE || Type == MV_QUIET || Type == MV_NON_EVASION);
   assert(!pos.in_check());
 
   Color us = pos.side_to_move();
@@ -320,11 +320,11 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
   if (Type == MV_CAPTURE)
       target = pos.pieces(~us);
 
-  else if (Type == MV_NON_CAPTURE)
-      target = pos.empty_squares();
+  else if (Type == MV_QUIET)
+      target = ~pos.occupied_squares();
 
   else if (Type == MV_NON_EVASION)
-      target = pos.pieces(~us) | pos.empty_squares();
+      target = pos.pieces(~us) | ~pos.occupied_squares();
 
   mlist = (us == WHITE ? generate_pawn_moves<WHITE, Type>(pos, mlist, target)
                        : generate_pawn_moves<BLACK, Type>(pos, mlist, target));
@@ -346,14 +346,14 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
 
 // 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_QUIET>(const Position& pos, MoveStack* mlist);
 template MoveStack* generate<MV_NON_EVASION>(const Position& pos, MoveStack* mlist);
 
 
-/// generate<MV_NON_CAPTURE_CHECK> generates all pseudo-legal non-captures and knight
+/// generate<MV_QUIET_CHECK> 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) {
+MoveStack* generate<MV_QUIET_CHECK>(const Position& pos, MoveStack* mlist) {
 
   assert(!pos.in_check());
 
@@ -369,7 +369,7 @@ MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist)
      if (pt == PAWN)
          continue; // Will be generated togheter with direct checks
 
-     Bitboard b = pos.attacks_from(Piece(pt), from) & pos.empty_squares();
+     Bitboard b = pos.attacks_from(Piece(pt), from) & ~pos.occupied_squares();
 
      if (pt == KING)
          b &= ~PseudoAttacks[QUEEN][ci.ksq];
@@ -377,8 +377,8 @@ MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist)
      SERIALIZE(b);
   }
 
-  mlist = (us == WHITE ? generate_pawn_moves<WHITE, MV_NON_CAPTURE_CHECK>(pos, mlist, ci.dcCandidates, ci.ksq)
-                       : generate_pawn_moves<BLACK, MV_NON_CAPTURE_CHECK>(pos, mlist, ci.dcCandidates, ci.ksq));
+  mlist = (us == WHITE ? generate_pawn_moves<WHITE, MV_QUIET_CHECK>(pos, mlist, ci.dcCandidates, ci.ksq)
+                       : generate_pawn_moves<BLACK, MV_QUIET_CHECK>(pos, mlist, ci.dcCandidates, ci.ksq));
 
   mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, ci);
   mlist = generate_direct_checks<BISHOP>(pos, mlist, us, ci);
@@ -430,7 +430,7 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
           // If queen and king are far or not on a diagonal line 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) || !bit_is_set(PseudoAttacks[BISHOP][checksq], ksq))
+          if (squares_between(ksq, checksq) || !(PseudoAttacks[BISHOP][checksq] & ksq))
               sliderAttacks |= PseudoAttacks[QUEEN][checksq];
 
           // Otherwise we need to use real rook attacks to check if king is safe