]> git.sesse.net Git - stockfish/blobdiff - src/evaluate.cpp
Fix operator++ definition
[stockfish] / src / evaluate.cpp
index dd26e46986e9ad7fb57829ddf4ed5f3992f349cc..912c05fc8b394942e46a864235dd9c29dda5d8e0 100644 (file)
 
 namespace {
 
+  enum ExtendedPieceType { // Used for tracing
+    PST = 8, IMBALANCE, MOBILITY, THREAT, PASSED, UNSTOPPABLE, SPACE, TOTAL
+  };
+
+  namespace Tracing {
+
+    Score scores[COLOR_NB][TOTAL + 1];
+    std::stringstream stream;
+
+    void add(int idx, Score term_w, Score term_b = SCORE_ZERO);
+    void row(const char* name, int idx);
+    std::string do_trace(const Position& pos);
+  }
+
   // Struct EvalInfo contains various information computed and collected
   // by the evaluation functions.
   struct EvalInfo {
@@ -72,10 +86,10 @@ namespace {
   };
 
   // Evaluation grain size, must be a power of 2
-  const int GrainSize = 8;
+  const int GrainSize = 4;
 
   // Evaluation weights, initialized from UCI options
-  enum { Mobility, PassedPawns, Space, KingDangerUs, KingDangerThem };
+  enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
   Score Weights[6];
 
   typedef Value V;
@@ -88,33 +102,32 @@ namespace {
   //
   // Values modified by Joona Kiiski
   const Score WeightsInternal[] = {
-      S(289, 344), S(221, 273), S(46, 0), S(271, 0), S(307, 0)
+      S(289, 344), S(233, 201), S(221, 273), S(46, 0), S(271, 0), S(307, 0)
   };
 
-  // MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
-  // end game, indexed by piece type and number of attacked squares not occupied
-  // by friendly pieces.
+  // MobilityBonus[PieceType][attacked] contains bonuses for middle and end
+  // game, indexed by piece type and number of attacked squares not occupied by
+  // friendly pieces.
   const Score MobilityBonus[][32] = {
      {}, {},
-     { S(-38,-33), S(-25,-23), S(-12,-13), S( 0, -3), S(12,  7), S(25, 17), // Knights
-       S( 31, 22), S( 38, 27), S( 38, 27) },
-     { S(-25,-30), S(-11,-16), S(  3, -2), S(17, 12), S(31, 26), S(45, 40), // Bishops
-       S( 57, 52), S( 65, 60), S( 71, 65), S(74, 69), S(76, 71), S(78, 73),
-       S( 79, 74), S( 80, 75), S( 81, 76), S(81, 76) },
-     { S(-20,-36), S(-14,-19), S( -8, -3), S(-2, 13), S( 4, 29), S(10, 46), // Rooks
-       S( 14, 62), S( 19, 79), S( 23, 95), S(26,106), S(27,111), S(28,114),
-       S( 29,116), S( 30,117), S( 31,118), S(32,118) },
-     { S(-10,-18), S( -8,-13), S( -6, -7), S(-3, -2), S(-1,  3), S( 1,  8), // Queens
-       S(  3, 13), S(  5, 19), S(  8, 23), S(10, 27), S(12, 32), S(15, 34),
-       S( 16, 35), S( 17, 35), S( 18, 35), S(20, 35), S(20, 35), S(20, 35),
-       S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
-       S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
-       S( 20, 35), S( 20, 35) }
+     { S(-35,-30), S(-22,-20), S(-9,-10), S( 3,  0), S(15, 10), S(27, 20), // Knights
+       S( 37, 28), S( 42, 31), S(44, 33) },
+     { S(-22,-27), S( -8,-13), S( 6,  1), S(20, 15), S(34, 29), S(48, 43), // Bishops
+       S( 60, 55), S( 68, 63), S(74, 68), S(77, 72), S(80, 75), S(82, 77),
+       S( 84, 79), S( 86, 81) },
+     { S(-17,-33), S(-11,-16), S(-5,  0), S( 1, 16), S( 7, 32), S(13, 48), // Rooks
+       S( 18, 64), S( 22, 80), S(26, 96), S(29,109), S(31,115), S(33,119),
+       S( 35,122), S( 36,123), S(37,124) },
+     { S(-12,-20), S( -8,-13), S(-5, -7), S(-2, -1), S( 1,  5), S( 4, 11), // Queens
+       S(  7, 17), S( 10, 23), S(13, 29), S(16, 34), S(18, 38), S(20, 40),
+       S( 22, 41), S( 23, 41), S(24, 41), S(25, 41), S(25, 41), S(25, 41),
+       S( 25, 41), S( 25, 41), S(25, 41), S(25, 41), S(25, 41), S(25, 41),
+       S( 25, 41), S( 25, 41), S(25, 41), S(25, 41) }
   };
 
-  // OutpostBonus[PieceType][Square] contains outpost bonuses of knights and
-  // bishops, indexed by piece type and square (from white's point of view).
-  const Value OutpostBonus[][SQUARE_NB] = {
+  // Outpost[PieceType][Square] contains bonuses of knights and bishops, indexed
+  // by piece type and square (from white's point of view).
+  const Value Outpost[][SQUARE_NB] = {
   {
   //  A     B     C     D     E     F     G     H
     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights
@@ -132,9 +145,9 @@ namespace {
     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) }
   };
 
-  // ThreatBonus[attacking][attacked] contains threat bonuses according to
-  // which piece type attacks which one.
-  const Score ThreatBonus[][PIECE_TYPE_NB] = {
+  // Threat[attacking][attacked] contains bonuses according to which piece
+  // type attacks which one.
+  const Score Threat[][PIECE_TYPE_NB] = {
     {}, {},
     { S(0, 0), S( 7, 39), S( 0,  0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
     { S(0, 0), S( 7, 39), S(24, 49), S( 0,  0), S(41,100), S(41,100) }, // BISHOP
@@ -142,75 +155,60 @@ namespace {
     { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0,  0) }  // QUEEN
   };
 
-  // ThreatenedByPawnPenalty[PieceType] contains a penalty according to which
-  // piece type is attacked by an enemy pawn.
-  const Score ThreatenedByPawnPenalty[] = {
+  // ThreatenedByPawn[PieceType] contains a penalty according to which piece
+  // type is attacked by an enemy pawn.
+  const Score ThreatenedByPawn[] = {
     S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
   };
 
   #undef S
 
-  const Score BishopPinBonus = make_score(66, 11);
-
-  // Bonus for having the side to move (modified by Joona Kiiski)
-  const Score Tempo = make_score(24, 11);
-
-  // Rooks and queens on the 7th rank
-  const Score RookOn7thBonus  = make_score(3, 20);
-  const Score QueenOn7thBonus = make_score(1,  8);
-
-  // Rooks and queens attacking pawns on the same rank
-  const Score RookOnPawnBonus  = make_score(3, 48);
-  const Score QueenOnPawnBonus = make_score(1, 40);
-
-  // Rooks on open files (modified by Joona Kiiski)
-  const Score RookOpenFileBonus     = make_score(43, 21);
-  const Score RookHalfOpenFileBonus = make_score(19, 10);
-
-  // Penalty for rooks trapped inside a friendly king which has lost the
-  // right to castle.
-  const Value TrappedRookPenalty = Value(180);
+  const Score Tempo            = make_score(24, 11);
+  const Score BishopPin        = make_score(66, 11);
+  const Score RookOn7th        = make_score(11, 20);
+  const Score QueenOn7th       = make_score( 3,  8);
+  const Score RookOnPawn       = make_score(10, 28);
+  const Score QueenOnPawn      = make_score( 4, 20);
+  const Score RookOpenFile     = make_score(43, 21);
+  const Score RookSemiopenFile = make_score(19, 10);
+  const Score BishopPawns      = make_score( 8, 12);
+  const Score MinorBehindPawn  = make_score(16,  0);
+  const Score UndefendedMinor  = make_score(25, 10);
+  const Score TrappedRook      = make_score(90,  0);
 
   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
   // happen in Chess960 games.
-  const Score TrappedBishopA1H1Penalty = make_score(100, 100);
-
-  // Penalty for an undefended bishop or knight
-  const Score UndefendedMinorPenalty = make_score(25, 10);
+  const Score TrappedBishopA1H1 = make_score(50, 50);
 
   // The SpaceMask[Color] contains the area of the board which is considered
   // by the space evaluation. In the middle game, each side is given a bonus
   // based on how many squares inside this area are safe and available for
   // friendly minor pieces.
   const Bitboard SpaceMask[] = {
-    (1ULL << SQ_C2) | (1ULL << SQ_D2) | (1ULL << SQ_E2) | (1ULL << SQ_F2) |
-    (1ULL << SQ_C3) | (1ULL << SQ_D3) | (1ULL << SQ_E3) | (1ULL << SQ_F3) |
-    (1ULL << SQ_C4) | (1ULL << SQ_D4) | (1ULL << SQ_E4) | (1ULL << SQ_F4),
-    (1ULL << SQ_C7) | (1ULL << SQ_D7) | (1ULL << SQ_E7) | (1ULL << SQ_F7) |
-    (1ULL << SQ_C6) | (1ULL << SQ_D6) | (1ULL << SQ_E6) | (1ULL << SQ_F6) |
-    (1ULL << SQ_C5) | (1ULL << SQ_D5) | (1ULL << SQ_E5) | (1ULL << SQ_F5)
+    (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB),
+    (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB)
   };
 
   // King danger constants and variables. The king danger scores are taken
-  // from the KingDangerTable[]. Various little "meta-bonuses" measuring
+  // from the KingDanger[]. Various little "meta-bonuses" measuring
   // the strength of the enemy attack are added up into an integer, which
-  // is used as an index to KingDangerTable[].
+  // is used as an index to KingDanger[].
   //
   // KingAttackWeights[PieceType] contains king attack weights by piece type
   const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
 
   // Bonuses for enemy's safe checks
-  const int QueenContactCheckBonus = 6;
-  const int RookContactCheckBonus  = 4;
-  const int QueenCheckBonus        = 3;
-  const int RookCheckBonus         = 2;
-  const int BishopCheckBonus       = 1;
-  const int KnightCheckBonus       = 1;
-
-  // InitKingDanger[Square] contains penalties based on the position of the
+  const int QueenContactCheck = 6;
+  const int RookContactCheck  = 4;
+  const int QueenCheck        = 3;
+  const int RookCheck         = 2;
+  const int BishopCheck       = 1;
+  const int KnightCheck       = 1;
+
+  // KingExposed[Square] contains penalties based on the position of the
   // defending king, indexed by king's square (from white's point of view).
-  const int InitKingDanger[] = {
+  const int KingExposed[] = {
      2,  0,  2,  5,  5,  2,  0,  2,
      2,  2,  4,  8,  8,  4,  2,  2,
      7, 10, 12, 12, 12, 12, 10,  7,
@@ -221,19 +219,9 @@ namespace {
     15, 15, 15, 15, 15, 15, 15, 15
   };
 
-  // KingDangerTable[Color][attackUnits] contains the actual king danger
-  // weighted scores, indexed by color and by a calculated integer number.
-  Score KingDangerTable[COLOR_NB][128];
-
-  // TracedTerms[Color][PieceType || TracedType] contains a breakdown of the
-  // evaluation terms, used when tracing.
-  Score TracedScores[COLOR_NB][16];
-  std::stringstream TraceStream;
-
-  enum TracedType {
-    PST = 8, IMBALANCE = 9, MOBILITY = 10, THREAT = 11,
-    PASSED = 12, UNSTOPPABLE = 13, SPACE = 14, TOTAL = 15
-  };
+  // KingDanger[Color][attackUnits] contains the actual king danger weighted
+  // scores, indexed by color and by a calculated integer number.
+  Score KingDanger[COLOR_NB][128];
 
   // Function prototypes
   template<bool Trace>
@@ -246,24 +234,23 @@ namespace {
   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
 
   template<Color Us, bool Trace>
-  Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]);
+  Score evaluate_king(const Position& pos, const EvalInfo& ei, Value margins[]);
 
-  template<Color Us>
-  Score evaluate_threats(const Position& pos, EvalInfo& ei);
+  template<Color Us, bool Trace>
+  Score evaluate_threats(const Position& pos, const EvalInfo& ei);
 
-  template<Color Us>
-  int evaluate_space(const Position& pos, EvalInfo& ei);
+  template<Color Us, bool Trace>
+  Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei);
 
   template<Color Us>
-  Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
+  int evaluate_space(const Position& pos, const EvalInfo& ei);
 
-  Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
+  Score evaluate_unstoppable_pawns(const Position& pos, const EvalInfo& ei);
 
   Value interpolate(const Score& v, Phase ph, ScaleFactor sf);
+  Score apply_weight(Score v, Score w);
   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
   double to_cp(Value v);
-  void trace_add(int idx, Score term_w, Score term_b = SCORE_ZERO);
-  void trace_row(const char* name, int idx);
 }
 
 
@@ -278,13 +265,22 @@ namespace Eval {
   }
 
 
+  /// trace() is like evaluate() but instead of a value returns a string suitable
+  /// to be print on stdout with the detailed descriptions and values of each
+  /// evaluation term. Used mainly for debugging.
+  std::string trace(const Position& pos) {
+    return Tracing::do_trace(pos);
+  }
+
+
   /// init() computes evaluation weights from the corresponding UCI parameters
   /// and setup king tables.
 
   void init() {
 
-    Weights[Mobility]       = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
-    Weights[PassedPawns]    = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
+    Weights[Mobility]       = weight_option("Mobility (Midgame)", "Mobility (Endgame)", WeightsInternal[Mobility]);
+    Weights[PawnStructure]  = weight_option("Pawn Structure (Midgame)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
+    Weights[PassedPawns]    = weight_option("Passed Pawns (Midgame)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
     Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
     Weights[KingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
     Weights[KingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
@@ -296,57 +292,11 @@ namespace Eval {
     {
         t = std::min(Peak, std::min(int(0.4 * i * i), t + MaxSlope));
 
-        KingDangerTable[1][i] = apply_weight(make_score(t, 0), Weights[KingDangerUs]);
-        KingDangerTable[0][i] = apply_weight(make_score(t, 0), Weights[KingDangerThem]);
+        KingDanger[1][i] = apply_weight(make_score(t, 0), Weights[KingDangerUs]);
+        KingDanger[0][i] = apply_weight(make_score(t, 0), Weights[KingDangerThem]);
     }
   }
 
-
-  /// trace() is like evaluate() but instead of a value returns a string suitable
-  /// to be print on stdout with the detailed descriptions and values of each
-  /// evaluation term. Used mainly for debugging.
-
-  std::string trace(const Position& pos) {
-
-    Value margin;
-    std::string totals;
-
-    Search::RootColor = pos.side_to_move();
-
-    TraceStream.str("");
-    TraceStream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
-    memset(TracedScores, 0, 2 * 16 * sizeof(Score));
-
-    do_evaluate<true>(pos, margin);
-
-    totals = TraceStream.str();
-    TraceStream.str("");
-
-    TraceStream << std::setw(21) << "Eval term " << "|    White    |    Black    |     Total     \n"
-                <<             "                     |   MG    EG  |   MG    EG  |   MG     EG   \n"
-                <<             "---------------------+-------------+-------------+---------------\n";
-
-    trace_row("Material, PST, Tempo", PST);
-    trace_row("Material imbalance", IMBALANCE);
-    trace_row("Pawns", PAWN);
-    trace_row("Knights", KNIGHT);
-    trace_row("Bishops", BISHOP);
-    trace_row("Rooks", ROOK);
-    trace_row("Queens", QUEEN);
-    trace_row("Mobility", MOBILITY);
-    trace_row("King safety", KING);
-    trace_row("Threats", THREAT);
-    trace_row("Passed pawns", PASSED);
-    trace_row("Unstoppable pawns", UNSTOPPABLE);
-    trace_row("Space", SPACE);
-
-    TraceStream <<             "---------------------+-------------+-------------+---------------\n";
-    trace_row("Total", TOTAL);
-    TraceStream << totals;
-
-    return TraceStream.str();
-  }
-
 } // namespace Eval
 
 
@@ -385,7 +335,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
 
   // Probe the pawn hash table
   ei.pi = Pawns::probe(pos, th->pawnsTable);
-  score += ei.pi->pawns_value();
+  score += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
 
   // Initialize attack and king safety bitboards
   init_eval_info<WHITE>(pos, ei);
@@ -403,12 +353,12 @@ Value do_evaluate(const Position& pos, Value& margin) {
           - evaluate_king<BLACK, Trace>(pos, ei, margins);
 
   // Evaluate tactical threats, we need full attack information including king
-  score +=  evaluate_threats<WHITE>(pos, ei)
-          - evaluate_threats<BLACK>(pos, ei);
+  score +=  evaluate_threats<WHITE, Trace>(pos, ei)
+          - evaluate_threats<BLACK, Trace>(pos, ei);
 
   // Evaluate passed pawns, we need full attack information including king
-  score +=  evaluate_passed_pawns<WHITE>(pos, ei)
-          - evaluate_passed_pawns<BLACK>(pos, ei);
+  score +=  evaluate_passed_pawns<WHITE, Trace>(pos, ei)
+          - evaluate_passed_pawns<BLACK, Trace>(pos, ei);
 
   // If one side has only a king, check whether exists any unstoppable passed pawn
   if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
@@ -418,7 +368,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
   if (ei.mi->space_weight())
   {
       int s = evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei);
-      score += apply_weight(make_score(s * ei.mi->space_weight(), 0), Weights[Space]);
+      score += apply_weight(s * ei.mi->space_weight(), Weights[Space]);
   }
 
   // Scale winning side if position is more drawish that what it appears
@@ -437,7 +387,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
       {
           // 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.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
+          bool one_pawn = (pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK) == 1);
           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
       }
       else
@@ -452,24 +402,21 @@ Value do_evaluate(const Position& pos, Value& margin) {
   // In case of tracing add all single evaluation contributions for both white and black
   if (Trace)
   {
-      trace_add(PST, pos.psq_score());
-      trace_add(IMBALANCE, ei.mi->material_value());
-      trace_add(PAWN, ei.pi->pawns_value());
-      trace_add(MOBILITY, apply_weight(mobilityWhite, Weights[Mobility]), apply_weight(mobilityBlack, Weights[Mobility]));
-      trace_add(THREAT, evaluate_threats<WHITE>(pos, ei), evaluate_threats<BLACK>(pos, ei));
-      trace_add(PASSED, evaluate_passed_pawns<WHITE>(pos, ei), evaluate_passed_pawns<BLACK>(pos, ei));
-      trace_add(UNSTOPPABLE, evaluate_unstoppable_pawns(pos, ei));
-      Score w = make_score(ei.mi->space_weight() * evaluate_space<WHITE>(pos, ei), 0);
-      Score b = make_score(ei.mi->space_weight() * evaluate_space<BLACK>(pos, ei), 0);
-      trace_add(SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
-      trace_add(TOTAL, score);
-      TraceStream << "\nUncertainty margin: White: " << to_cp(margins[WHITE])
-                  << ", Black: " << to_cp(margins[BLACK])
-                  << "\nScaling: " << std::noshowpos
-                  << std::setw(6) << 100.0 * ei.mi->game_phase() / 128.0 << "% MG, "
-                  << std::setw(6) << 100.0 * (1.0 - ei.mi->game_phase() / 128.0) << "% * "
-                  << std::setw(6) << (100.0 * sf) / SCALE_FACTOR_NORMAL << "% EG.\n"
-                  << "Total evaluation: " << to_cp(v);
+      Tracing::add(PST, pos.psq_score());
+      Tracing::add(IMBALANCE, ei.mi->material_value());
+      Tracing::add(PAWN, ei.pi->pawns_value());
+      Tracing::add(UNSTOPPABLE, evaluate_unstoppable_pawns(pos, ei));
+      Score w = ei.mi->space_weight() * evaluate_space<WHITE>(pos, ei);
+      Score b = ei.mi->space_weight() * evaluate_space<BLACK>(pos, ei);
+      Tracing::add(SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
+      Tracing::add(TOTAL, score);
+      Tracing::stream << "\nUncertainty margin: White: " << to_cp(margins[WHITE])
+                      << ", Black: " << to_cp(margins[BLACK])
+                      << "\nScaling: " << std::noshowpos
+                      << std::setw(6) << 100.0 * ei.mi->game_phase() / 128.0 << "% MG, "
+                      << std::setw(6) << 100.0 * (1.0 - ei.mi->game_phase() / 128.0) << "% * "
+                      << std::setw(6) << (100.0 * sf) / SCALE_FACTOR_NORMAL << "% EG.\n"
+                      << "Total evaluation: " << to_cp(v);
   }
 
   return pos.side_to_move() == WHITE ? v : -v;
@@ -482,16 +429,16 @@ Value do_evaluate(const Position& pos, Value& margin) {
   template<Color Us>
   void init_eval_info(const Position& pos, EvalInfo& ei) {
 
-    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    const Color  Them = (Us == WHITE ? BLACK : WHITE);
+    const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
 
     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
     ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
 
     // Init king safety tables only if we are going to use them
-    if (   pos.piece_count(Us, QUEEN)
-        && pos.non_pawn_material(Us) > QueenValueMg + PawnValueMg)
+    if (pos.count<QUEEN>(Us) && pos.non_pawn_material(Us) > QueenValueMg + PawnValueMg)
     {
-        ei.kingRing[Them] = (b | (Us == WHITE ? b >> 8 : b << 8));
+        ei.kingRing[Them] = b | shift_bb<Down>(b);
         b &= ei.attackedBy[Us][PAWN];
         ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) / 2 : 0;
         ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
@@ -510,14 +457,14 @@ Value do_evaluate(const Position& pos, Value& margin) {
     assert (Piece == BISHOP || Piece == KNIGHT);
 
     // Initial bonus based on square
-    Value bonus = OutpostBonus[Piece == BISHOP][relative_square(Us, s)];
+    Value bonus = Outpost[Piece == BISHOP][relative_square(Us, s)];
 
     // Increase bonus if supported by pawn, especially if the opponent has
     // no minor piece which can exchange the outpost piece.
     if (bonus && (ei.attackedBy[Us][PAWN] & s))
     {
         if (   !pos.pieces(Them, KNIGHT)
-            && !(same_color_squares(s) & pos.pieces(Them, BISHOP)))
+            && !(squares_of_color(s) & pos.pieces(Them, BISHOP)))
             bonus += bonus + bonus / 2;
         else
             bonus += bonus / 2;
@@ -532,27 +479,20 @@ Value do_evaluate(const Position& pos, Value& margin) {
   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
 
     Bitboard b;
-    Square s, ksq;
-    int mob;
-    File f;
+    Square s;
     Score score = SCORE_ZERO;
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
-    const Square* pl = pos.piece_list(Us, Piece);
+    const Square* pl = pos.list<Piece>(Us);
 
     ei.attackedBy[Us][Piece] = 0;
 
     while ((s = *pl++) != SQ_NONE)
     {
         // Find attacked squares, including x-ray attacks for bishops and rooks
-        if (Piece == KNIGHT || Piece == QUEEN)
-            b = pos.attacks_from<Piece>(s);
-        else if (Piece == BISHOP)
-            b = attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN));
-        else if (Piece == ROOK)
-            b = attacks_bb<ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN));
-        else
-            assert(false);
+        b = Piece == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
+          : Piece ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
+                            : pos.attacks_from<Piece>(s);
 
         ei.attackedBy[Us][Piece] |= b;
 
@@ -565,110 +505,91 @@ Value do_evaluate(const Position& pos, Value& margin) {
                 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
         }
 
-        mob = (Piece != QUEEN ? popcount<Max15>(b & mobilityArea)
-                              : popcount<Full >(b & mobilityArea));
+        int mob = Piece != QUEEN ? popcount<Max15>(b & mobilityArea)
+                                 : popcount<Full >(b & mobilityArea);
 
         mobility += MobilityBonus[Piece][mob];
 
         // Decrease score if we are attacked by an enemy pawn. Remaining part
         // of threat evaluation must be done later when we have full attack info.
         if (ei.attackedBy[Them][PAWN] & s)
-            score -= ThreatenedByPawnPenalty[Piece];
+            score -= ThreatenedByPawn[Piece];
 
-        // Otherwise give a bonus if we are a bishop and can pin a piece or
-        // can give a discovered check through an x-ray attack.
+        // Otherwise give a bonus if we are a bishop and can pin a piece or can
+        // give a discovered check through an x-ray attack.
         else if (    Piece == BISHOP
                  && (PseudoAttacks[Piece][pos.king_square(Them)] & s)
                  && !more_than_one(BetweenBB[s][pos.king_square(Them)] & pos.pieces()))
-                 score += BishopPinBonus;
+                 score += BishopPin;
 
         // Penalty for bishop with same coloured pawns
         if (Piece == BISHOP)
-            score -= make_score(8, 12) * ei.pi->same_colored_pawn_count(s, Us); 
+            score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
 
-        // Bishop and knight outposts squares
-        if (    (Piece == BISHOP || Piece == KNIGHT)
-            && !(pos.pieces(Them, PAWN) & attack_span_mask(Us, s)))
-            score += evaluate_outposts<Piece, Us>(pos, ei, s);
+        if (Piece == BISHOP || Piece == KNIGHT)
+        {
+            // Bishop and knight outposts squares
+            if (!(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))
+                score += evaluate_outposts<Piece, Us>(pos, ei, s);
+
+            // Bishop or knight behind a pawn
+            if (    relative_rank(Us, s) < RANK_5
+                && (pos.pieces(PAWN) & (s + pawn_push(Us))))
+                score += MinorBehindPawn;
+        }
 
-        if ((Piece == ROOK || Piece == QUEEN) && relative_rank(Us, s) >= RANK_5)
+        if (  (Piece == ROOK || Piece == QUEEN)
+            && relative_rank(Us, s) >= RANK_5)
         {
-            // Major piece on 7th rank
+            // Major piece on 7th rank and enemy king trapped on 8th
             if (   relative_rank(Us, s) == RANK_7
                 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
-                score += (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
+                score += Piece == ROOK ? RookOn7th : QueenOn7th;
 
-            // Major piece attacking pawns on the same rank
-            Bitboard pawns = pos.pieces(Them, PAWN) & rank_bb(s);
+            // Major piece attacking enemy pawns on the same rank/file
+            Bitboard pawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];
             if (pawns)
-                score += (Piece == ROOK ? RookOnPawnBonus
-                                        : QueenOnPawnBonus) * popcount<Max15>(pawns);
-        }
-
-        // Special extra evaluation for bishops
-        if (Piece == BISHOP && pos.is_chess960())
-        {
-            // An important Chess960 pattern: A cornered bishop blocked by
-            // a friendly pawn diagonally in front of it is a very serious
-            // problem, especially when that pawn is also blocked.
-            if (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1))
-            {
-                Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
-                if (pos.piece_on(s + d) == make_piece(Us, PAWN))
-                {
-                    if (!pos.is_empty(s + d + pawn_push(Us)))
-                        score -= 2*TrappedBishopA1H1Penalty;
-                    else if (pos.piece_on(s + 2*d) == make_piece(Us, PAWN))
-                        score -= TrappedBishopA1H1Penalty;
-                    else
-                        score -= TrappedBishopA1H1Penalty / 2;
-                }
-            }
+                score += popcount<Max15>(pawns) * (Piece == ROOK ? RookOnPawn : QueenOnPawn);
         }
 
         // Special extra evaluation for rooks
         if (Piece == ROOK)
         {
-            // Open and half-open files
-            f = file_of(s);
-            if (ei.pi->file_is_half_open(Us, f))
-            {
-                if (ei.pi->file_is_half_open(Them, f))
-                    score += RookOpenFileBonus;
-                else
-                    score += RookHalfOpenFileBonus;
-            }
+            // Give a bonus for a rook on a open or semi-open file
+            if (ei.pi->semiopen(Us, file_of(s)))
+                score += ei.pi->semiopen(Them, file_of(s)) ? RookOpenFile : RookSemiopenFile;
 
-            // Penalize rooks which are trapped inside a king. Penalize more if
-            // king has lost right to castle.
-            if (mob > 6 || ei.pi->file_is_half_open(Us, f))
+            if (mob > 3 || ei.pi->semiopen(Us, file_of(s)))
                 continue;
 
-            ksq = pos.king_square(Us);
+            Square ksq = pos.king_square(Us);
 
-            if (    file_of(ksq) >= FILE_E
-                &&  file_of(s) > file_of(ksq)
-                && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
-            {
-                // Is there a half-open file between the king and the edge of the board?
-                if (!ei.pi->has_open_file_to_right(Us, file_of(ksq)))
-                    score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
-                                                           : (TrappedRookPenalty - mob * 16), 0);
-            }
-            else if (    file_of(ksq) <= FILE_D
-                     &&  file_of(s) < file_of(ksq)
-                     && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
-            {
-                // Is there a half-open file between the king and the edge of the board?
-                if (!ei.pi->has_open_file_to_left(Us, file_of(ksq)))
-                    score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
-                                                           : (TrappedRookPenalty - mob * 16), 0);
-            }
+            // Penalize rooks which are trapped inside a king. Penalize more if
+            // king has lost right to castle.
+            if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
+                && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
+                && !ei.pi->semiopen_on_side(Us, file_of(ksq), file_of(ksq) < FILE_E))
+                score -= (TrappedRook - make_score(mob * 8, 0)) * (pos.can_castle(Us) ? 1 : 2);
+        }
+
+        // An important Chess960 pattern: A cornered bishop blocked by a friendly
+        // pawn diagonally in front of it is a very serious problem, especially
+        // when that pawn is also blocked.
+        if (   Piece == BISHOP
+            && pos.is_chess960()
+            && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
+        {
+            const enum Piece P = make_piece(Us, PAWN);
+            Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
+            if (pos.piece_on(s + d) == P)
+                score -= !pos.is_empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
+                        : pos.piece_on(s + d + d) == P        ? TrappedBishopA1H1 * 2
+                                                              : TrappedBishopA1H1;
         }
     }
 
     if (Trace)
-        TracedScores[Us][Piece] = score;
+        Tracing::scores[Us][Piece] = score;
 
     return score;
   }
@@ -677,8 +598,8 @@ Value do_evaluate(const Position& pos, Value& margin) {
   // evaluate_threats<>() assigns bonuses according to the type of attacking piece
   // and the type of attacked one.
 
-  template<Color Us>
-  Score evaluate_threats(const Position& pos, EvalInfo& ei) {
+  template<Color Us, bool Trace>
+  Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
@@ -686,32 +607,33 @@ Value do_evaluate(const Position& pos, Value& margin) {
     Score score = SCORE_ZERO;
 
     // Undefended minors get penalized even if not under attack
-    undefendedMinors =  pos.pieces(Them)
-                      & (pos.pieces(BISHOP) | pos.pieces(KNIGHT))
+    undefendedMinors =  pos.pieces(Them, BISHOP, KNIGHT)
                       & ~ei.attackedBy[Them][ALL_PIECES];
 
     if (undefendedMinors)
-        score += UndefendedMinorPenalty;
+        score += UndefendedMinor;
 
     // Enemy pieces not defended by a pawn and under our attack
     weakEnemies =  pos.pieces(Them)
                  & ~ei.attackedBy[Them][PAWN]
                  & ei.attackedBy[Us][ALL_PIECES];
 
-    if (!weakEnemies)
-        return score;
-
     // Add bonus according to type of attacked enemy piece and to the
     // type of attacking piece, from knights to queens. Kings are not
     // considered because are already handled in king evaluation.
-    for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
-    {
-        b = ei.attackedBy[Us][pt1] & weakEnemies;
-        if (b)
-            for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
-                if (b & pos.pieces(pt2))
-                    score += ThreatBonus[pt1][pt2];
-    }
+    if (weakEnemies)
+        for (PieceType pt1 = KNIGHT; pt1 < KING; ++pt1)
+        {
+            b = ei.attackedBy[Us][pt1] & weakEnemies;
+            if (b)
+                for (PieceType pt2 = PAWN; pt2 < KING; ++pt2)
+                    if (b & pos.pieces(pt2))
+                        score += Threat[pt1][pt2];
+        }
+
+    if (Trace)
+        Tracing::scores[Us][THREAT] = score;
+
     return score;
   }
 
@@ -727,7 +649,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
     Score score = mobility = SCORE_ZERO;
 
     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
-    const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us));
+    const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us, PAWN, KING));
 
     score += evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea);
     score += evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea);
@@ -738,6 +660,9 @@ Value do_evaluate(const Position& pos, Value& margin) {
     ei.attackedBy[Us][ALL_PIECES] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
                                     | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
                                     | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
+    if (Trace)
+        Tracing::scores[Us][MOBILITY] = apply_weight(mobility, Weights[Mobility]);
+
     return score;
   }
 
@@ -745,7 +670,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
 
   template<Color Us, bool Trace>
-  Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
+  Score evaluate_king(const Position& pos, const EvalInfo& ei, Value margins[]) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
@@ -769,13 +694,13 @@ Value do_evaluate(const Position& pos, Value& margin) {
                         | ei.attackedBy[Us][QUEEN]);
 
         // Initialize the 'attackUnits' variable, which is used later on as an
-        // index to the KingDangerTable[] array. The initial value is based on
-        // the number and types of the enemy's attacking pieces, the number of
+        // index to the KingDanger[] array. The initial value is based on the
+        // number and types of the enemy's attacking pieces, the number of
         // attacked and undefended squares around our king, the square of the
         // king, and the quality of the pawn shelter.
         attackUnits =  std::min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + popcount<Max15>(undefended))
-                     + InitKingDanger[relative_square(Us, ksq)]
+                     + KingExposed[relative_square(Us, ksq)]
                      - mg_value(score) / 32;
 
         // Analyse enemy's safe queen contact checks. First find undefended
@@ -787,7 +712,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
             if (b)
-                attackUnits +=  QueenContactCheckBonus
+                attackUnits +=  QueenContactCheck
                               * popcount<Max15>(b)
                               * (Them == pos.side_to_move() ? 2 : 1);
         }
@@ -805,7 +730,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
             if (b)
-                attackUnits +=  RookContactCheckBonus
+                attackUnits +=  RookContactCheck
                               * popcount<Max15>(b)
                               * (Them == pos.side_to_move() ? 2 : 1);
         }
@@ -819,37 +744,37 @@ Value do_evaluate(const Position& pos, Value& margin) {
         // Enemy queen safe checks
         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
         if (b)
-            attackUnits += QueenCheckBonus * popcount<Max15>(b);
+            attackUnits += QueenCheck * popcount<Max15>(b);
 
         // Enemy rooks safe checks
         b = b1 & ei.attackedBy[Them][ROOK];
         if (b)
-            attackUnits += RookCheckBonus * popcount<Max15>(b);
+            attackUnits += RookCheck * popcount<Max15>(b);
 
         // Enemy bishops safe checks
         b = b2 & ei.attackedBy[Them][BISHOP];
         if (b)
-            attackUnits += BishopCheckBonus * popcount<Max15>(b);
+            attackUnits += BishopCheck * popcount<Max15>(b);
 
         // Enemy knights safe checks
         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
         if (b)
-            attackUnits += KnightCheckBonus * popcount<Max15>(b);
+            attackUnits += KnightCheck * popcount<Max15>(b);
 
-        // To index KingDangerTable[] attackUnits must be in [0, 99] range
+        // To index KingDanger[] attackUnits must be in [0, 99] range
         attackUnits = std::min(99, std::max(0, attackUnits));
 
-        // Finally, extract the king danger score from the KingDangerTable[]
+        // Finally, extract the king danger score from the KingDanger[]
         // array and subtract the score from evaluation. Set also margins[]
         // value that will be used for pruning because this value can sometimes
         // be very big, and so capturing a single attacking piece can therefore
         // result in a score change far bigger than the value of the captured piece.
-        score -= KingDangerTable[Us == Search::RootColor][attackUnits];
-        margins[Us] += mg_value(KingDangerTable[Us == Search::RootColor][attackUnits]);
+        score -= KingDanger[Us == Search::RootColor][attackUnits];
+        margins[Us] += mg_value(KingDanger[Us == Search::RootColor][attackUnits]);
     }
 
     if (Trace)
-        TracedScores[Us][KING] = score;
+        Tracing::scores[Us][KING] = score;
 
     return score;
   }
@@ -857,8 +782,8 @@ Value do_evaluate(const Position& pos, Value& margin) {
 
   // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
 
-  template<Color Us>
-  Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
+  template<Color Us, bool Trace>
+  Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
@@ -867,10 +792,8 @@ Value do_evaluate(const Position& pos, Value& margin) {
 
     b = ei.pi->passed_pawns(Us);
 
-    if (!b)
-        return SCORE_ZERO;
-
-    do {
+    while (b)
+    {
         Square s = pop_lsb(&b);
 
         assert(pos.pawn_is_passed(Us, s));
@@ -879,8 +802,8 @@ Value do_evaluate(const Position& pos, Value& margin) {
         int rr = r * (r - 1);
 
         // Base bonus based on rank
-        Value mbonus = Value(20 * rr);
-        Value ebonus = Value(10 * (rr + r + 1));
+        Value mbonus = Value(17 * rr);
+        Value ebonus = Value(7 * (rr + r + 1));
 
         if (rr)
         {
@@ -891,34 +814,42 @@ Value do_evaluate(const Position& pos, Value& margin) {
             ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 2 * rr);
 
             // If blockSq is not the queening square then consider also a second push
-            if (rank_of(blockSq) != (Us == WHITE ? RANK_8 : RANK_1))
+            if (relative_rank(Us, blockSq) != RANK_8)
                 ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
 
             // If the pawn is free to advance, increase bonus
             if (pos.is_empty(blockSq))
             {
                 squaresToQueen = forward_bb(Us, s);
-                defendedSquares = squaresToQueen & ei.attackedBy[Us][ALL_PIECES];
 
                 // If there is an enemy rook or queen attacking the pawn from behind,
                 // add all X-ray attacks by the rook or queen. Otherwise consider only
                 // the squares in the pawn's path attacked or occupied by the enemy.
-                if (   (forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN))
+                if (    unlikely(forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN))
                     && (forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
                     unsafeSquares = squaresToQueen;
                 else
                     unsafeSquares = squaresToQueen & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
 
-                // If there aren't enemy attacks or pieces along the path to queen give
-                // huge bonus. Even bigger if we protect the pawn's path.
-                if (!unsafeSquares)
-                    ebonus += Value(rr * (squaresToQueen == defendedSquares ? 17 : 15));
+                if (    unlikely(forward_bb(Them, s) & pos.pieces(Us, ROOK, QUEEN))
+                    && (forward_bb(Them, s) & pos.pieces(Us, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
+                    defendedSquares = squaresToQueen;
                 else
-                    // OK, there are enemy attacks or pieces (but not pawns). Are those
-                    // squares which are attacked by the enemy also attacked by us ?
-                    // If yes, big bonus (but smaller than when there are no enemy attacks),
-                    // if no, somewhat smaller bonus.
-                    ebonus += Value(rr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
+                    defendedSquares = squaresToQueen & ei.attackedBy[Us][ALL_PIECES];
+
+                // If there aren't enemy attacks huge bonus, a bit smaller if at
+                // least block square is not attacked, otherwise smallest bonus.
+                int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 3;
+
+                // Big bonus if the path to queen is fully defended, a bit less
+                // if at least block square is defended.
+                if (defendedSquares == squaresToQueen)
+                    k += 6;
+
+                else if (defendedSquares & blockSq)
+                    k += (unsafeSquares & defendedSquares) == unsafeSquares ? 4 : 2;
+
+                mbonus += Value(k * rr), ebonus += Value(k * rr);
             }
         } // rr != 0
 
@@ -941,12 +872,22 @@ Value do_evaluate(const Position& pos, Value& margin) {
         {
             if (pos.non_pawn_material(Them) <= KnightValueMg)
                 ebonus += ebonus / 4;
+
             else if (pos.pieces(Them, ROOK, QUEEN))
                 ebonus -= ebonus / 4;
         }
+
+        // Increase the bonus if we have more non-pawn pieces
+        if (pos.count<ALL_PIECES>(  Us) - pos.count<PAWN>(  Us) >
+            pos.count<ALL_PIECES>(Them) - pos.count<PAWN>(Them))
+            ebonus += ebonus / 4;
+
         score += make_score(mbonus, ebonus);
 
-    } while (b);
+    }
+
+    if (Trace)
+        Tracing::scores[Us][PASSED] = apply_weight(score, Weights[PassedPawns]);
 
     // Add the scores to the middle game and endgame eval
     return apply_weight(score, Weights[PassedPawns]);
@@ -956,7 +897,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
   // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides, this is quite
   // conservative and returns a winning score only when we are very sure that the pawn is winning.
 
-  Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
+  Score evaluate_unstoppable_pawns(const Position& pos, const EvalInfo& ei) {
 
     Bitboard b, b2, blockers, supporters, queeningPath, candidates;
     Square s, blockSq, queeningSquare;
@@ -967,7 +908,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
 
     // Step 1. Hunt for unstoppable passed pawns. If we find at least one,
     // record how many plies are required for promotion.
-    for (c = WHITE; c <= BLACK; c++)
+    for (c = WHITE; c <= BLACK; ++c)
     {
         // Skip if other side has non-pawn pieces
         if (pos.non_pawn_material(~c))
@@ -1066,21 +1007,21 @@ Value do_evaluate(const Position& pos, Value& margin) {
             // black pawns: a4, b4 white: b2 then pawn in b4 is giving support.
             if (!opposed)
             {
-                b2 = supporters & in_front_bb(winnerSide, blockSq + pawn_push(winnerSide));
+                b2 = supporters & in_front_bb(winnerSide, rank_of(blockSq + pawn_push(winnerSide)));
 
-                while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
+                if (b2)
                 {
-                    d = square_distance(blockSq, pop_lsb(&b2)) - 2;
+                    d = square_distance(blockSq, backmost_sq(winnerSide, b2)) - 2;
                     movesToGo = std::min(movesToGo, d);
                 }
             }
 
             // Check pawns that can be sacrificed against the blocking pawn
-            b2 = attack_span_mask(winnerSide, blockSq) & candidates & ~(1ULL << s);
+            b2 = pawn_attack_span(winnerSide, blockSq) & candidates & ~SquareBB[s];
 
-            while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
+            if (b2)
             {
-                d = square_distance(blockSq, pop_lsb(&b2)) - 2;
+                d = square_distance(blockSq, backmost_sq(winnerSide, b2)) - 2;
                 movesToGo = std::min(movesToGo, d);
             }
 
@@ -1099,12 +1040,8 @@ Value do_evaluate(const Position& pos, Value& margin) {
             kingptg = (minKingDist + blockersCount) * 2;
         }
 
-        // Check if pawn sacrifice plan _may_ save the day
-        if (pliesToQueen[winnerSide] + 3 > pliesToGo + sacptg)
-            return SCORE_ZERO;
-
-        // Check if king capture plan _may_ save the day (contains some false positives)
-        if (pliesToQueen[winnerSide] + 3 > pliesToGo + kingptg)
+        // Check if pawn sacrifice or king capture plan _may_ save the day
+        if (pliesToQueen[winnerSide] + 3 > pliesToGo + std::min(kingptg, sacptg))
             return SCORE_ZERO;
     }
 
@@ -1121,7 +1058,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
   // twice. Finally, the space bonus is scaled by a weight taken from the
   // material hash table. The aim is to improve play on game opening.
   template<Color Us>
-  int evaluate_space(const Position& pos, EvalInfo& ei) {
+  int evaluate_space(const Position& pos, const EvalInfo& ei) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
@@ -1155,11 +1092,16 @@ Value do_evaluate(const Position& pos, Value& margin) {
     assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
 
-    int ev = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
-    int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
-    return Value((result + GrainSize / 2) & ~(GrainSize - 1));
+    int e = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
+    int r = (mg_value(v) * int(ph) + e * int(PHASE_MIDGAME - ph)) / PHASE_MIDGAME;
+    return Value((r / GrainSize) * GrainSize); // Sign independent
   }
 
+  // apply_weight() weights score v by score w trying to prevent overflow
+  Score apply_weight(Score v, Score w) {
+    return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
+                      (int(eg_value(v)) * eg_value(w)) / 0x100);
+  }
 
   // weight_option() computes the value of an evaluation weight, by combining
   // two UCI-configurable weights (midgame and endgame) with an internal weight.
@@ -1174,41 +1116,73 @@ Value do_evaluate(const Position& pos, Value& margin) {
   }
 
 
-  // A couple of little helpers used by tracing code, to_cp() converts a value to
-  // a double in centipawns scale, trace_add() stores white and black scores.
+  // Tracing functions definitions
 
   double to_cp(Value v) { return double(v) / double(PawnValueMg); }
 
-  void trace_add(int idx, Score wScore, Score bScore) {
+  void Tracing::add(int idx, Score wScore, Score bScore) {
 
-    TracedScores[WHITE][idx] = wScore;
-    TracedScores[BLACK][idx] = bScore;
+    scores[WHITE][idx] = wScore;
+    scores[BLACK][idx] = bScore;
   }
 
+  void Tracing::row(const char* name, int idx) {
 
-  // trace_row() is an helper function used by tracing code to register the
-  // values of a single evaluation term.
-
-  void trace_row(const char* name, int idx) {
-
-    Score wScore = TracedScores[WHITE][idx];
-    Score bScore = TracedScores[BLACK][idx];
+    Score wScore = scores[WHITE][idx];
+    Score bScore = scores[BLACK][idx];
 
     switch (idx) {
     case PST: case IMBALANCE: case PAWN: case UNSTOPPABLE: case TOTAL:
-        TraceStream << std::setw(20) << name << " |   ---   --- |   ---   --- | "
-                    << std::setw(6)  << to_cp(mg_value(wScore)) << " "
-                    << std::setw(6)  << to_cp(eg_value(wScore)) << " \n";
+        stream << std::setw(20) << name << " |   ---   --- |   ---   --- | "
+               << std::setw(6)  << to_cp(mg_value(wScore)) << " "
+               << std::setw(6)  << to_cp(eg_value(wScore)) << " \n";
         break;
     default:
-        TraceStream << std::setw(20) << name << " | " << std::noshowpos
-                    << std::setw(5)  << to_cp(mg_value(wScore)) << " "
-                    << std::setw(5)  << to_cp(eg_value(wScore)) << " | "
-                    << std::setw(5)  << to_cp(mg_value(bScore)) << " "
-                    << std::setw(5)  << to_cp(eg_value(bScore)) << " | "
-                    << std::showpos
-                    << std::setw(6)  << to_cp(mg_value(wScore - bScore)) << " "
-                    << std::setw(6)  << to_cp(eg_value(wScore - bScore)) << " \n";
+        stream << std::setw(20) << name << " | " << std::noshowpos
+               << std::setw(5)  << to_cp(mg_value(wScore)) << " "
+               << std::setw(5)  << to_cp(eg_value(wScore)) << " | "
+               << std::setw(5)  << to_cp(mg_value(bScore)) << " "
+               << std::setw(5)  << to_cp(eg_value(bScore)) << " | "
+               << std::showpos
+               << std::setw(6)  << to_cp(mg_value(wScore - bScore)) << " "
+               << std::setw(6)  << to_cp(eg_value(wScore - bScore)) << " \n";
     }
   }
+
+  std::string Tracing::do_trace(const Position& pos) {
+
+    stream.str("");
+    stream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
+    std::memset(scores, 0, 2 * (TOTAL + 1) * sizeof(Score));
+
+    Value margin;
+    do_evaluate<true>(pos, margin);
+
+    std::string totals = stream.str();
+    stream.str("");
+
+    stream << std::setw(21) << "Eval term " << "|    White    |    Black    |     Total     \n"
+                    <<             "                     |   MG    EG  |   MG    EG  |   MG     EG   \n"
+                    <<             "---------------------+-------------+-------------+---------------\n";
+
+    row("Material, PST, Tempo", PST);
+    row("Material imbalance", IMBALANCE);
+    row("Pawns", PAWN);
+    row("Knights", KNIGHT);
+    row("Bishops", BISHOP);
+    row("Rooks", ROOK);
+    row("Queens", QUEEN);
+    row("Mobility", MOBILITY);
+    row("King safety", KING);
+    row("Threats", THREAT);
+    row("Passed pawns", PASSED);
+    row("Unstoppable pawns", UNSTOPPABLE);
+    row("Space", SPACE);
+
+    stream <<             "---------------------+-------------+-------------+---------------\n";
+    row("Total", TOTAL);
+    stream << totals;
+
+    return stream.str();
+  }
 }