Tidy up quick_evaluate()

[stockfish] / src / evaluate.cpp

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 049a40deacd3de78f18023a0df22c45e338048b4..89b074eb2f16a63b1594e97da5b107f27f616e9a 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -270,7 +270,7 @@ namespace {
                                     EvalInfo &ei);
 
   inline Value apply_weight(Value v, int w);
-  Value scale_by_game_phase(Value mv, Value ev, Phase ph, ScaleFactor sf[]);
+  Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
 
   int count_1s_8bit(Bitboard b);
 
@@ -419,36 +419,26 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && ei.egValue > Value(0))
           || (factor[BLACK] == SCALE_FACTOR_NORMAL && ei.egValue < Value(0))))
   {
-    if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == 2*BishopValueMidgame)
-    {
-      // Only the two bishops
-      if (pos.pawn_count(WHITE) + pos.pawn_count(BLACK) == 1)
+      ScaleFactor sf;
+
+      // Only the two bishops ?
+      if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
+          && pos.non_pawn_material(BLACK) == BishopValueMidgame)
       {
-        // KBP vs KB with only a single pawn; almost certainly a draw.
-        if (factor[WHITE] == SCALE_FACTOR_NORMAL)
-            factor[WHITE] = ScaleFactor(8);
-        if (factor[BLACK] == SCALE_FACTOR_NORMAL)
-            factor[BLACK] = ScaleFactor(8);
+          // Check for KBP vs KB with only a single pawn that is almost
+          // certainly a draw or at least two pawns.
+          bool one_pawn = (pos.pawn_count(WHITE) + pos.pawn_count(BLACK) == 1);
+          sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
       }
       else
-      {
-        // At least two pawns
-        if (factor[WHITE] == SCALE_FACTOR_NORMAL)
-            factor[WHITE] = ScaleFactor(32);
-        if (factor[BLACK] == SCALE_FACTOR_NORMAL)
-            factor[BLACK] = ScaleFactor(32);
-      }
-    }
-    else
-    {
-      // Endgame with opposite-colored bishops, but also other pieces.
-      // Still a bit drawish, but not as drawish as with only the two
-      // bishops.
+          // Endgame with opposite-colored bishops, but also other pieces. Still
+          // a bit drawish, but not as drawish as with only the two bishops.
+           sf = ScaleFactor(50);
+
       if (factor[WHITE] == SCALE_FACTOR_NORMAL)
-          factor[WHITE] = ScaleFactor(50);
+          factor[WHITE] = sf;
       if (factor[BLACK] == SCALE_FACTOR_NORMAL)
-          factor[BLACK] = ScaleFactor(50);
-    }
+          factor[BLACK] = sf;
   }
 
   // Interpolate between the middle game and the endgame score, and
@@ -466,22 +456,18 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
 /// we should add scores from the pawn and material hash tables?
 
 Value quick_evaluate(const Position &pos) {
-  Color stm;
-  Value mgValue, egValue;
-  ScaleFactor factor[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};
-  Phase phase;
 
   assert(pos.is_ok());
 
-  stm = pos.side_to_move();
+  static const
+  ScaleFactor sf[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};  
 
-  mgValue = pos.mg_value();
-  egValue = pos.eg_value();
-  phase = pos.game_phase();
-
-  Value value = scale_by_game_phase(mgValue, egValue, phase, factor);
+  Value mgv = pos.mg_value();
+  Value egv = pos.eg_value();
+  Phase ph = pos.game_phase();
+  Color stm = pos.side_to_move();
 
-  return Sign[stm] * value;
+  return Sign[stm] * scale_by_game_phase(mgv, egv, ph, sf);
 }
 
 
@@ -1091,7 +1077,7 @@ namespace {
   // score, based on game phase.  It also scales the return value by a
   // ScaleFactor array.
 
-  Value scale_by_game_phase(Value mv, Value ev, Phase ph, ScaleFactor sf[]) {
+  Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]) {
 
     assert(mv > -VALUE_INFINITE && mv < VALUE_INFINITE);
     assert(ev > -VALUE_INFINITE && ev < VALUE_INFINITE);