Various cleanups in Position's ancillary functions

No functional change.

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

src/position.cpp

@@ -312,7 +312,7 @@ bool Position::set_castling_rights(char token) {
         for (Square sq = sqH; sq >= sqA; sq--)
             if (piece_on(sq) == rook)
             {
-                allow_oo(c);
+                do_allow_oo(c);
                 initialKRFile = square_file(sq);
                 break;
             }
@@ -322,7 +322,7 @@ bool Position::set_castling_rights(char token) {
         for (Square sq = sqA; sq <= sqH; sq++)
             if (piece_on(sq) == rook)
             {
-                allow_ooo(c);
+                do_allow_ooo(c);
                 initialQRFile = square_file(sq);
                 break;
             }
@@ -332,12 +332,12 @@ bool Position::set_castling_rights(char token) {
         File rookFile = File(token - 'A') + FILE_A;
         if (rookFile < initialKFile)
         {
-            allow_ooo(c);
+            do_allow_ooo(c);
             initialQRFile = rookFile;
         }
         else
         {
-            allow_oo(c);
+            do_allow_oo(c);
             initialKRFile = rookFile;
         }
     }
@@ -1393,7 +1393,7 @@ int Position::see_sign(Move m) const {
 
 int Position::see(Square from, Square to) const {
 
-  Bitboard occ, attackers, stmAttackers, b;
+  Bitboard occupied, attackers, stmAttackers, b;
   int swapList[32], slIndex = 1;
   PieceType capturedType, pt;
   Color stm;
@@ -1407,26 +1407,26 @@ int Position::see(Square from, Square to) const {
   if (capturedType == KING)
       return seeValues[capturedType];
 
-  occ = occupied_squares();
+  occupied = occupied_squares();
 
   // Handle en passant moves
   if (st->epSquare == to && type_of_piece_on(from) == PAWN)
   {
-      Square capQq = (side_to_move() == WHITE) ? (to - DELTA_N) : (to - DELTA_S);
+      Square capQq = (side_to_move() == WHITE ? to - DELTA_N : to - DELTA_S);
 
       assert(capturedType == PIECE_TYPE_NONE);
       assert(type_of_piece_on(capQq) == PAWN);
 
       // Remove the captured pawn
-      clear_bit(&occ, capQq);
+      clear_bit(&occupied, capQq);
       capturedType = PAWN;
   }
 
   // Find all attackers to the destination square, with the moving piece
   // removed, but possibly an X-ray attacker added behind it.
-  clear_bit(&occ, from);
+  clear_bit(&occupied, from);
-  attackers =  (rook_attacks_bb(to, occ)      & pieces(ROOK, QUEEN))
+  attackers =  (rook_attacks_bb(to, occupied)  & pieces(ROOK, QUEEN))
-             | (bishop_attacks_bb(to, occ)    & pieces(BISHOP, QUEEN))
+             | (bishop_attacks_bb(to, occupied)& pieces(BISHOP, QUEEN))
              | (attacks_from<KNIGHT>(to)       & pieces(KNIGHT))
              | (attacks_from<KING>(to)         & pieces(KING))
              | (attacks_from<PAWN>(to, WHITE)  & pieces(PAWN, BLACK))
@@ -1454,28 +1454,28 @@ int Position::see(Square from, Square to) const {
       for (pt = PAWN; !(stmAttackers & pieces(pt)); pt++)
           assert(pt < KING);
 
-      // Remove the attacker we just found from the 'attackers' bitboard,
+      // Remove the attacker we just found from the 'occupied' bitboard,
       // and scan for new X-ray attacks behind the attacker.
       b = stmAttackers & pieces(pt);
-      occ ^= (b & (~b + 1));
+      occupied ^= (b & (~b + 1));
-      attackers |=  (rook_attacks_bb(to, occ)   & pieces(ROOK, QUEEN))
+      attackers |=  (rook_attacks_bb(to, occupied)   & pieces(ROOK, QUEEN))
-                  | (bishop_attacks_bb(to, occ) & pieces(BISHOP, QUEEN));
+                  | (bishop_attacks_bb(to, occupied) & pieces(BISHOP, QUEEN));
 
-      attackers &= occ; // Cut out pieces we've already done
+      attackers &= occupied; // Cut out pieces we've already done
 
       // Add the new entry to the swap list
       assert(slIndex < 32);
       swapList[slIndex] = -swapList[slIndex - 1] + seeValues[capturedType];
       slIndex++;
 
-      // Remember the value of the capturing piece, and change the side to move
+      // Remember the value of the capturing piece, and change the side to
-      // before beginning the next iteration
+      // move before beginning the next iteration.
       capturedType = pt;
       stm = opposite_color(stm);
       stmAttackers = attackers & pieces_of_color(stm);
 
-      // Stop after a king capture
+      // Stop before processing a king capture
-      if (pt == KING && stmAttackers)
+      if (capturedType == KING && stmAttackers)
       {
           assert(slIndex < 32);
           swapList[slIndex++] = QueenValueMidgame*10;
@@ -1484,7 +1484,7 @@ int Position::see(Square from, Square to) const {
   } while (stmAttackers);
 
   // Having built the swap list, we negamax through it to find the best
-  // achievable score from the point of view of the side to move
+  // achievable score from the point of view of the side to move.
   while (--slIndex)
       swapList[slIndex-1] = Min(-swapList[slIndex], swapList[slIndex-1]);
 
@@ -1542,7 +1542,7 @@ void Position::inc_startpos_ply_counter() {
 }
 
 /// Position::put_piece() puts a piece on the given square of the board,
-/// updating the board array, bitboards, and piece counts.
+/// updating the board array, pieces list, bitboards, and piece counts.
 
 void Position::put_piece(Piece p, Square s) {
 
@@ -1550,32 +1550,12 @@ void Position::put_piece(Piece p, Square s) {
   PieceType pt = type_of_piece(p);
 
   board[s] = p;
-  index[s] = pieceCount[c][pt];
+  index[s] = pieceCount[c][pt]++;
   pieceList[c][pt][index[s]] = s;
 
   set_bit(&(byTypeBB[pt]), s);
   set_bit(&(byColorBB[c]), s);
-  set_bit(&byTypeBB[0], s); // HACK: byTypeBB[0] contains all occupied squares.
+  set_bit(&(byTypeBB[0]), s); // HACK: byTypeBB[0] contains all occupied squares.
-
-  pieceCount[c][pt]++;
-}
-
-
-/// Position::allow_oo() gives the given side the right to castle kingside.
-/// Used when setting castling rights during parsing of FEN strings.
-
-void Position::allow_oo(Color c) {
-
-  st->castleRights |= (1 + int(c));
-}
-
-
-/// Position::allow_ooo() gives the given side the right to castle queenside.
-/// Used when setting castling rights during parsing of FEN strings.
-
-void Position::allow_ooo(Color c) {
-
-  st->castleRights |= (4 + 4*int(c));
 }
 
 
@@ -1586,7 +1566,7 @@ void Position::allow_ooo(Color c) {
 
 Key Position::compute_key() const {
 
-  Key result = 0;
+  Key result = zobCastle[st->castleRights];
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
       if (square_is_occupied(s))
@@ -1595,7 +1575,6 @@ Key Position::compute_key() const {
   if (ep_square() != SQ_NONE)
       result ^= zobEp[ep_square()];
 
-  result ^= zobCastle[st->castleRights];
   if (side_to_move() == BLACK)
       result ^= zobSideToMove;
 
@@ -1611,18 +1590,14 @@ Key Position::compute_key() const {
 
 Key Position::compute_pawn_key() const {
 
-  Key result = 0;
   Bitboard b;
-  Square s;
+  Key result = 0;
 
   for (Color c = WHITE; c <= BLACK; c++)
   {
       b = pieces(PAWN, c);
       while (b)
-      {
+          result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
-          s = pop_1st_bit(&b);
-          result ^= zobrist[c][PAWN][s];
-      }
   }
   return result;
 }
@@ -1636,11 +1611,13 @@ Key Position::compute_pawn_key() const {
 
 Key Position::compute_material_key() const {
 
+  int count;
   Key result = 0;
+
   for (Color c = WHITE; c <= BLACK; c++)
       for (PieceType pt = PAWN; pt <= QUEEN; pt++)
       {
-          int count = piece_count(c, pt);
+          count = piece_count(c, pt);
           for (int i = 0; i < count; i++)
               result ^= zobrist[c][pt][i];
       }
@@ -1654,20 +1631,15 @@ Key Position::compute_material_key() const {
 /// updated by do_move and undo_move when the program is running in debug mode.
 Score Position::compute_value() const {
 
-  Score result = SCORE_ZERO;
   Bitboard b;
-  Square s;
+  Score result = SCORE_ZERO;
 
   for (Color c = WHITE; c <= BLACK; c++)
       for (PieceType pt = PAWN; pt <= KING; pt++)
       {
           b = pieces(pt, c);
           while (b)
-          {
+              result += pst(c, pt, pop_1st_bit(&b));
-              s = pop_1st_bit(&b);
-              assert(piece_on(s) == piece_of_color_and_type(c, pt));
-              result += pst(c, pt, s);
-          }
       }
 
   result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2);
@@ -1676,7 +1648,7 @@ Score Position::compute_value() const {
 
 
 /// Position::compute_non_pawn_material() computes the total non-pawn middle
-/// game material score for the given side. Material scores are updated
+/// game material value for the given side. Material values are updated
 /// incrementally during the search, this function is only used while
 /// initializing a new Position object.
 
@@ -1685,16 +1657,8 @@ Value Position::compute_non_pawn_material(Color c) const {
   Value result = VALUE_ZERO;
 
   for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
-  {
+      result += piece_count(c, pt) * PieceValueMidgame[pt];
-      Bitboard b = pieces(pt, c);
-      while (b)
-      {
-          assert(piece_on(first_1(b)) == piece_of_color_and_type(c, pt));
 
-          pop_1st_bit(&b);
-          result += PieceValueMidgame[pt];
-      }
-  }
   return result;
 }
 
@@ -1729,7 +1693,7 @@ bool Position::is_draw() const {
 bool Position::is_mate() const {
 
   MoveStack moves[MOVES_MAX];
-  return is_check() && (generate_moves(*this, moves) == moves);
+  return is_check() && generate_moves(*this, moves) == moves;
 }
 
 
@@ -1749,7 +1713,7 @@ bool Position::has_mate_threat() {
   // First pass the move to our opponent doing a null move
   do_null_move(st1);
 
-  // Then generate pseudo-legal moves that give check
+  // Then generate pseudo-legal moves that could give check
   last = generate_non_capture_checks(*this, mlist);
   last = generate_captures(*this, last);
 
@@ -1781,20 +1745,20 @@ bool Position::has_mate_threat() {
 
 void Position::init_zobrist() {
 
-  RKISS RKiss;
   int i,j, k;
+  RKISS rk;
 
   for (i = 0; i < 2; i++) for (j = 0; j < 8; j++) for (k = 0; k < 64; k++)
-      zobrist[i][j][k] = RKiss.rand<Key>();
+      zobrist[i][j][k] = rk.rand<Key>();
 
   for (i = 0; i < 64; i++)
-      zobEp[i] = RKiss.rand<Key>();
+      zobEp[i] = rk.rand<Key>();
 
   for (i = 0; i < 16; i++)
-      zobCastle[i] = RKiss.rand<Key>();
+      zobCastle[i] = rk.rand<Key>();
 
-  zobSideToMove = RKiss.rand<Key>();
+  zobSideToMove = rk.rand<Key>();
-  zobExclusion  = RKiss.rand<Key>();
+  zobExclusion  = rk.rand<Key>();
 }
 
 
@@ -1830,16 +1794,16 @@ void Position::flipped_copy(const Position& pos) {
   // Board
   for (Square s = SQ_A1; s <= SQ_H8; s++)
       if (!pos.square_is_empty(s))
-          put_piece(Piece(int(pos.piece_on(s)) ^ 8), flip_square(s));
+          put_piece(Piece(pos.piece_on(s) ^ 8), flip_square(s));
 
   // Side to move
   sideToMove = opposite_color(pos.side_to_move());
 
   // Castling rights
-  if (pos.can_castle_kingside(WHITE))  allow_oo(BLACK);
+  if (pos.can_castle_kingside(WHITE))  do_allow_oo(BLACK);
-  if (pos.can_castle_queenside(WHITE)) allow_ooo(BLACK);
+  if (pos.can_castle_queenside(WHITE)) do_allow_ooo(BLACK);
-  if (pos.can_castle_kingside(BLACK))  allow_oo(WHITE);
+  if (pos.can_castle_kingside(BLACK))  do_allow_oo(WHITE);
-  if (pos.can_castle_queenside(BLACK)) allow_ooo(WHITE);
+  if (pos.can_castle_queenside(BLACK)) do_allow_ooo(WHITE);
 
   initialKFile  = pos.initialKFile;
   initialKRFile = pos.initialKRFile;
@@ -1881,18 +1845,20 @@ void Position::flipped_copy(const Position& pos) {
 bool Position::is_ok(int* failedStep) const {
 
   // What features of the position should be verified?
-  static const bool debugBitboards = false;
+  const bool debugAll = false;
-  static const bool debugKingCount = false;
+
-  static const bool debugKingCapture = false;
+  const bool debugBitboards       = debugAll || false;
-  static const bool debugCheckerCount = false;
+  const bool debugKingCount       = debugAll || false;
-  static const bool debugKey = false;
+  const bool debugKingCapture     = debugAll || false;
-  static const bool debugMaterialKey = false;
+  const bool debugCheckerCount    = debugAll || false;
-  static const bool debugPawnKey = false;
+  const bool debugKey             = debugAll || false;
-  static const bool debugIncrementalEval = false;
+  const bool debugMaterialKey     = debugAll || false;
-  static const bool debugNonPawnMaterial = false;
+  const bool debugPawnKey         = debugAll || false;
-  static const bool debugPieceCounts = false;
+  const bool debugIncrementalEval = debugAll || false;
-  static const bool debugPieceList = false;
+  const bool debugNonPawnMaterial = debugAll || false;
-  static const bool debugCastleSquares = false;
+  const bool debugPieceCounts     = debugAll || false;
+  const bool debugPieceList       = debugAll || false;
+  const bool debugCastleSquares   = debugAll || false;
 
   if (failedStep) *failedStep = 1;
 

src/position.h

@@ -281,8 +281,8 @@ private:
   // Initialization helper functions (used while setting up a position)
   void clear();
   void put_piece(Piece p, Square s);
-  void allow_oo(Color c);
+  void do_allow_oo(Color c);
-  void allow_ooo(Color c);
+  void do_allow_ooo(Color c);
   bool set_castling_rights(char token);
 
   // Helper functions for doing and undoing moves
@@ -391,7 +391,7 @@ inline Bitboard Position::occupied_squares() const {
 }
 
 inline Bitboard Position::empty_squares() const {
-  return ~(occupied_squares());
+  return ~occupied_squares();
 }
 
 inline Bitboard Position::pieces_of_color(Color c) const {
@@ -535,12 +535,10 @@ inline bool Position::move_is_passed_pawn_push(Move m) const {
 }
 
 inline int Position::rule_50_counter() const {
-
   return st->rule50;
 }
 
 inline int Position::startpos_ply_counter() const {
-
   return startPosPlyCounter;
 }
 
@@ -552,12 +550,10 @@ inline bool Position::opposite_colored_bishops() const {
 }
 
 inline bool Position::has_pawn_on_7th(Color c) const {
-
   return pieces(PAWN, c) & relative_rank_bb(c, RANK_7);
 }
 
 inline bool Position::is_chess960() const {
-
   return isChess960;
 }
 
@@ -581,4 +577,12 @@ inline int Position::thread() const {
   return threadID;
 }
 
+inline void Position::do_allow_oo(Color c) {
+  st->castleRights |= (1 + int(c));
+}
+
+inline void Position::do_allow_ooo(Color c) {
+  st->castleRights |= (4 + 4*int(c));
+}
+
 #endif // !defined(POSITION_H_INCLUDED)