Rename Pieces

Align with PieceType naming convention and
make them more readable.

No functional change.

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

diff --git a/src/bitbase.cpp b/src/bitbase.cpp
index 5e31cc5c8b89a7cf7222c1a0e760393afba621bd..726411f46b9bbb1cad49a3213cda632d5e658a00 100644 (file)
--- a/src/bitbase.cpp
+++ b/src/bitbase.cpp
@@ -39,9 +39,9 @@ namespace {
     void from_index(int index);
     Result classify_white(const Result db[]);
     Result classify_black(const Result db[]);
     void from_index(int index);
     Result classify_white(const Result db[]);
     Result classify_black(const Result db[]);

-    Bitboard wk_attacks()   const { return StepAttacksBB[WK][whiteKingSquare]; }
-    Bitboard bk_attacks()   const { return StepAttacksBB[BK][blackKingSquare]; }
-    Bitboard pawn_attacks() const { return StepAttacksBB[WP][pawnSquare]; }
+    Bitboard wk_attacks()   const { return StepAttacksBB[W_KING][whiteKingSquare]; }
+    Bitboard bk_attacks()   const { return StepAttacksBB[B_KING][blackKingSquare]; }
+    Bitboard pawn_attacks() const { return StepAttacksBB[W_PAWN][pawnSquare]; }

 
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;
 
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;

diff --git a/src/material.cpp b/src/material.cpp
index cf1019ac07cd3646c036499353556d50fce956e1..a0097d135c2a9b5e8741df74f37a7fc0bc503e5d 100644 (file)
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -254,7 +254,7 @@ int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
               + RedundantQueenPenalty * pieceCount[Us][QUEEN];
 
   // Second-degree polynomial material imbalance by Tord Romstad
               + RedundantQueenPenalty * pieceCount[Us][QUEEN];
 
   // Second-degree polynomial material imbalance by Tord Romstad

-  for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
+  for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)

   {
       pc = pieceCount[Us][pt1];
       if (!pc)
   {
       pc = pieceCount[Us][pt1];
       if (!pc)


@@ -262,7 +262,7 @@ int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
 
       v = LinearCoefficients[pt1];
 
 
       v = LinearCoefficients[pt1];
 

-      for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
+      for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)

           v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
               + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
 
           v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
               + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
 

diff --git a/src/position.cpp b/src/position.cpp
index 9a49501cda35ef004525061287281ffe66054893..f0bbff449427eaa09509645876532ebfe5b45f8d 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -70,7 +70,7 @@ namespace {
   const Score TempoValue = make_score(48, 22);
 
   // To convert a Piece to and from a FEN char
   const Score TempoValue = make_score(48, 22);
 
   // To convert a Piece to and from a FEN char

-  const string PieceToChar(".PNBRQK  pnbrqk  ");
+  const string PieceToChar(" PNBRQK  pnbrqk  .");

 }
 
 
 }
 
 


@@ -338,8 +338,8 @@ void Position::print(Move move) const {
           Piece piece = piece_on(sq);
           char c = (color_of(piece) == BLACK ? '=' : ' ');
 
           Piece piece = piece_on(sq);
           char c = (color_of(piece) == BLACK ? '=' : ' ');
 

-          if (piece == PIECE_NONE && color_of(sq) == DARK)
-              piece = PIECE_NONE_DARK_SQ;
+          if (piece == NO_PIECE && color_of(sq) == DARK)
+              piece++; // Index the dot

 
           cout << c << PieceToChar[piece] << c << '|';
       }
 
           cout << c << PieceToChar[piece] << c << '|';
       }


@@ -401,12 +401,12 @@ Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
 
   assert(square_is_ok(s));
 
 
   assert(square_is_ok(s));
 

-  switch (p)
+  switch (type_of(p))

   {
   {

-  case WB: case BB: return bishop_attacks_bb(s, occ);
-  case WR: case BR: return rook_attacks_bb(s, occ);
-  case WQ: case BQ: return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
-  default: return StepAttacksBB[p][s];
+  case BISHOP: return bishop_attacks_bb(s, occ);
+  case ROOK  : return rook_attacks_bb(s, occ);
+  case QUEEN : return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
+  default    : return StepAttacksBB[p][s];

   }
 }
 
   }
 }
 


@@ -470,7 +470,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
       assert(to == ep_square());
       assert(piece_on(from) == make_piece(us, PAWN));
       assert(piece_on(capsq) == make_piece(them, PAWN));
       assert(to == ep_square());
       assert(piece_on(from) == make_piece(us, PAWN));
       assert(piece_on(capsq) == make_piece(them, PAWN));

-      assert(piece_on(to) == PIECE_NONE);
+      assert(piece_on(to) == NO_PIECE);

 
       clear_bit(&b, from);
       clear_bit(&b, capsq);
 
       clear_bit(&b, from);
       clear_bit(&b, capsq);


@@ -525,12 +525,12 @@ bool Position::is_pseudo_legal(const Move m) const {
       return move_is_legal(m);
 
   // Is not a promotion, so promotion piece must be empty
       return move_is_legal(m);
 
   // Is not a promotion, so promotion piece must be empty

-  if (promotion_piece_type(m) - 2 != PIECE_TYPE_NONE)
+  if (promotion_piece_type(m) - 2 != NO_PIECE_TYPE)

       return false;
 
   // If the from square is not occupied by a piece belonging to the side to
   // move, the move is obviously not legal.
       return false;
 
   // If the from square is not occupied by a piece belonging to the side to
   // move, the move is obviously not legal.

-  if (pc == PIECE_NONE || color_of(pc) != us)
+  if (pc == NO_PIECE || color_of(pc) != us)

       return false;
 
   // The destination square cannot be occupied by a friendly piece
       return false;
 
   // The destination square cannot be occupied by a friendly piece


@@ -791,10 +791,10 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
               assert(pt == PAWN);
               assert(to == st->epSquare);
               assert(relative_rank(us, to) == RANK_6);
               assert(pt == PAWN);
               assert(to == st->epSquare);
               assert(relative_rank(us, to) == RANK_6);

-              assert(piece_on(to) == PIECE_NONE);
+              assert(piece_on(to) == NO_PIECE);

               assert(piece_on(capsq) == make_piece(them, PAWN));
 
               assert(piece_on(capsq) == make_piece(them, PAWN));
 

-              board[capsq] = PIECE_NONE;
+              board[capsq] = NO_PIECE;

           }
 
           st->pawnKey ^= zobrist[them][PAWN][capsq];
           }
 
           st->pawnKey ^= zobrist[them][PAWN][capsq];


@@ -859,7 +859,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   do_move_bb(&occupied, move_bb);
 
   board[to] = board[from];
   do_move_bb(&occupied, move_bb);
 
   board[to] = board[from];

-  board[from] = PIECE_NONE;
+  board[from] = NO_PIECE;

 
   // Update piece lists, index[from] is not updated and becomes stale. This
   // works as long as index[] is accessed just by known occupied squares.
 
   // Update piece lists, index[from] is not updated and becomes stale. This
   // works as long as index[] is accessed just by known occupied squares.


@@ -1024,7 +1024,7 @@ void Position::undo_move(Move m) {
   do_move_bb(&occupied, move_bb);
 
   board[from] = board[to];
   do_move_bb(&occupied, move_bb);
 
   board[from] = board[to];

-  board[to] = PIECE_NONE;
+  board[to] = NO_PIECE;

 
   // Update piece lists, index[to] is not updated and becomes stale. This
   // works as long as index[] is accessed just by known occupied squares.
 
   // Update piece lists, index[to] is not updated and becomes stale. This
   // works as long as index[] is accessed just by known occupied squares.


@@ -1042,7 +1042,7 @@ void Position::undo_move(Move m) {
           assert(pt == PAWN);
           assert(to == st->previous->epSquare);
           assert(relative_rank(us, to) == RANK_6);
           assert(pt == PAWN);
           assert(to == st->previous->epSquare);
           assert(relative_rank(us, to) == RANK_6);

-          assert(piece_on(capsq) == PIECE_NONE);
+          assert(piece_on(capsq) == NO_PIECE);

       }
 
       // Restore the captured piece
       }
 
       // Restore the captured piece


@@ -1120,7 +1120,7 @@ void Position::do_castle_move(Move m) {
   // Update board
   Piece king = make_piece(us, KING);
   Piece rook = make_piece(us, ROOK);
   // Update board
   Piece king = make_piece(us, KING);
   Piece rook = make_piece(us, ROOK);

-  board[kfrom] = board[rfrom] = PIECE_NONE;
+  board[kfrom] = board[rfrom] = NO_PIECE;

   board[kto] = king;
   board[rto] = rook;
 
   board[kto] = king;
   board[rto] = rook;
 


@@ -1134,7 +1134,7 @@ void Position::do_castle_move(Move m) {
   if (Do)
   {
       // Reset capture field
   if (Do)
   {
       // Reset capture field

-      st->capturedType = PIECE_TYPE_NONE;
+      st->capturedType = NO_PIECE_TYPE;

 
       // Update incremental scores
       st->value += pst_delta(king, kfrom, kto);
 
       // Update incremental scores
       st->value += pst_delta(king, kfrom, kto);


@@ -1266,7 +1266,7 @@ int Position::see(Move m) const {
   {
       Square capQq = to - pawn_push(side_to_move());
 
   {
       Square capQq = to - pawn_push(side_to_move());
 

-      assert(capturedType == PIECE_TYPE_NONE);
+      assert(capturedType == NO_PIECE_TYPE);

       assert(type_of(piece_on(capQq)) == PAWN);
 
       // Remove the captured pawn
       assert(type_of(piece_on(capQq)) == PAWN);
 
       // Remove the captured pawn


@@ -1359,7 +1359,7 @@ void Position::clear() {
 
   for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
   {
 
   for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
   {

-      board[sq] = PIECE_NONE;
+      board[sq] = NO_PIECE;

       castleRightsMask[sq] = ALL_CASTLES;
   }
   sideToMove = WHITE;
       castleRightsMask[sq] = ALL_CASTLES;
   }
   sideToMove = WHITE;


@@ -1564,7 +1564,7 @@ void Position::init() {
   zobSideToMove = rk.rand<Key>();
   zobExclusion  = rk.rand<Key>();
 
   zobSideToMove = rk.rand<Key>();
   zobExclusion  = rk.rand<Key>();
 

-  for (Piece p = WP; p <= WK; p++)
+  for (Piece p = W_PAWN; p <= W_KING; p++)

   {
       Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
 
   {
       Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
 


@@ -1658,11 +1658,11 @@ bool Position::pos_is_ok(int* failedStep) const {
 
   // Are the king squares in the position correct?
   if (failedStep) (*failedStep)++;
 
   // Are the king squares in the position correct?
   if (failedStep) (*failedStep)++;

-  if (piece_on(king_square(WHITE)) != WK)
+  if (piece_on(king_square(WHITE)) != W_KING)

       return false;
 
   if (failedStep) (*failedStep)++;
       return false;
 
   if (failedStep) (*failedStep)++;

-  if (piece_on(king_square(BLACK)) != BK)
+  if (piece_on(king_square(BLACK)) != B_KING)

       return false;
 
   // Do both sides have exactly one king?
       return false;
 
   // Do both sides have exactly one king?


@@ -1783,7 +1783,7 @@ bool Position::pos_is_ok(int* failedStep) const {
           if (!can_castle(f))
               continue;
 
           if (!can_castle(f))
               continue;
 

-          Piece rook = (f & (WHITE_OO | WHITE_OOO) ? WR : BR);
+          Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK);

 
           if (   castleRightsMask[castleRookSquare[f]] != (ALL_CASTLES ^ f)
               || piece_on(castleRookSquare[f]) != rook)
 
           if (   castleRightsMask[castleRookSquare[f]] != (ALL_CASTLES ^ f)
               || piece_on(castleRookSquare[f]) != rook)

diff --git a/src/position.h b/src/position.h
index 989694becc2ba1b97c133881863a39b7b6ac1cd8..ba49b82bd91fcc954fc2524344f671c519e132e4 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -278,7 +278,7 @@ inline Piece Position::piece_on(Square s) const {
 }
 
 inline bool Position::square_is_empty(Square s) const {
 }
 
 inline bool Position::square_is_empty(Square s) const {

-  return board[s] == PIECE_NONE;
+  return board[s] == NO_PIECE;

 }
 
 inline Color Position::side_to_move() const {
 }
 
 inline Color Position::side_to_move() const {

diff --git a/src/search.cpp b/src/search.cpp
index 653ef834418ae29881fbb252481245e347f890b9..c09de0ba6b061cb60e677008d9deadcca56edd15 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -706,7 +706,7 @@ namespace {
     if (   (move = (ss-1)->currentMove) != MOVE_NULL
         && (ss-1)->eval != VALUE_NONE
         && ss->eval != VALUE_NONE
     if (   (move = (ss-1)->currentMove) != MOVE_NULL
         && (ss-1)->eval != VALUE_NONE
         && ss->eval != VALUE_NONE

-        && pos.captured_piece_type() == PIECE_TYPE_NONE
+        && pos.captured_piece_type() == NO_PIECE_TYPE

         && !is_special(move))
     {
         Square to = move_to(move);
         && !is_special(move))
     {
         Square to = move_to(move);

diff --git a/src/types.h b/src/types.h
index fc42ea76535feaf4c4a1df5cd1f59e4f32c44b32..f1627a961168403c568872e64abff409e9307065 100644 (file)
--- a/src/types.h
+++ b/src/types.h
@@ -225,17 +225,18 @@ enum Value {
 };
 
 enum PieceType {
 };
 
 enum PieceType {

-  PIECE_TYPE_NONE = 0,
+  NO_PIECE_TYPE = 0,

   PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
 };
 
 enum Piece {
   PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
 };
 
 enum Piece {

-  PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
-  BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16
+  NO_PIECE = 16, // color_of(NO_PIECE) == NO_COLOR
+  W_PAWN = 1, W_KNIGHT =  2, W_BISHOP =  3, W_ROOK =  4, W_QUEEN =  5, W_KING =  6,
+  B_PAWN = 9, B_KNIGHT = 10, B_BISHOP = 11, B_ROOK = 12, B_QUEEN = 13, B_KING = 14

 };
 
 enum Color {
 };
 
 enum Color {

-  WHITE, BLACK, COLOR_NONE
+  WHITE, BLACK, NO_COLOR

 };
 
 enum Depth {
 };
 
 enum Depth {