Unify compute_mg_value() and compute_eg_value()

[stockfish] / src / position.cpp

diff --git a/src/position.cpp b/src/position.cpp
index 2fc73b660d912898b9563f87a127ff682bf6d5e3..d5f28218ea8aa53c53846a02516157edc8e0b2ae 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -210,8 +210,8 @@ void Position::from_fen(const std::string& fen) {
   key = compute_key();
   pawnKey = compute_pawn_key();
   materialKey = compute_material_key();
-  mgValue = compute_mg_value();
-  egValue = compute_eg_value();
+  mgValue = compute_value(MidGame);
+  egValue = compute_value(EndGame);
   npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   npMaterial[BLACK] = compute_non_pawn_material(BLACK);
 }
@@ -669,60 +669,6 @@ bool Position::move_is_capture(Move m) const {
 }
 
 
-/// Position::backup() is called when making a move. All information
-/// necessary to restore the position when the move is later unmade
-/// is saved to an UndoInfo object. The function Position::restore
-/// does the reverse operation:  When one does a backup followed by
-/// a restore with the same UndoInfo object, the position is restored
-/// to the state before backup was called.
-
-void Position::backup(UndoInfo& u) const {
-
-  for (Color c = WHITE; c <= BLACK; c++)
-  {
-      u.pinners[c]      = pinners[c];
-      u.pinned[c]       = pinned[c];
-      u.dcCandidates[c] = dcCandidates[c];
-  }
-  u.checkersBB   = checkersBB;
-  u.key          = key;
-  u.pawnKey      = pawnKey;
-  u.materialKey  = materialKey;
-  u.castleRights = castleRights;
-  u.rule50       = rule50;
-  u.epSquare     = epSquare;
-  u.lastMove     = lastMove;
-  u.mgValue      = mgValue;
-  u.egValue      = egValue;
-  u.capture      = NO_PIECE_TYPE;
-}
-
-
-/// Position::restore() is called when unmaking a move.  It copies back
-/// the information backed up during a previous call to Position::backup.
-
-void Position::restore(const UndoInfo& u) {
-
-  for (Color c = WHITE; c <= BLACK; c++)
-  {
-      pinners[c]      = u.pinners[c];
-      pinned[c]       = u.pinned[c];
-      dcCandidates[c] = u.dcCandidates[c];
-  }
-  checkersBB   = u.checkersBB;
-  key          = u.key;
-  pawnKey      = u.pawnKey;
-  materialKey  = u.materialKey;
-  castleRights = u.castleRights;
-  rule50       = u.rule50;
-  epSquare     = u.epSquare;
-  lastMove     = u.lastMove;
-  mgValue     = u.mgValue;
-  egValue     = u.egValue;
-  // u.capture is restored in undo_move()
-}
-
-
 /// Position::update_checkers() is a private method to udpate chekers info
 
 template<PieceType Piece>
@@ -758,7 +704,8 @@ void Position::do_move(Move m, UndoInfo& u) {
 
   // Back up the necessary information to our UndoInfo object (except the
   // captured piece, which is taken care of later.
-  backup(u);
+  u = undoInfoUnion;
+  u.capture = NO_PIECE_TYPE;
 
   // Save the current key to the history[] array, in order to be able to
   // detect repetition draws.
@@ -1219,7 +1166,7 @@ void Position::undo_move(Move m, const UndoInfo &u) {
 
   // Restore information from our UndoInfo object (except the captured piece,
   // which is taken care of later)
-  restore(u);
+  undoInfoUnion = u;
 
   if (move_is_castle(m))
       undo_castle_move(m);
@@ -1870,7 +1817,7 @@ Key Position::compute_material_key() const {
 /// up, and to verify that the scores are correctly updated by do_move
 /// and undo_move when the program is running in debug mode.
 
-Value Position::compute_mg_value() const {
+Value Position::compute_value(GamePhase p) const {
 
   Value result = Value(0);
   Bitboard b;
@@ -1884,31 +1831,12 @@ Value Position::compute_mg_value() const {
           {
               s = pop_1st_bit(&b);
               assert(piece_on(s) == piece_of_color_and_type(c, pt));
-              result += mg_pst(c, pt, s);
+              result += (p == MidGame ? mg_pst(c, pt, s) : eg_pst(c, pt, s));
           }
       }
-  result += (side_to_move() == WHITE)? TempoValueMidgame / 2 : -TempoValueMidgame / 2;
-  return result;
-}
-
-Value Position::compute_eg_value() const {
-
-  Value result = Value(0);
-  Bitboard b;
-  Square s;
 
-  for (Color c = WHITE; c <= BLACK; c++)
-    for (PieceType pt = PAWN; pt <= KING; pt++)
-    {
-        b = pieces_of_color_and_type(c, pt);
-        while(b)
-        {
-            s = pop_1st_bit(&b);
-            assert(piece_on(s) == piece_of_color_and_type(c, pt));
-            result += eg_pst(c, pt, s);
-        }
-    }
-  result += (side_to_move() == WHITE)? TempoValueEndgame / 2 : -TempoValueEndgame / 2;
+  const Value TempoValue = (p == MidGame ? TempoValueMidgame : TempoValueEndgame);
+  result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2;
   return result;
 }
 
@@ -2129,8 +2057,8 @@ void Position::flipped_copy(const Position &pos) {
   materialKey = compute_material_key();
 
   // Incremental scores
-  mgValue = compute_mg_value();
-  egValue = compute_eg_value();
+  mgValue = compute_value(MidGame);
+  egValue = compute_value(EndGame);
 
   // Material
   npMaterial[WHITE] = compute_non_pawn_material(WHITE);
@@ -2259,10 +2187,10 @@ bool Position::is_ok(int* failedStep) const {
   if (failedStep) (*failedStep)++;
   if (debugIncrementalEval)
   {
-      if (mgValue != compute_mg_value())
+      if (mgValue != compute_value(MidGame))
           return false;
 
-      if (egValue != compute_eg_value())
+      if (egValue != compute_value(EndGame))
           return false;
   }