Assorted formatting and comment tweaks in position.h

No functional change.

src/endgame.cpp

@@ -167,7 +167,8 @@ Value Endgame<KXK>::operator()(const Position& pos) const {
   if (   pos.count<QUEEN>(strongSide)
       || pos.count<ROOK>(strongSide)
       ||(pos.count<BISHOP>(strongSide) && pos.count<KNIGHT>(strongSide))
-      || pos.bishop_pair(strongSide))
+      ||(pos.count<BISHOP>(strongSide) > 1 && opposite_colors(pos.list<BISHOP>(strongSide)[0],
+                                                              pos.list<BISHOP>(strongSide)[1])))
       result += VALUE_KNOWN_WIN;
 
   return strongSide == pos.side_to_move() ? result : -result;

src/position.cpp

@@ -176,9 +176,8 @@ void Position::init() {
 }
 
 
-/// Position::operator=() creates a copy of 'pos'. We want the new born Position
+/// Position::operator=() creates a copy of 'pos' but detaching the state pointer
-/// object to not depend on any external data so we detach state pointer from
+/// from the source to be self-consistent and not depending on any external data.
-/// the source one.
 
 Position& Position::operator=(const Position& pos) {
 

src/position.h

@@ -21,17 +21,17 @@
 #define POSITION_H_INCLUDED
 
 #include <cassert>
-#include <cstddef>
+#include <cstddef>  // For offsetof()
 
 #include "bitboard.h"
 #include "types.h"
 
-
-/// The checkInfo struct is initialized at c'tor time and keeps info used
-/// to detect if a move gives check.
 class Position;
 struct Thread;
 
+/// CheckInfo struct is initialized at c'tor time and keeps info used to detect
+/// if a move gives check.
+
 struct CheckInfo {
 
   explicit CheckInfo(const Position&);
@@ -39,52 +39,57 @@ struct CheckInfo {
   Bitboard dcCandidates;
   Bitboard pinned;
   Bitboard checkSq[PIECE_TYPE_NB];
-  Square ksq;
+  Square   ksq;
 };
 
 
-/// The StateInfo struct stores information needed to restore a Position
+/// StateInfo struct stores information needed to restore a Position object to
-/// object to its previous state when we retract a move. Whenever a move
+/// its previous state when we retract a move. Whenever a move is made on the
-/// is made on the board (by calling Position::do_move), a StateInfo
+/// board (by calling Position::do_move), a StateInfo object must be passed.
-/// object must be passed as a parameter.
 
 struct StateInfo {
-  Key pawnKey, materialKey;
+
-  Value nonPawnMaterial[COLOR_NB];
+  // Copied when making a move
-  int castlingRights, rule50, pliesFromNull;
+  Key    pawnKey;
-  Score psq;
+  Key    materialKey;
+  Value  nonPawnMaterial[COLOR_NB];
+  int    castlingRights;
+  int    rule50;
+  int    pliesFromNull;
+  Score  psq;
   Square epSquare;
 
-  Key key;
+  // Not copied when making a move
-  Bitboard checkersBB;
+  Key        key;
-  PieceType capturedType;
+  Bitboard   checkersBB;
+  PieceType  capturedType;
   StateInfo* previous;
 };
 
 
 /// When making a move the current StateInfo up to 'key' excluded is copied to
-/// the new one. Here we calculate the quad words (64bits) needed to be copied.
+/// the new one. Here we calculate the quad words (64 bit) needed to be copied.
 const size_t StateCopySize64 = offsetof(StateInfo, key) / sizeof(uint64_t) + 1;
 
 
-/// The Position class stores the information regarding the board representation
+/// Position class stores information regarding the board representation as
-/// like pieces, side to move, hash keys, castling info, etc. The most important
+/// pieces, side to move, hash keys, castling info, etc. Important methods are
-/// methods are do_move() and undo_move(), used by the search to update node info
+/// do_move() and undo_move(), used by the search to update node info when
-/// when traversing the search tree.
+/// traversing the search tree.
 
 class Position {
 
   friend std::ostream& operator<<(std::ostream&, const Position&);
 
-  // Disable the default copy constructor
+  Position(const Position&); // Disable the default copy constructor
-  Position(const Position&); 
 
 public:
-  Position() {}
+  static void init();
+
+  Position() {} // To define the global object RootPos
   Position(const Position& pos, Thread* th) { *this = pos; thisThread = th; }
   Position(const std::string& f, bool c960, Thread* th) { set(f, c960, th); }
-  Position& operator=(const Position&);
+  Position& operator=(const Position&); // To assign RootPos from UCI
-  static void init();
 
   // FEN string input/output
   void set(const std::string& fenStr, bool isChess960, Thread* th);
@@ -135,7 +140,6 @@ public:
   // Piece specific
   bool pawn_passed(Color c, Square s) const;
   bool pawn_on_7th(Color c) const;
-  bool bishop_pair(Color c) const;
   bool opposite_bishops() const;
 
   // Doing and undoing moves
@@ -153,12 +157,8 @@ public:
   Key key() const;
   Key key_after(Move m) const;
   Key exclusion_key() const;
-  Key pawn_key() const;
   Key material_key() const;
-
+  Key pawn_key() const;
-  // Incremental piece-square evaluation
-  Score psq_score() const;
-  Value non_pawn_material(Color c) const;
 
   // Other properties of the position
   Color side_to_move() const;
@@ -170,6 +170,8 @@ public:
   void set_nodes_searched(uint64_t n);
   bool is_draw() const;
   int rule50_count() const;
+  Score psq_score() const;
+  Value non_pawn_material(Color c) const;
 
   // Position consistency check, for debugging
   bool pos_is_ok(int* step = NULL) const;
@@ -181,7 +183,7 @@ private:
   void set_castling_right(Color c, Square rfrom);
   void set_state(StateInfo* si) const;
 
-  // Helper functions
+  // Other helpers
   Bitboard check_blockers(Color c, Color kingColor) const;
   void put_piece(Square s, Color c, PieceType pt);
   void remove_piece(Square s, Color c, PieceType pt);
@@ -189,15 +191,13 @@ private:
   template<bool Do>
   void do_castling(Square from, Square& to, Square& rfrom, Square& rto);
 
-  // Board and pieces
+  // Data members
   Piece board[SQUARE_NB];
   Bitboard byTypeBB[PIECE_TYPE_NB];
   Bitboard byColorBB[COLOR_NB];
   int pieceCount[COLOR_NB][PIECE_TYPE_NB];
   Square pieceList[COLOR_NB][PIECE_TYPE_NB][16];
   int index[SQUARE_NB];
-
-  // Other info
   int castlingRightsMask[SQUARE_NB];
   Square castlingRookSquare[CASTLING_RIGHT_NB];
   Bitboard castlingPath[CASTLING_RIGHT_NB];
@@ -210,12 +210,12 @@ private:
   bool chess960;
 };
 
-inline uint64_t Position::nodes_searched() const {
+inline Color Position::side_to_move() const {
-  return nodes;
+  return sideToMove;
 }
 
-inline void Position::set_nodes_searched(uint64_t n) {
+inline bool Position::empty(Square s) const {
-  nodes = n;
+  return board[s] == NO_PIECE;
 }
 
 inline Piece Position::piece_on(Square s) const {
@@ -226,14 +226,6 @@ inline Piece Position::moved_piece(Move m) const {
   return board[from_sq(m)];
 }
 
-inline bool Position::empty(Square s) const {
-  return board[s] == NO_PIECE;
-}
-
-inline Color Position::side_to_move() const {
-  return sideToMove;
-}
-
 inline Bitboard Position::pieces() const {
   return byTypeBB[ALL_PIECES];
 }
@@ -266,14 +258,14 @@ template<PieceType Pt> inline const Square* Position::list(Color c) const {
   return pieceList[c][Pt];
 }
 
-inline Square Position::ep_square() const {
-  return st->epSquare;
-}
-
 inline Square Position::king_square(Color c) const {
   return pieceList[c][KING][0];
 }
 
+inline Square Position::ep_square() const {
+  return st->epSquare;
+}
+
 inline int Position::can_castle(CastlingRight cr) const {
   return st->castlingRights & cr;
 }
@@ -292,7 +284,6 @@ inline Square Position::castling_rook_square(CastlingRight cr) const {
 
 template<PieceType Pt>
 inline Bitboard Position::attacks_from(Square s) const {
-
   return  Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, byTypeBB[ALL_PIECES])
         : Pt == QUEEN  ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s)
         : StepAttacksBB[Pt][s];
@@ -360,19 +351,20 @@ inline int Position::rule50_count() const {
   return st->rule50;
 }
 
-inline bool Position::opposite_bishops() const {
+inline uint64_t Position::nodes_searched() const {
+  return nodes;
+}
 
+inline void Position::set_nodes_searched(uint64_t n) {
+  nodes = n;
+}
+
+inline bool Position::opposite_bishops() const {
   return   pieceCount[WHITE][BISHOP] == 1
         && pieceCount[BLACK][BISHOP] == 1
         && opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]);
 }
 
-inline bool Position::bishop_pair(Color c) const {
-
-  return   pieceCount[c][BISHOP] >= 2
-        && opposite_colors(pieceList[c][BISHOP][0], pieceList[c][BISHOP][1]);
-}
-
 inline bool Position::pawn_on_7th(Color c) const {
   return pieces(c, PAWN) & rank_bb(relative_rank(c, RANK_7));
 }
@@ -389,7 +381,7 @@ inline bool Position::capture_or_promotion(Move m) const {
 
 inline bool Position::capture(Move m) const {
 
-  // Note that castling is encoded as "king captures the rook"
+  // Castling is encoded as "king captures the rook"
   assert(is_ok(m));
   return (!empty(to_sq(m)) && type_of(m) != CASTLING) || type_of(m) == ENPASSANT;
 }
@@ -415,8 +407,8 @@ inline void Position::put_piece(Square s, Color c, PieceType pt) {
 
 inline void Position::move_piece(Square from, Square to, Color c, PieceType pt) {
 
-  // index[from] is not updated and becomes stale. This works as long
+  // index[from] is not updated and becomes stale. This works as long as index[]
-  // as index[] is accessed just by known occupied squares.
+  // is accessed just by known occupied squares.
   Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
   byTypeBB[ALL_PIECES] ^= from_to_bb;
   byTypeBB[pt] ^= from_to_bb;
@@ -436,7 +428,7 @@ inline void Position::remove_piece(Square s, Color c, PieceType pt) {
   byTypeBB[ALL_PIECES] ^= s;
   byTypeBB[pt] ^= s;
   byColorBB[c] ^= s;
-  /* board[s] = NO_PIECE; */ // Not needed, will be overwritten by capturing
+  /* board[s] = NO_PIECE;  Not needed, overwritten by the capturing one */
   Square lastSquare = pieceList[c][pt][--pieceCount[c][pt]];
   index[lastSquare] = index[s];
   pieceList[c][pt][index[lastSquare]] = lastSquare;