- {}, {},
- { S(-75,-76), S(-56,-54), S( -9,-26), S( -2,-10), S( 6, 5), S( 15, 11), // Knights
- S( 22, 26), S( 30, 28), S( 36, 29) },
- { S(-48,-58), S(-21,-19), S( 16, -2), S( 26, 12), S( 37, 22), S( 51, 42), // Bishops
- S( 54, 54), S( 63, 58), S( 65, 63), S( 71, 70), S( 79, 74), S( 81, 86),
- S( 92, 90), S( 97, 94) },
- { S(-56,-78), S(-25,-18), S(-11, 26), S( -5, 55), S( -4, 70), S( -1, 81), // Rooks
- S( 8,109), S( 14,120), S( 21,128), S( 23,143), S( 31,154), S( 32,160),
- S( 43,165), S( 49,168), S( 59,169) },
- { S(-40,-35), S(-25,-12), S( 2, 7), S( 4, 19), S( 14, 37), S( 24, 55), // Queens
- S( 25, 62), S( 40, 76), S( 43, 79), S( 47, 87), S( 54, 94), S( 56,102),
- S( 60,111), S( 70,116), S( 72,118), S( 73,122), S( 75,128), S( 77,130),
- S( 85,133), S( 94,136), S( 99,140), S(108,157), S(112,158), S(113,161),
- S(118,174), S(119,177), S(123,191), S(128,199) }
+ { S(-75,-76), S(-57,-54), S( -9,-28), S( -2,-10), S( 6, 5), S( 14, 12), // Knights
+ S( 22, 26), S( 29, 29), S( 36, 29) },
+ { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops
+ S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
+ S( 91, 88), S( 98, 97) },
+ { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks
+ S( 9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165),
+ S( 46,166), S( 48,169), S( 58,171) },
+ { S(-39,-36), S(-21,-15), S( 3, 8), S( 3, 18), S( 14, 34), S( 22, 54), // Queens
+ S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104),
+ S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136),
+ S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175),
+ S(106,184), S(109,191), S(113,206), S(116,212) }
- // ReachableOutpost[knight/bishop][supported by pawn] contains bonuses for
- // knights and bishops which can reach an outpost square in one move, bigger
- // if outpost square is supported by a pawn.
- const Score ReachableOutpost[][2] = {
- { S(21, 5), S(35, 8) }, // Knights
- { S( 8, 0), S(14, 4) } // Bishops
- };
-
- // RookOnFile[semiopen/open] contains bonuses for each rook when there is no
- // friendly pawn on the rook file.
- const Score RookOnFile[2] = { S(20, 7), S(45, 20) };
-
- // ThreatBySafePawn[PieceType] contains bonuses according to which piece
- // type is attacked by a pawn which is protected or is not attacked.
- const Score ThreatBySafePawn[PIECE_TYPE_NB] = {
- S(0, 0), S(0, 0), S(176, 139), S(131, 127), S(217, 218), S(203, 215)
- };
+ // RookOnFile[semiopen/open] contains bonuses for each rook when there is
+ // no (friendly) pawn on the rook file.
+ const Score RookOnFile[] = { S(20, 7), S(45, 20) };
- // Assorted bonuses and penalties used by evaluation
- const Score MinorBehindPawn = S(16, 0);
- const Score BishopPawns = S( 8, 12);
- const Score RookOnPawn = S( 8, 24);
- const Score TrappedRook = S(92, 0);
- const Score WeakQueen = S(50, 10);
- const Score OtherCheck = S(10, 10);
- const Score CloseEnemies = S( 7, 0);
- const Score PawnlessFlank = S(20, 80);
- const Score LooseEnemies = S( 0, 25);
- const Score ThreatByHangingPawn = S(71, 61);
- const Score ThreatByRank = S(16, 3);
- const Score Hanging = S(48, 27);
- const Score ThreatByPawnPush = S(38, 22);
- const Score HinderPassedPawn = S( 7, 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 TrappedBishopA1H1 = S(50, 50);
-
- #undef S
- #undef V
+ // PassedDanger[Rank] contains a term to weight the passed score
+ const int PassedDanger[RANK_NB] = { 0, 0, 0, 2, 7, 12, 19 };
+
+ // KingProtector[PieceType-2] contains a penalty according to distance from king
+ const Score KingProtector[] = { S(3, 5), S(4, 3), S(3, 0), S(1, -1) };
+
+ // Assorted bonuses and penalties
+ const Score BishopPawns = S( 8, 12);
+ const Score CloseEnemies = S( 7, 0);
+ const Score Hanging = S( 52, 30);
+ const Score HinderPassedPawn = S( 8, 1);
+ const Score LongRangedBishop = S( 22, 0);
+ const Score MinorBehindPawn = S( 16, 0);
+ const Score PawnlessFlank = S( 20, 80);
+ const Score RookOnPawn = S( 8, 24);
+ const Score ThreatByPawnPush = S( 47, 26);
+ const Score ThreatByRank = S( 16, 3);
+ const Score ThreatBySafePawn = S(175,168);
+ const Score ThreatOnQueen = S( 42, 21);
+ const Score TrappedBishopA1H1 = S( 50, 50);
+ const Score TrappedRook = S( 92, 0);
+ const Score WeakQueen = S( 50, 10);
+ const Score WeakUnopposedPawn = S( 5, 25);
+
+#undef S
+
+ // Evaluation class computes and stores attacks tables and other working data
+ template<Tracing T>
+ class Evaluation {
+
+ public:
+ Evaluation() = delete;
+ explicit Evaluation(const Position& p) : pos(p) {}
+ Evaluation& operator=(const Evaluation&) = delete;
+ Value value();
+
+ private:
+ template<Color Us> void initialize();
+ template<Color Us, PieceType Pt> Score pieces();
+ template<Color Us> Score king() const;
+ template<Color Us> Score threats() const;
+ template<Color Us> Score passed() const;
+ template<Color Us> Score space() const;
+ ScaleFactor scale_factor(Value eg) const;
+ Score initiative(Value eg) const;
+
+ const Position& pos;
+ Material::Entry* me;
+ Pawns::Entry* pe;
+ Bitboard mobilityArea[COLOR_NB];
+ Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
- // KingAttackWeights[PieceType] contains king attack weights by piece type
- const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 78, 56, 45, 11 };
+ // attackedBy[color][piece type] is a bitboard representing all squares
+ // attacked by a given color and piece type. Special "piece types" which
+ // are also calculated are QUEEN_DIAGONAL and ALL_PIECES.
+ Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
+
+ // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
+ // possibly via x-ray or by one pawn and one piece. Diagonal x-ray through
+ // pawn or squares attacked by 2 pawns are not explicitly added.
+ Bitboard attackedBy2[COLOR_NB];
+
+ // kingRing[color] are the squares adjacent to the king, plus (only for a
+ // king on its first rank) the squares two ranks in front. For instance,
+ // if black's king is on g8, kingRing[BLACK] is f8, h8, f7, g7, h7, f6, g6
+ // and h6. It is set to 0 when king safety evaluation is skipped.
+ Bitboard kingRing[COLOR_NB];
+
+ // kingAttackersCount[color] is the number of pieces of the given color
+ // which attack a square in the kingRing of the enemy king.
+ int kingAttackersCount[COLOR_NB];
+
+ // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
+ // given color which attack a square in the kingRing of the enemy king. The
+ // weights of the individual piece types are given by the elements in the
+ // KingAttackWeights array.
+ int kingAttackersWeight[COLOR_NB];
+
+ // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
+ // color to squares directly adjacent to the enemy king. Pieces which attack
+ // more than one square are counted multiple times. For instance, if there is
+ // a white knight on g5 and black's king is on g8, this white knight adds 2
+ // to kingAdjacentZoneAttacksCount[WHITE].
+ int kingAdjacentZoneAttacksCount[COLOR_NB];
+ };
- // Find the attacked squares which are defended only by the king...
- undefended = ei.attackedBy[Them][ALL_PIECES]
- & ei.attackedBy[Us][KING]
- & ~ei.attackedBy2[Us];
-
- // ... and those which are not defended at all in the larger king ring
- b = ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES]
- & ei.kingRing[Us] & ~pos.pieces(Them);
-
- // Initialize the 'kingDanger' variable, which will be transformed
- // later into a king danger score. 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 and the quality of
- // the pawn shelter (current 'score' value).
- kingDanger = std::min(807, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
- + 101 * ei.kingAdjacentZoneAttacksCount[Them]
- + 235 * popcount(undefended)
- + 134 * (popcount(b) + !!ei.pinnedPieces[Us])
- - 717 * !pos.count<QUEEN>(Them)
- - 7 * mg_value(score) / 5 - 5;
-
- // Analyse the enemy's safe queen contact checks. Firstly, find the
- // undefended squares around the king reachable by the enemy queen...
- b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
-
- // ...and keep squares supported by another enemy piece
- kingDanger += QueenContactCheck * popcount(b & ei.attackedBy2[Them]);
-
- // Analyse the safe enemy's checks which are possible on next move...
- safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));
-
- // ... and some other potential checks, only requiring the square to be
- // safe from pawn-attacks, and not being occupied by a blocked pawn.
- other = ~( ei.attackedBy[Us][PAWN]
- | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
-
- b1 = pos.attacks_from<ROOK >(ksq);
- b2 = pos.attacks_from<BISHOP>(ksq);
-
- // Enemy queen safe checks
- if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe)
- kingDanger += QueenCheck;
-
- // For other pieces, also consider the square safe if attacked twice,
- // and only defended by a queen.
- safe |= ei.attackedBy2[Them]
- & ~(ei.attackedBy2[Us] | pos.pieces(Them))
- & ei.attackedBy[Us][QUEEN];
-
- // Enemy rooks safe and other checks
- if (b1 & ei.attackedBy[Them][ROOK] & safe)
- kingDanger += RookCheck;
+ int kingDanger = unsafeChecks = 0;
- // Evaluate all pieces but king and pawns
- score += evaluate_pieces<DoTrace>(pos, ei, mobility, mobilityArea);
- score += mobility[WHITE] - mobility[BLACK];
-
- // Evaluate kings after all other pieces because we need full attack
- // information when computing the king safety evaluation.
- score += evaluate_king<WHITE, DoTrace>(pos, ei)
- - evaluate_king<BLACK, DoTrace>(pos, ei);
-
- // Evaluate tactical threats, we need full attack information including king
- score += evaluate_threats<WHITE, DoTrace>(pos, ei)
- - evaluate_threats<BLACK, DoTrace>(pos, ei);
-
- // Evaluate passed pawns, we need full attack information including king
- score += evaluate_passed_pawns<WHITE, DoTrace>(pos, ei)
- - evaluate_passed_pawns<BLACK, DoTrace>(pos, ei);
-
- // Evaluate space for both sides, only during opening
- if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
- score += evaluate_space<WHITE>(pos, ei)
- - evaluate_space<BLACK>(pos, ei);
-
- // Evaluate position potential for the winning side
- score += evaluate_initiative(pos, ei.pi->pawn_asymmetry(), eg_value(score));
-
- // Evaluate scale factor for the winning side
- ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
-
- // Interpolate between a middlegame and a (scaled by 'sf') endgame score
- Value v = mg_value(score) * int(ei.me->game_phase())
- + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
-
- v /= int(PHASE_MIDGAME);
-
- // In case of tracing add all remaining individual evaluation terms
- if (DoTrace)
- {
- Trace::add(MATERIAL, pos.psq_score());
- Trace::add(IMBALANCE, ei.me->imbalance());
- Trace::add(PAWN, ei.pi->pawns_score());
- Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
- if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
- Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
- , evaluate_space<BLACK>(pos, ei));
- Trace::add(TOTAL, score);
+ score += initiative(eg_value(score));
+
+ // Interpolate between a middlegame and a (scaled by 'sf') endgame score
+ ScaleFactor sf = scale_factor(eg_value(score));
+ v = mg_value(score) * int(me->game_phase())
+ + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
+
+ v /= int(PHASE_MIDGAME);
+
+ // In case of tracing add all remaining individual evaluation terms
+ if (T)
+ {
+ Trace::add(MATERIAL, pos.psq_score());
+ Trace::add(IMBALANCE, me->imbalance());
+ Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
+ Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
+ Trace::add(TOTAL, score);
+ }
+
+ return (pos.side_to_move() == WHITE ? v : -v) // Side to move point of view
+ + Eval::Tempo;
- << " Eval term | White | Black | Total \n"
- << " | MG EG | MG EG | MG EG \n"
- << "----------------+-------------+-------------+-------------\n"
- << " Material | " << Term(MATERIAL)
- << " Imbalance | " << Term(IMBALANCE)
- << " Pawns | " << Term(PAWN)
- << " Knights | " << Term(KNIGHT)
- << " Bishop | " << Term(BISHOP)
- << " Rooks | " << Term(ROOK)
- << " Queens | " << Term(QUEEN)
- << " Mobility | " << Term(MOBILITY)
- << " King safety | " << Term(KING)
- << " Threats | " << Term(THREAT)
- << " Passed pawns | " << Term(PASSED)
- << " Space | " << Term(SPACE)
- << "----------------+-------------+-------------+-------------\n"
- << " Total | " << Term(TOTAL);
-
- ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
+ << " Term | White | Black | Total \n"
+ << " | MG EG | MG EG | MG EG \n"
+ << " ------------+-------------+-------------+------------\n"
+ << " Material | " << Term(MATERIAL)
+ << " Imbalance | " << Term(IMBALANCE)
+ << " Initiative | " << Term(INITIATIVE)
+ << " Pawns | " << Term(PAWN)
+ << " Knights | " << Term(KNIGHT)
+ << " Bishops | " << Term(BISHOP)
+ << " Rooks | " << Term(ROOK)
+ << " Queens | " << Term(QUEEN)
+ << " Mobility | " << Term(MOBILITY)
+ << " King safety | " << Term(KING)
+ << " Threats | " << Term(THREAT)
+ << " Passed | " << Term(PASSED)
+ << " Space | " << Term(SPACE)
+ << " ------------+-------------+-------------+------------\n"
+ << " Total | " << Term(TOTAL);
+
+ ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";