Introduce another two (bitboard,square) operators

And simplify the code.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/bitboard.h b/src/bitboard.h
index 7a39a5009c5571ccf0ef68b5d90792acc353de9b..241970f834c398b765069d89f261185e700db6d4 100644 (file)
--- a/src/bitboard.h
+++ b/src/bitboard.h
@@ -57,11 +57,19 @@ inline Bitboard operator&(Bitboard b, Square s) {
 }
 
 inline Bitboard& operator|=(Bitboard& b, Square s) {
-  return b |= SquareBB[s], b;
+  return b |= SquareBB[s];
 }
 
 inline Bitboard& operator^=(Bitboard& b, Square s) {
-  return b ^= SquareBB[s], b;
+  return b ^= SquareBB[s];
+}
+
+inline Bitboard operator|(Bitboard b, Square s) {
+  return b | SquareBB[s];
+}
+
+inline Bitboard operator^(Bitboard b, Square s) {
+  return b ^ SquareBB[s];
 }
 
 

diff --git a/src/movegen.cpp b/src/movegen.cpp
index 612a87e577faec13cf342d1522a4b9abea107146..52d358a66bd3979b9e5e3cf31179a68691dd1e97 100644 (file)
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -71,13 +71,9 @@ namespace {
     // Because we generate only legal castling moves we need to verify that
     // when moving the castling rook we do not discover some hidden checker.
     // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
-    if (pos.is_chess960())
-    {
-        Bitboard occ = pos.occupied_squares();
-        occ ^= rfrom;
-        if (pos.attackers_to(kto, occ) & enemies)
+    if (    pos.is_chess960()
+        && (pos.attackers_to(kto, pos.occupied_squares() ^ rfrom) & enemies))
             return mlist;
-    }
 
     (*mlist++).move = make_castle(kfrom, rfrom);
 

diff --git a/src/position.cpp b/src/position.cpp
index 9376aa91ad5b06fbf06ca3f27a0b9a79f78e8db6..2cc384a31e8267a525250e9f69738314c38f0e82 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -425,9 +425,7 @@ bool Position::move_attacks_square(Move m, Square s) const {
   assert(!square_is_empty(from));
 
   // Update occupancy as if the piece is moving
-  occ = occupied_squares();
-  occ ^= from;
-  occ ^= to;
+  occ = occupied_squares() ^ from ^ to;
 
   // The piece moved in 'to' attacks the square 's' ?
   if (attacks_from(piece, to, occ) & s)
@@ -464,17 +462,13 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
       Square to = to_sq(m);
       Square capsq = to + pawn_push(them);
       Square ksq = king_square(us);
-      Bitboard b = occupied_squares();
+      Bitboard b = (occupied_squares() ^ from ^ capsq) | to;
 
       assert(to == ep_square());
       assert(piece_moved(m) == make_piece(us, PAWN));
       assert(piece_on(capsq) == make_piece(them, PAWN));
       assert(piece_on(to) == NO_PIECE);
 
-      b ^= from;
-      b ^= capsq;
-      b |= to;
-
       return   !(attacks_bb<ROOK>(ksq, b) & pieces(ROOK, QUEEN, them))
             && !(attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, them));
   }
@@ -606,28 +600,22 @@ bool Position::is_pseudo_legal(const Move m) const {
   // same kind of moves are filtered out here.
   if (in_check())
   {
-      // In case of king moves under check we have to remove king so to catch
-      // as invalid moves like b1a1 when opposite queen is on c1.
-      if (type_of(pc) == KING)
-      {
-          Bitboard b = occupied_squares();
-          b ^= from;
-          if (attackers_to(to, b) & pieces(~us))
-              return false;
-      }
-      else
+      if (type_of(pc) != KING)
       {
-          Bitboard target = checkers();
-          Square checksq = pop_1st_bit(&target);
+          Bitboard b = checkers();
+          Square checksq = pop_1st_bit(&b);
 
-          if (target) // double check ? In this case a king move is required
+          if (b) // double check ? In this case a king move is required
               return false;
 
           // Our move must be a blocking evasion or a capture of the checking piece
-          target = squares_between(checksq, king_square(us)) | checkers();
-          if (!(target & to))
+          if (!((squares_between(checksq, king_square(us)) | checkers()) & to))
               return false;
       }
+      // In case of king moves under check we have to remove king so to catch
+      // as invalid moves like b1a1 when opposite queen is on c1.
+      else if (attackers_to(to, occupied_squares() ^ from) & pieces(~us))
+          return false;
   }
 
   return true;
@@ -664,15 +652,11 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
       return false;
 
   Color us = sideToMove;
-  Bitboard b = occupied_squares();
   Square ksq = king_square(~us);
 
   // Promotion with check ?
   if (is_promotion(m))
-  {
-      b ^= from;
-      return attacks_from(Piece(promotion_piece_type(m)), to, b) & ksq;
-  }
+      return attacks_from(Piece(promotion_piece_type(m)), to, occupied_squares() ^ from) & ksq;
 
   // En passant capture with check ? We have already handled the case
   // of direct checks and ordinary discovered check, the only case we
@@ -681,32 +665,21 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
   if (is_enpassant(m))
   {
       Square capsq = make_square(file_of(to), rank_of(from));
-      b ^= from;
-      b ^= capsq;
-      b |= to;
-      return  (attacks_bb<ROOK>(ksq, b) & pieces(ROOK, QUEEN, us))
-            ||(attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, us));
+      Bitboard b = (occupied_squares() ^ from ^ capsq) | to;
+
+      return  (attacks_bb<  ROOK>(ksq, b) & pieces(  ROOK, QUEEN, us))
+            | (attacks_bb<BISHOP>(ksq, b) & pieces(BISHOP, QUEEN, us));
   }
 
   // Castling with check ?
   if (is_castle(m))
   {
-      Square kfrom, kto, rfrom, rto;
-      kfrom = from;
-      rfrom = to;
+      Square kfrom = from;
+      Square rfrom = to; // 'King captures the rook' notation
+      Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
+      Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
+      Bitboard b = (occupied_squares() ^ kfrom ^ rfrom) | rto | kto;
 
-      if (rfrom > kfrom)
-      {
-          kto = relative_square(us, SQ_G1);
-          rto = relative_square(us, SQ_F1);
-      } else {
-          kto = relative_square(us, SQ_C1);
-          rto = relative_square(us, SQ_D1);
-      }
-      b ^= kfrom;
-      b ^= rfrom;
-      b |= rto;
-      b |= kto;
       return attacks_bb<ROOK>(rto, b) & ksq;
   }
 
@@ -868,7 +841,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   if (pt == PAWN)
   {
       // Set en-passant square, only if moved pawn can be captured
-      if (   (to ^ from) == 16
+      if (   (int(to) ^ int(from)) == 16
           && (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(PAWN, them)))
       {
           st->epSquare = Square((from + to) / 2);

diff --git a/src/search.cpp b/src/search.cpp
index a322a01df4cec0fe93f517f5fc2c6c6049641718..40f14a509d2e0bc940023354897f15a9a0f14530 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -1410,13 +1410,11 @@ split_point_start: // At split points actual search starts from here
 
     // Case 5: Discovered check, checking piece is the piece moved in m1
     ksq = pos.king_square(pos.side_to_move());
-    if (piece_is_slider(p1) && (squares_between(t1, ksq) & f2))
-    {
-        Bitboard occ = pos.occupied_squares();
-        occ ^= f2;
-        if (pos.attacks_from(p1, t1, occ) & ksq)
-            return true;
-    }
+    if (    piece_is_slider(p1)
+        && (squares_between(t1, ksq) & f2)
+        && (pos.attacks_from(p1, t1, pos.occupied_squares() ^ f2) & ksq))
+        return true;
+
     return false;
   }