Retire PieceValueXXX[] getters

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index 93e344538a9776915eacd1b9090b1d37779e52e9..9d7679ab0979e1daee7f38528d6b5bdb23d318e9 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -400,18 +400,8 @@ Bitboard Position::discovered_check_candidates() const {
   return hidden_checkers<false>();
 }
 
-/// Position::attackers_to() computes a bitboard containing all pieces which
-/// attacks a given square.
-
-Bitboard Position::attackers_to(Square s) const {
-
-  return  (attacks_from<PAWN>(s, BLACK) & pieces(PAWN, WHITE))
-        | (attacks_from<PAWN>(s, WHITE) & pieces(PAWN, BLACK))
-        | (attacks_from<KNIGHT>(s)      & pieces(KNIGHT))
-        | (attacks_from<ROOK>(s)        & pieces(ROOK, QUEEN))
-        | (attacks_from<BISHOP>(s)      & pieces(BISHOP, QUEEN))
-        | (attacks_from<KING>(s)        & pieces(KING));
-}
+/// Position::attackers_to() computes a bitboard of all pieces which attacks a
+/// given square. Slider attacks use occ bitboard as occupancy.
 
 Bitboard Position::attackers_to(Square s, Bitboard occ) const {
 
@@ -423,21 +413,8 @@ Bitboard Position::attackers_to(Square s, Bitboard occ) const {
         | (attacks_from<KING>(s)        & pieces(KING));
 }
 
-/// Position::attacks_from() computes a bitboard of all attacks
-/// of a given piece put in a given square.
-
-Bitboard Position::attacks_from(Piece p, Square s) const {
-
-  assert(square_is_ok(s));
-
-  switch (p)
-  {
-  case WB: case BB: return attacks_from<BISHOP>(s);
-  case WR: case BR: return attacks_from<ROOK>(s);
-  case WQ: case BQ: return attacks_from<QUEEN>(s);
-  default: return StepAttacksBB[p][s];
-  }
-}
+/// Position::attacks_from() computes a bitboard of all attacks of a given piece
+/// put in a given square. Slider attacks use occ bitboard as occupancy.
 
 Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
 
@@ -641,6 +618,9 @@ bool Position::is_pseudo_legal(const Move m) const {
   else if (!bit_is_set(attacks_from(pc, from), to))
       return false;
 
+  // Evasions generator already takes care to avoid some kind of illegal moves
+  // and pl_move_is_legal() relies on this. So we have to take care that the
+  // 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
@@ -708,20 +688,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
   if (is_promotion(m))
   {
       clear_bit(&b, from);
-
-      switch (promotion_piece_type(m))
-      {
-      case KNIGHT:
-          return bit_is_set(attacks_from<KNIGHT>(to), ksq);
-      case BISHOP:
-          return bit_is_set(bishop_attacks_bb(to, b), ksq);
-      case ROOK:
-          return bit_is_set(rook_attacks_bb(to, b), ksq);
-      case QUEEN:
-          return bit_is_set(queen_attacks_bb(to, b), ksq);
-      default:
-          assert(false);
-      }
+      return bit_is_set(attacks_from(Piece(promotion_piece_type(m)), to, b), ksq);
   }
 
   // En passant capture with check ? We have already handled the case
@@ -1384,7 +1351,7 @@ int Position::see_sign(Move m) const {
   // Early return if SEE cannot be negative because captured piece value
   // is not less then capturing one. Note that king moves always return
   // here because king midgame value is set to 0.
-  if (piece_value_midgame(piece_on(to)) >= piece_value_midgame(piece_on(from)))
+  if (PieceValueMidgame[piece_on(to)] >= PieceValueMidgame[piece_on(from)])
       return 1;
 
   return see(m);
@@ -1591,7 +1558,7 @@ Key Position::compute_material_key() const {
 
   for (Color c = WHITE; c <= BLACK; c++)
       for (PieceType pt = PAWN; pt <= QUEEN; pt++)
-          for (int i = 0, cnt = piece_count(c, pt); i < cnt; i++)
+          for (int i = 0; i < piece_count(c, pt); i++)
               result ^= zobrist[c][pt][i];
 
   return result;
@@ -1689,12 +1656,11 @@ bool Position::is_mate() const {
 }
 
 
-/// Position::init() is a static member function which initializes at
-/// startup the various arrays used to compute hash keys and the piece
-/// square tables. The latter is a two-step operation: First, the white
-/// halves of the tables are copied from the MgPST[][] and EgPST[][] arrays.
-/// Second, the black halves of the tables are initialized by flipping
-/// and changing the sign of the corresponding white scores.
+/// Position::init() is a static member function which initializes at startup
+/// the various arrays used to compute hash keys and the piece square tables.
+/// The latter is a two-step operation: First, the white halves of the tables
+/// are copied from PSQT[] tables. Second, the black halves of the tables are
+/// initialized by flipping and changing the sign of the white scores.
 
 void Position::init() {
 
@@ -1716,7 +1682,7 @@ void Position::init() {
 
   for (Piece p = WP; p <= WK; p++)
   {
-      Score ps = make_score(piece_value_midgame(p), piece_value_endgame(p));
+      Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
 
       for (Square s = SQ_A1; s <= SQ_H8; s++)
       {