X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=77a6d604523f40a841a5f73ba6a2e67e41a760f3;hp=10c9d6796311fd5bf061d6d1bbac4b15686a56c5;hb=f35ddb04af2a00bd9facf5b66ec97e4ab28d4480;hpb=a9e536a7eb3fdcf7f7594f6b66fe533b13b4c1a8

diff --git a/src/position.cpp b/src/position.cpp
index 10c9d679..77a6d604 100644
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -52,8 +52,7 @@ Key Position::zobCastle[16];
 Key Position::zobMaterial[2][8][16];
 Key Position::zobSideToMove;
 
-Value Position::MgPieceSquareTable[16][64];
-Value Position::EgPieceSquareTable[16][64];
+Score Position::PieceSquareTable[16][64];
 
 static bool RequestPending = false;
 
@@ -213,8 +212,7 @@ void Position::from_fen(const string& fen) {
   st->key = compute_key();
   st->pawnKey = compute_pawn_key();
   st->materialKey = compute_material_key();
-  st->mgValue = compute_value<MidGame>();
-  st->egValue = compute_value<EndGame>();
+  st->value = compute_value();
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
 }
@@ -720,10 +718,10 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   // ones which are recalculated from scratch anyway, then switch our state
   // pointer to point to the new, ready to be updated, state.
   struct ReducedStateInfo {
-    Key key, pawnKey, materialKey;
+    Key pawnKey, materialKey;
     int castleRights, rule50, pliesFromNull;
     Square epSquare;
-    Value mgValue, egValue;
+    Value value;
     Value npMaterial[2];
   };
 
@@ -760,16 +758,15 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
 
   Piece piece = piece_on(from);
   PieceType pt = type_of_piece(piece);
+  PieceType capture = ep ? PAWN : type_of_piece_on(to);
 
   assert(color_of_piece_on(from) == us);
   assert(color_of_piece_on(to) == them || square_is_empty(to));
   assert(!(ep || pm) || piece == piece_of_color_and_type(us, PAWN));
   assert(!pm || relative_rank(us, to) == RANK_8);
 
-  st->capture = ep ? PAWN : type_of_piece_on(to);
-
-  if (st->capture)
-      do_capture_move(key, st->capture, them, to, ep);
+  if (capture)
+      do_capture_move(key, capture, them, to, ep);
 
   // Update hash key
   key ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
@@ -819,7 +816,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
       st->pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
 
       // Set en passant square, only if moved pawn can be captured
-      if (abs(int(to) - int(from)) == 16)
+      if ((to ^ from) == 16)
       {
           if (attacks_from<PAWN>(from + (us == WHITE ? DELTA_N : DELTA_S), us) & pieces(PAWN, them))
           {
@@ -830,8 +827,10 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   }
 
   // Update incremental scores
-  st->mgValue += pst_delta<MidGame>(piece, from, to);
-  st->egValue += pst_delta<EndGame>(piece, from, to);
+  st->value += pst_delta(piece, from, to);
+
+  // Set capture piece
+  st->capture = capture;
 
   if (pm) // promotion ?
   {
@@ -866,10 +865,8 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
       st->pawnKey ^= zobrist[us][PAWN][to];
 
       // Partially revert and update incremental scores
-      st->mgValue -= pst<MidGame>(us, PAWN, to);
-      st->mgValue += pst<MidGame>(us, promotion, to);
-      st->egValue -= pst<EndGame>(us, PAWN, to);
-      st->egValue += pst<EndGame>(us, promotion, to);
+      st->value -= pst(us, PAWN, to);
+      st->value += pst(us, promotion, to);
 
       // Update material
       st->npMaterial[us] += piece_value_midgame(promotion);
@@ -899,9 +896,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
 
   // Finish
   sideToMove = opposite_color(sideToMove);
-
-  st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
-  st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
+  st->value += (sideToMove == WHITE ?  TempoValue : -TempoValue);
 
   assert(is_ok());
 }
@@ -937,8 +932,7 @@ void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Squ
     key ^= zobrist[them][capture][capsq];
 
     // Update incremental scores
-    st->mgValue -= pst<MidGame>(them, capture, capsq);
-    st->egValue -= pst<EndGame>(them, capture, capsq);
+    st->value -= pst(them, capture, capsq);
 
     // If the captured piece was a pawn, update pawn hash key,
     // otherwise update non-pawn material.
@@ -1035,10 +1029,8 @@ void Position::do_castle_move(Move m) {
   index[rto] = tmp;
 
   // Update incremental scores
-  st->mgValue += pst_delta<MidGame>(king, kfrom, kto);
-  st->egValue += pst_delta<EndGame>(king, kfrom, kto);
-  st->mgValue += pst_delta<MidGame>(rook, rfrom, rto);
-  st->egValue += pst_delta<EndGame>(rook, rfrom, rto);
+  st->value += pst_delta(king, kfrom, kto);
+  st->value += pst_delta(rook, rfrom, rto);
 
   // Update hash key
   st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
@@ -1064,9 +1056,7 @@ void Position::do_castle_move(Move m) {
 
   // Finish
   sideToMove = opposite_color(sideToMove);
-
-  st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
-  st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
+  st->value += (sideToMove == WHITE ?  TempoValue : -TempoValue);
 
   assert(is_ok());
 }
@@ -1258,8 +1248,7 @@ void Position::do_null_move(StateInfo& backupSt) {
   // a backup storage not as a new state to be used.
   backupSt.key      = st->key;
   backupSt.epSquare = st->epSquare;
-  backupSt.mgValue  = st->mgValue;
-  backupSt.egValue  = st->egValue;
+  backupSt.value    = st->value;
   backupSt.previous = st->previous;
   backupSt.pliesFromNull = st->pliesFromNull;
   st->previous = &backupSt;
@@ -1279,10 +1268,8 @@ void Position::do_null_move(StateInfo& backupSt) {
   st->epSquare = SQ_NONE;
   st->rule50++;
   st->pliesFromNull = 0;
+  st->value += (sideToMove == WHITE) ?  TempoValue : -TempoValue;
   gamePly++;
-
-  st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
-  st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
 }
 
 
@@ -1297,8 +1284,7 @@ void Position::undo_null_move() {
   StateInfo* backupSt = st->previous;
   st->key      = backupSt->key;
   st->epSquare = backupSt->epSquare;
-  st->mgValue  = backupSt->mgValue;
-  st->egValue  = backupSt->egValue;
+  st->value    = backupSt->value;
   st->previous = backupSt->previous;
   st->pliesFromNull = backupSt->pliesFromNull;
 
@@ -1645,10 +1631,9 @@ Key Position::compute_material_key() const {
 /// game and the endgame. These functions are used to initialize the incremental
 /// scores when a new position is set up, and to verify that the scores are correctly
 /// updated by do_move and undo_move when the program is running in debug mode.
-template<Position::GamePhase Phase>
-Value Position::compute_value() const {
+Score Position::compute_value() const {
 
-  Value result = Value(0);
+  Score result = make_score(0, 0);
   Bitboard b;
   Square s;
 
@@ -1660,12 +1645,11 @@ Value Position::compute_value() const {
           {
               s = pop_1st_bit(&b);
               assert(piece_on(s) == piece_of_color_and_type(c, pt));
-              result += pst<Phase>(c, pt, s);
+              result += pst(c, pt, s);
           }
       }
 
-  const Value TempoValue = (Phase == MidGame ? TempoValueMidgame : TempoValueEndgame);
-  result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2;
+  result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2);
   return result;
 }
 
@@ -1814,16 +1798,12 @@ void Position::init_piece_square_tables() {
       for (Piece p = WP; p <= WK; p++)
       {
           i = (r == 0)? 0 : (genrand_int32() % (r*2) - r);
-          MgPieceSquareTable[p][s] = Value(MgPST[p][s] + i);
-          EgPieceSquareTable[p][s] = Value(EgPST[p][s] + i);
+          PieceSquareTable[p][s] = make_score(MgPST[p][s] + i, EgPST[p][s] + i);
       }
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
       for (Piece p = BP; p <= BK; p++)
-      {
-          MgPieceSquareTable[p][s] = -MgPieceSquareTable[p-8][flip_square(s)];
-          EgPieceSquareTable[p][s] = -EgPieceSquareTable[p-8][flip_square(s)];
-      }
+          PieceSquareTable[p][s] = -PieceSquareTable[p-8][flip_square(s)];
 }
 
 
@@ -1878,8 +1858,7 @@ void Position::flipped_copy(const Position& pos) {
   st->materialKey = compute_material_key();
 
   // Incremental scores
-  st->mgValue = compute_value<MidGame>();
-  st->egValue = compute_value<EndGame>();
+  st->value = compute_value();
 
   // Material
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
@@ -2006,14 +1985,8 @@ bool Position::is_ok(int* failedStep) const {
 
   // Incremental eval OK?
   if (failedStep) (*failedStep)++;
-  if (debugIncrementalEval)
-  {
-      if (st->mgValue != compute_value<MidGame>())
-          return false;
-
-      if (st->egValue != compute_value<EndGame>())
-          return false;
-  }
+  if (debugIncrementalEval && st->value != compute_value())
+      return false;
 
   // Non-pawn material OK?
   if (failedStep) (*failedStep)++;