A combo of parameters tweaks
[stockfish] / src / evaluate.cpp
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4   Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5   Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
6
7   Stockfish is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation, either version 3 of the License, or
10   (at your option) any later version.
11
12   Stockfish is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include <algorithm>
22 #include <cassert>
23 #include <cstring>   // For std::memset
24 #include <iomanip>
25 #include <sstream>
26
27 #include "bitboard.h"
28 #include "evaluate.h"
29 #include "material.h"
30 #include "pawns.h"
31 #include "thread.h"
32
33 namespace Trace {
34
35   enum Tracing { NO_TRACE, TRACE };
36
37   enum Term { // The first 8 entries are reserved for PieceType
38     MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, INITIATIVE, TOTAL, TERM_NB
39   };
40
41   Score scores[TERM_NB][COLOR_NB];
42
43   double to_cp(Value v) { return double(v) / PawnValueEg; }
44
45   void add(int idx, Color c, Score s) {
46     scores[idx][c] = s;
47   }
48
49   void add(int idx, Score w, Score b = SCORE_ZERO) {
50     scores[idx][WHITE] = w;
51     scores[idx][BLACK] = b;
52   }
53
54   std::ostream& operator<<(std::ostream& os, Score s) {
55     os << std::setw(5) << to_cp(mg_value(s)) << " "
56        << std::setw(5) << to_cp(eg_value(s));
57     return os;
58   }
59
60   std::ostream& operator<<(std::ostream& os, Term t) {
61
62     if (t == MATERIAL || t == IMBALANCE || t == INITIATIVE || t == TOTAL)
63         os << " ----  ----"    << " | " << " ----  ----";
64     else
65         os << scores[t][WHITE] << " | " << scores[t][BLACK];
66
67     os << " | " << scores[t][WHITE] - scores[t][BLACK] << "\n";
68     return os;
69   }
70 }
71
72 using namespace Trace;
73
74 namespace {
75
76   // Threshold for lazy and space evaluation
77   constexpr Value LazyThreshold  = Value(1400);
78   constexpr Value SpaceThreshold = Value(12222);
79
80   // KingAttackWeights[PieceType] contains king attack weights by piece type
81   constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 81, 52, 44, 10 };
82
83   // Penalties for enemy's safe checks
84   constexpr int QueenSafeCheck  = 772;
85   constexpr int RookSafeCheck   = 1084;
86   constexpr int BishopSafeCheck = 645;
87   constexpr int KnightSafeCheck = 792;
88
89 #define S(mg, eg) make_score(mg, eg)
90
91   // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
92   // indexed by piece type and number of attacked squares in the mobility area.
93   constexpr Score MobilityBonus[][32] = {
94     { S(-62,-81), S(-53,-56), S(-12,-30), S( -4,-14), S(  3,  8), S( 13, 15), // Knight
95       S( 22, 23), S( 28, 27), S( 33, 33) },
96     { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishop
97       S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86),
98       S( 91, 88), S( 98, 97) },
99     { S(-60,-78), S(-20,-17), S(  2, 23), S(  3, 39), S(  3, 70), S( 11, 99), // Rook
100       S( 22,103), S( 31,121), S( 40,134), S( 40,139), S( 41,158), S( 48,164),
101       S( 57,168), S( 57,169), S( 62,172) },
102     { S(-34,-36), S(-15,-21), S(-10, -1), S(-10, 22), S( 20, 41), S( 23, 56), // Queen
103       S( 23, 59), S( 35, 75), S( 38, 78), S( 53, 96), S( 64, 96), S( 65,100),
104       S( 65,121), S( 66,127), S( 67,131), S( 67,133), S( 72,136), S( 72,141),
105       S( 77,147), S( 79,150), S( 93,151), S(108,168), S(108,168), S(108,171),
106       S(110,182), S(114,182), S(114,192), S(116,219) }
107   };
108
109   // RookOnFile[semiopen/open] contains bonuses for each rook when there is
110   // no (friendly) pawn on the rook file.
111   constexpr Score RookOnFile[] = { S(19, 7), S(48, 29) };
112
113   // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
114   // which piece type attacks which one. Attacks on lesser pieces which are
115   // pawn-defended are not considered.
116   constexpr Score ThreatByMinor[PIECE_TYPE_NB] = {
117     S(0, 0), S(5, 32), S(57, 41), S(77, 56), S(88, 119), S(79, 161)
118   };
119
120   constexpr Score ThreatByRook[PIECE_TYPE_NB] = {
121     S(0, 0), S(3, 46), S(37, 68), S(42, 60), S(0, 38), S(58, 41)
122   };
123
124   // PassedRank[Rank] contains a bonus according to the rank of a passed pawn
125   constexpr Score PassedRank[RANK_NB] = {
126     S(0, 0), S(10, 28), S(17, 33), S(15, 41), S(62, 72), S(168, 177), S(276, 260)
127   };
128
129   // Assorted bonuses and penalties
130   constexpr Score BishopPawns         = S(  3,  7);
131   constexpr Score BishopXRayPawns     = S(  4,  5);
132   constexpr Score CorneredBishop      = S( 50, 50);
133   constexpr Score FlankAttacks        = S(  8,  0);
134   constexpr Score Hanging             = S( 69, 36);
135   constexpr Score BishopKingProtector = S(  6,  9);
136   constexpr Score KnightKingProtector = S(  8,  9);
137   constexpr Score KnightOnQueen       = S( 16, 11);
138   constexpr Score LongDiagonalBishop  = S( 45,  0);
139   constexpr Score MinorBehindPawn     = S( 18,  3);
140   constexpr Score KnightOutpost       = S( 56, 36);
141   constexpr Score BishopOutpost       = S( 30, 23);
142   constexpr Score ReachableOutpost    = S( 31, 22);
143   constexpr Score PassedFile          = S( 11,  8);
144   constexpr Score PawnlessFlank       = S( 17, 95);
145   constexpr Score RestrictedPiece     = S(  7,  7);
146   constexpr Score RookOnQueenFile     = S(  5,  9);
147   constexpr Score SliderOnQueen       = S( 59, 18);
148   constexpr Score ThreatByKing        = S( 24, 89);
149   constexpr Score ThreatByPawnPush    = S( 48, 39);
150   constexpr Score ThreatBySafePawn    = S(173, 94);
151   constexpr Score TrappedRook         = S( 55, 13);
152   constexpr Score WeakQueen           = S( 51, 14);
153   constexpr Score WeakQueenProtection = S( 15,  0);
154
155 #undef S
156
157   // Evaluation class computes and stores attacks tables and other working data
158   template<Tracing T>
159   class Evaluation {
160
161   public:
162     Evaluation() = delete;
163     explicit Evaluation(const Position& p) : pos(p) {}
164     Evaluation& operator=(const Evaluation&) = delete;
165     Value value();
166
167   private:
168     template<Color Us> void initialize();
169     template<Color Us, PieceType Pt> Score pieces();
170     template<Color Us> Score king() const;
171     template<Color Us> Score threats() const;
172     template<Color Us> Score passed() const;
173     template<Color Us> Score space() const;
174     ScaleFactor scale_factor(Value eg) const;
175     Score initiative(Score score) const;
176
177     const Position& pos;
178     Material::Entry* me;
179     Pawns::Entry* pe;
180     Bitboard mobilityArea[COLOR_NB];
181     Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
182
183     // attackedBy[color][piece type] is a bitboard representing all squares
184     // attacked by a given color and piece type. Special "piece types" which
185     // is also calculated is ALL_PIECES.
186     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
187
188     // attackedBy2[color] are the squares attacked by at least 2 units of a given
189     // color, including x-rays. But diagonal x-rays through pawns are not computed.
190     Bitboard attackedBy2[COLOR_NB];
191
192     // kingRing[color] are the squares adjacent to the king plus some other
193     // very near squares, depending on king position.
194     Bitboard kingRing[COLOR_NB];
195
196     // kingAttackersCount[color] is the number of pieces of the given color
197     // which attack a square in the kingRing of the enemy king.
198     int kingAttackersCount[COLOR_NB];
199
200     // kingAttackersWeight[color] is the sum of the "weights" of the pieces of
201     // the given color which attack a square in the kingRing of the enemy king.
202     // The weights of the individual piece types are given by the elements in
203     // the KingAttackWeights array.
204     int kingAttackersWeight[COLOR_NB];
205
206     // kingAttacksCount[color] is the number of attacks by the given color to
207     // squares directly adjacent to the enemy king. Pieces which attack more
208     // than one square are counted multiple times. For instance, if there is
209     // a white knight on g5 and black's king is on g8, this white knight adds 2
210     // to kingAttacksCount[WHITE].
211     int kingAttacksCount[COLOR_NB];
212   };
213
214
215   // Evaluation::initialize() computes king and pawn attacks, and the king ring
216   // bitboard for a given color. This is done at the beginning of the evaluation.
217   template<Tracing T> template<Color Us>
218   void Evaluation<T>::initialize() {
219
220     constexpr Color     Them = ~Us;
221     constexpr Direction Up   = pawn_push(Us);
222     constexpr Direction Down = -Up;
223     constexpr Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB : Rank7BB | Rank6BB);
224
225     const Square ksq = pos.square<KING>(Us);
226
227     Bitboard dblAttackByPawn = pawn_double_attacks_bb<Us>(pos.pieces(Us, PAWN));
228
229     // Find our pawns that are blocked or on the first two ranks
230     Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | LowRanks);
231
232     // Squares occupied by those pawns, by our king or queen, by blockers to attacks on our king
233     // or controlled by enemy pawns are excluded from the mobility area.
234     mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pos.blockers_for_king(Us) | pe->pawn_attacks(Them));
235
236     // Initialize attackedBy[] for king and pawns
237     attackedBy[Us][KING] = pos.attacks_from<KING>(ksq);
238     attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
239     attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN];
240     attackedBy2[Us] = dblAttackByPawn | (attackedBy[Us][KING] & attackedBy[Us][PAWN]);
241
242     // Init our king safety tables
243     Square s = make_square(Utility::clamp(file_of(ksq), FILE_B, FILE_G),
244                            Utility::clamp(rank_of(ksq), RANK_2, RANK_7));
245     kingRing[Us] = PseudoAttacks[KING][s] | s;
246
247     kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them));
248     kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
249
250     // Remove from kingRing[] the squares defended by two pawns
251     kingRing[Us] &= ~dblAttackByPawn;
252   }
253
254
255   // Evaluation::pieces() scores pieces of a given color and type
256   template<Tracing T> template<Color Us, PieceType Pt>
257   Score Evaluation<T>::pieces() {
258
259     constexpr Color     Them = ~Us;
260     constexpr Direction Down = -pawn_push(Us);
261     constexpr Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
262                                                    : Rank5BB | Rank4BB | Rank3BB);
263     const Square* pl = pos.squares<Pt>(Us);
264
265     Bitboard b, bb;
266     Score score = SCORE_ZERO;
267
268     attackedBy[Us][Pt] = 0;
269
270     for (Square s = *pl; s != SQ_NONE; s = *++pl)
271     {
272         // Find attacked squares, including x-ray attacks for bishops and rooks
273         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
274           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
275                          : pos.attacks_from<Pt>(s);
276
277         if (pos.blockers_for_king(Us) & s)
278             b &= LineBB[pos.square<KING>(Us)][s];
279
280         attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
281         attackedBy[Us][Pt] |= b;
282         attackedBy[Us][ALL_PIECES] |= b;
283
284         if (b & kingRing[Them])
285         {
286             kingAttackersCount[Us]++;
287             kingAttackersWeight[Us] += KingAttackWeights[Pt];
288             kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
289         }
290
291         int mob = popcount(b & mobilityArea[Us]);
292
293         mobility[Us] += MobilityBonus[Pt - 2][mob];
294
295         if (Pt == BISHOP || Pt == KNIGHT)
296         {
297             // Bonus if piece is on an outpost square or can reach one
298             bb = OutpostRanks & attackedBy[Us][PAWN] & ~pe->pawn_attacks_span(Them);
299             if (bb & s)
300                 score += (Pt == KNIGHT) ? KnightOutpost : BishopOutpost;
301             else if (Pt == KNIGHT && bb & b & ~pos.pieces(Us))
302                 score += ReachableOutpost;
303
304             // Bonus for a knight or bishop shielded by pawn
305             if (shift<Down>(pos.pieces(PAWN)) & s)
306                 score += MinorBehindPawn;
307
308             // Penalty if the piece is far from the king
309             score -= (Pt == KNIGHT ? KnightKingProtector
310                                    : BishopKingProtector) * distance(pos.square<KING>(Us), s);
311
312             if (Pt == BISHOP)
313             {
314                 // Penalty according to number of pawns on the same color square as the
315                 // bishop, bigger when the center files are blocked with pawns and smaller
316                 // when the bishop is outside the pawn chain.
317                 Bitboard blocked = pos.pieces(Us, PAWN) & shift<Down>(pos.pieces());
318
319                 score -= BishopPawns * pos.pawns_on_same_color_squares(Us, s)
320                                      * (!(attackedBy[Us][PAWN] & s) + popcount(blocked & CenterFiles));
321
322                 // Penalty for all enemy pawns x-rayed
323                 score -= BishopXRayPawns * popcount(PseudoAttacks[BISHOP][s] & pos.pieces(Them, PAWN));
324
325                 // Bonus for bishop on a long diagonal which can "see" both center squares
326                 if (more_than_one(attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & Center))
327                     score += LongDiagonalBishop;
328
329                 // An important Chess960 pattern: a cornered bishop blocked by a friendly
330                 // pawn diagonally in front of it is a very serious problem, especially
331                 // when that pawn is also blocked.
332                 if (   pos.is_chess960()
333                     && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
334                 {
335                     Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
336                     if (pos.piece_on(s + d) == make_piece(Us, PAWN))
337                         score -= !pos.empty(s + d + pawn_push(Us))                ? CorneredBishop * 4
338                                 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
339                                                                                   : CorneredBishop;
340                 }
341             }
342         }
343
344         if (Pt == ROOK)
345         {
346             // Bonus for rook on the same file as a queen
347             if (file_bb(s) & pos.pieces(QUEEN))
348                 score += RookOnQueenFile;
349
350             // Bonus for rook on an open or semi-open file
351             if (pos.is_on_semiopen_file(Us, s))
352                 score += RookOnFile[pos.is_on_semiopen_file(Them, s)];
353
354             // Penalty when trapped by the king, even more if the king cannot castle
355             else if (mob <= 3)
356             {
357                 File kf = file_of(pos.square<KING>(Us));
358                 if ((kf < FILE_E) == (file_of(s) < kf))
359                     score -= TrappedRook * (1 + !pos.castling_rights(Us));
360             }
361         }
362
363         if (Pt == QUEEN)
364         {
365             // Penalty if any relative pin or discovered attack against the queen
366             Bitboard queenPinners;
367             if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners))
368                 score -= WeakQueen;
369         }
370     }
371     if (T)
372         Trace::add(Pt, Us, score);
373
374     return score;
375   }
376
377
378   // Evaluation::king() assigns bonuses and penalties to a king of a given color
379   template<Tracing T> template<Color Us>
380   Score Evaluation<T>::king() const {
381
382     constexpr Color    Them = ~Us;
383     constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
384                                            : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
385
386     Bitboard weak, b1, b2, b3, safe, unsafeChecks = 0;
387     Bitboard rookChecks, queenChecks, bishopChecks, knightChecks;
388     int kingDanger = 0;
389     const Square ksq = pos.square<KING>(Us);
390
391     // Init the score with king shelter and enemy pawns storm
392     Score score = pe->king_safety<Us>(pos);
393
394     // Attacked squares defended at most once by our queen or king
395     weak =  attackedBy[Them][ALL_PIECES]
396           & ~attackedBy2[Us]
397           & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]);
398
399     // Analyse the safe enemy's checks which are possible on next move
400     safe  = ~pos.pieces(Them);
401     safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
402
403     b1 = attacks_bb<ROOK  >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
404     b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
405
406     // Enemy rooks checks
407     rookChecks = b1 & safe & attackedBy[Them][ROOK];
408     if (rookChecks)
409         kingDanger += more_than_one(rookChecks) ? RookSafeCheck * 175/100
410                                                 : RookSafeCheck;
411     else
412         unsafeChecks |= b1 & attackedBy[Them][ROOK];
413
414     // Enemy queen safe checks: we count them only if they are from squares from
415     // which we can't give a rook check, because rook checks are more valuable.
416     queenChecks =  (b1 | b2)
417                  & attackedBy[Them][QUEEN]
418                  & safe
419                  & ~attackedBy[Us][QUEEN]
420                  & ~rookChecks;
421     if (queenChecks)
422         kingDanger += more_than_one(queenChecks) ? QueenSafeCheck * 145/100
423                                                  : QueenSafeCheck;
424
425     // Enemy bishops checks: we count them only if they are from squares from
426     // which we can't give a queen check, because queen checks are more valuable.
427     bishopChecks =  b2
428                   & attackedBy[Them][BISHOP]
429                   & safe
430                   & ~queenChecks;
431     if (bishopChecks)
432         kingDanger += more_than_one(bishopChecks) ? BishopSafeCheck * 3/2
433                                                   : BishopSafeCheck;
434     else
435         unsafeChecks |= b2 & attackedBy[Them][BISHOP];
436
437     // Enemy knights checks
438     knightChecks = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
439     if (knightChecks & safe)
440         kingDanger += more_than_one(knightChecks & safe) ? KnightSafeCheck * 162/100
441                                                          : KnightSafeCheck;
442     else
443         unsafeChecks |= knightChecks;
444
445     // Find the squares that opponent attacks in our king flank, the squares
446     // which they attack twice in that flank, and the squares that we defend.
447     b1 = attackedBy[Them][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
448     b2 = b1 & attackedBy2[Them];
449     b3 = attackedBy[Us][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
450
451     int kingFlankAttack = popcount(b1) + popcount(b2);
452     int kingFlankDefense = popcount(b3);
453
454     kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
455                  + 185 * popcount(kingRing[Us] & weak)
456                  + 148 * popcount(unsafeChecks)
457                  +  98 * popcount(pos.blockers_for_king(Us))
458                  +  69 * kingAttacksCount[Them]
459                  +   3 * kingFlankAttack * kingFlankAttack / 8
460                  +       mg_value(mobility[Them] - mobility[Us])
461                  - 873 * !pos.count<QUEEN>(Them)
462                  - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING])
463                  -   6 * mg_value(score) / 8
464                  -   4 * kingFlankDefense
465                  +  37;
466
467     // Transform the kingDanger units into a Score, and subtract it from the evaluation
468     if (kingDanger > 100)
469         score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
470
471     // Penalty when our king is on a pawnless flank
472     if (!(pos.pieces(PAWN) & KingFlank[file_of(ksq)]))
473         score -= PawnlessFlank;
474
475     // Penalty if king flank is under attack, potentially moving toward the king
476     score -= FlankAttacks * kingFlankAttack;
477
478     if (T)
479         Trace::add(KING, Us, score);
480
481     return score;
482   }
483
484
485   // Evaluation::threats() assigns bonuses according to the types of the
486   // attacking and the attacked pieces.
487   template<Tracing T> template<Color Us>
488   Score Evaluation<T>::threats() const {
489
490     constexpr Color     Them     = ~Us;
491     constexpr Direction Up       = pawn_push(Us);
492     constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
493
494     Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe;
495     Score score = SCORE_ZERO;
496
497     // Non-pawn enemies
498     nonPawnEnemies = pos.pieces(Them) & ~pos.pieces(PAWN);
499
500     // Squares strongly protected by the enemy, either because they defend the
501     // square with a pawn, or because they defend the square twice and we don't.
502     stronglyProtected =  attackedBy[Them][PAWN]
503                        | (attackedBy2[Them] & ~attackedBy2[Us]);
504
505     // Non-pawn enemies, strongly protected
506     defended = nonPawnEnemies & stronglyProtected;
507
508     // Enemies not strongly protected and under our attack
509     weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
510
511     // Bonus according to the kind of attacking pieces
512     if (defended | weak)
513     {
514         b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
515         while (b)
516             score += ThreatByMinor[type_of(pos.piece_on(pop_lsb(&b)))];
517
518         b = weak & attackedBy[Us][ROOK];
519         while (b)
520             score += ThreatByRook[type_of(pos.piece_on(pop_lsb(&b)))];
521
522         if (weak & attackedBy[Us][KING])
523             score += ThreatByKing;
524
525         b =  ~attackedBy[Them][ALL_PIECES]
526            | (nonPawnEnemies & attackedBy2[Us]);
527         score += Hanging * popcount(weak & b);
528
529         // Additional bonus if weak piece is only protected by a queen
530         score += WeakQueenProtection * popcount(weak & attackedBy[Them][QUEEN]);
531     }
532
533     // Bonus for restricting their piece moves
534     b =   attackedBy[Them][ALL_PIECES]
535        & ~stronglyProtected
536        &  attackedBy[Us][ALL_PIECES];
537     score += RestrictedPiece * popcount(b);
538
539     // Protected or unattacked squares
540     safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES];
541
542     // Bonus for attacking enemy pieces with our relatively safe pawns
543     b = pos.pieces(Us, PAWN) & safe;
544     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
545     score += ThreatBySafePawn * popcount(b);
546
547     // Find squares where our pawns can push on the next move
548     b  = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
549     b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
550
551     // Keep only the squares which are relatively safe
552     b &= ~attackedBy[Them][PAWN] & safe;
553
554     // Bonus for safe pawn threats on the next move
555     b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
556     score += ThreatByPawnPush * popcount(b);
557
558     // Bonus for threats on the next moves against enemy queen
559     if (pos.count<QUEEN>(Them) == 1)
560     {
561         Square s = pos.square<QUEEN>(Them);
562         safe = mobilityArea[Us] & ~stronglyProtected;
563
564         b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
565
566         score += KnightOnQueen * popcount(b & safe);
567
568         b =  (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
569            | (attackedBy[Us][ROOK  ] & pos.attacks_from<ROOK  >(s));
570
571         score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]);
572     }
573
574     if (T)
575         Trace::add(THREAT, Us, score);
576
577     return score;
578   }
579
580   // Evaluation::passed() evaluates the passed pawns and candidate passed
581   // pawns of the given color.
582
583   template<Tracing T> template<Color Us>
584   Score Evaluation<T>::passed() const {
585
586     constexpr Color     Them = ~Us;
587     constexpr Direction Up   = pawn_push(Us);
588     constexpr Direction Down = -Up;
589
590     auto king_proximity = [&](Color c, Square s) {
591       return std::min(distance(pos.square<KING>(c), s), 5);
592     };
593
594     Bitboard b, bb, squaresToQueen, unsafeSquares, blockedPassers, helpers;
595     Score score = SCORE_ZERO;
596
597     b = pe->passed_pawns(Us);
598
599     blockedPassers = b & shift<Down>(pos.pieces(Them, PAWN));
600     if (blockedPassers)
601     {
602         helpers =  shift<Up>(pos.pieces(Us, PAWN))
603                  & ~pos.pieces(Them)
604                  & (~attackedBy2[Them] | attackedBy[Us][ALL_PIECES]);
605
606         // Remove blocked candidate passers that don't have help to pass
607         b &=  ~blockedPassers
608             | shift<WEST>(helpers)
609             | shift<EAST>(helpers);
610     }
611
612     while (b)
613     {
614         Square s = pop_lsb(&b);
615
616         assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
617
618         int r = relative_rank(Us, s);
619
620         Score bonus = PassedRank[r];
621
622         if (r > RANK_3)
623         {
624             int w = 5 * r - 13;
625             Square blockSq = s + Up;
626
627             // Adjust bonus based on the king's proximity
628             bonus += make_score(0, (  (king_proximity(Them, blockSq) * 19) / 4
629                                      - king_proximity(Us,   blockSq) *  2) * w);
630
631             // If blockSq is not the queening square then consider also a second push
632             if (r != RANK_7)
633                 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
634
635             // If the pawn is free to advance, then increase the bonus
636             if (pos.empty(blockSq))
637             {
638                 squaresToQueen = forward_file_bb(Us, s);
639                 unsafeSquares = passed_pawn_span(Us, s);
640
641                 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN);
642
643                 if (!(pos.pieces(Them) & bb))
644                     unsafeSquares &= attackedBy[Them][ALL_PIECES];
645
646                 // If there are no enemy attacks on passed pawn span, assign a big bonus.
647                 // Otherwise assign a smaller bonus if the path to queen is not attacked
648                 // and even smaller bonus if it is attacked but block square is not.
649                 int k = !unsafeSquares                    ? 35 :
650                         !(unsafeSquares & squaresToQueen) ? 20 :
651                         !(unsafeSquares & blockSq)        ?  9 :
652                                                              0 ;
653
654                 // Assign a larger bonus if the block square is defended
655                 if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq))
656                     k += 5;
657
658                 bonus += make_score(k * w, k * w);
659             }
660         } // r > RANK_3
661
662         score += bonus - PassedFile * edge_distance(file_of(s));
663     }
664
665     if (T)
666         Trace::add(PASSED, Us, score);
667
668     return score;
669   }
670
671
672   // Evaluation::space() computes the space evaluation for a given side. The
673   // space evaluation is a simple bonus based on the number of safe squares
674   // available for minor pieces on the central four files on ranks 2--4. Safe
675   // squares one, two or three squares behind a friendly pawn are counted
676   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
677   // improve play on game opening.
678
679   template<Tracing T> template<Color Us>
680   Score Evaluation<T>::space() const {
681
682     if (pos.non_pawn_material() < SpaceThreshold)
683         return SCORE_ZERO;
684
685     constexpr Color Them     = ~Us;
686     constexpr Direction Down = -pawn_push(Us);
687     constexpr Bitboard SpaceMask =
688       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
689                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
690
691     // Find the available squares for our pieces inside the area defined by SpaceMask
692     Bitboard safe =   SpaceMask
693                    & ~pos.pieces(Us, PAWN)
694                    & ~attackedBy[Them][PAWN];
695
696     // Find all squares which are at most three squares behind some friendly pawn
697     Bitboard behind = pos.pieces(Us, PAWN);
698     behind |= shift<Down>(behind);
699     behind |= shift<Down+Down>(behind);
700
701     int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
702     int weight = pos.count<ALL_PIECES>(Us) - 3 + std::min(pe->blocked_count(), 9);
703     Score score = make_score(bonus * weight * weight / 16, 0);
704
705     if (T)
706         Trace::add(SPACE, Us, score);
707
708     return score;
709   }
710
711
712   // Evaluation::initiative() computes the initiative correction value
713   // for the position. It is a second order bonus/malus based on the
714   // known attacking/defending status of the players.
715
716   template<Tracing T>
717   Score Evaluation<T>::initiative(Score score) const {
718
719     int outflanking =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
720                      - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
721
722     bool pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
723                             && (pos.pieces(PAWN) & KingSide);
724
725     bool almostUnwinnable =   outflanking < 0
726                            && !pawnsOnBothFlanks;
727
728     bool infiltration = rank_of(pos.square<KING>(WHITE)) > RANK_4
729                      || rank_of(pos.square<KING>(BLACK)) < RANK_5;
730
731     // Compute the initiative bonus for the attacking side
732     int complexity =   9 * pe->passed_count()
733                     + 12 * pos.count<PAWN>()
734                     +  9 * outflanking
735                     + 21 * pawnsOnBothFlanks
736                     + 24 * infiltration
737                     + 51 * !pos.non_pawn_material()
738                     - 43 * almostUnwinnable
739                     -  2 * pos.rule50_count()
740                     -110 ;
741
742     Value mg = mg_value(score);
743     Value eg = eg_value(score);
744
745     // Now apply the bonus: note that we find the attacking side by extracting the
746     // sign of the midgame or endgame values, and that we carefully cap the bonus
747     // so that the midgame and endgame scores do not change sign after the bonus.
748     int u = ((mg > 0) - (mg < 0)) * Utility::clamp(complexity + 50, -abs(mg), 0);
749     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
750
751     if (T)
752         Trace::add(INITIATIVE, make_score(u, v));
753
754     return make_score(u, v);
755   }
756
757
758   // Evaluation::scale_factor() computes the scale factor for the winning side
759
760   template<Tracing T>
761   ScaleFactor Evaluation<T>::scale_factor(Value eg) const {
762
763     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
764     int sf = me->scale_factor(pos, strongSide);
765
766     // If scale is not already specific, scale down the endgame via general heuristics
767     if (sf == SCALE_FACTOR_NORMAL)
768     {
769         if (pos.opposite_bishops())
770         {
771             if (   pos.non_pawn_material(WHITE) == BishopValueMg
772                 && pos.non_pawn_material(BLACK) == BishopValueMg)
773                 sf = 18 + 4 * popcount(pe->passed_pawns(strongSide));
774             else
775                 sf = 22 + 3 * pos.count<ALL_PIECES>(strongSide);
776         }
777         else
778             sf = std::min(sf, 36 + 7 * pos.count<PAWN>(strongSide));
779     }
780
781     return ScaleFactor(sf);
782   }
783
784
785   // Evaluation::value() is the main function of the class. It computes the various
786   // parts of the evaluation and returns the value of the position from the point
787   // of view of the side to move.
788
789   template<Tracing T>
790   Value Evaluation<T>::value() {
791
792     assert(!pos.checkers());
793
794     // Probe the material hash table
795     me = Material::probe(pos);
796
797     // If we have a specialized evaluation function for the current material
798     // configuration, call it and return.
799     if (me->specialized_eval_exists())
800         return me->evaluate(pos);
801
802     // Initialize score by reading the incrementally updated scores included in
803     // the position object (material + piece square tables) and the material
804     // imbalance. Score is computed internally from the white point of view.
805     Score score = pos.psq_score() + me->imbalance() + pos.this_thread()->contempt;
806
807     // Probe the pawn hash table
808     pe = Pawns::probe(pos);
809     score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
810
811     // Early exit if score is high
812     Value v = (mg_value(score) + eg_value(score)) / 2;
813     if (abs(v) > LazyThreshold + pos.non_pawn_material() / 64)
814        return pos.side_to_move() == WHITE ? v : -v;
815
816     // Main evaluation begins here
817
818     initialize<WHITE>();
819     initialize<BLACK>();
820
821     // Pieces evaluated first (also populates attackedBy, attackedBy2).
822     // Note that the order of evaluation of the terms is left unspecified
823     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
824             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
825             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()
826             + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
827
828     score += mobility[WHITE] - mobility[BLACK];
829
830     // More complex interactions that require fully populated attack bitboards
831     score +=  king<   WHITE>() - king<   BLACK>()
832             + threats<WHITE>() - threats<BLACK>()
833             + passed< WHITE>() - passed< BLACK>()
834             + space<  WHITE>() - space<  BLACK>();
835
836     score += initiative(score);
837
838     // Interpolate between a middlegame and a (scaled by 'sf') endgame score
839     ScaleFactor sf = scale_factor(eg_value(score));
840     v =  mg_value(score) * int(me->game_phase())
841        + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
842
843     v /= PHASE_MIDGAME;
844
845     // In case of tracing add all remaining individual evaluation terms
846     if (T)
847     {
848         Trace::add(MATERIAL, pos.psq_score());
849         Trace::add(IMBALANCE, me->imbalance());
850         Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
851         Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
852         Trace::add(TOTAL, score);
853     }
854
855     // Side to move point of view
856     return (pos.side_to_move() == WHITE ? v : -v) + Tempo;
857   }
858
859 } // namespace
860
861
862 /// evaluate() is the evaluator for the outer world. It returns a static
863 /// evaluation of the position from the point of view of the side to move.
864
865 Value Eval::evaluate(const Position& pos) {
866   return Evaluation<NO_TRACE>(pos).value();
867 }
868
869
870 /// trace() is like evaluate(), but instead of returning a value, it returns
871 /// a string (suitable for outputting to stdout) that contains the detailed
872 /// descriptions and values of each evaluation term. Useful for debugging.
873
874 std::string Eval::trace(const Position& pos) {
875
876   if (pos.checkers())
877       return "Total evaluation: none (in check)";
878
879   std::memset(scores, 0, sizeof(scores));
880
881   pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt
882
883   Value v = Evaluation<TRACE>(pos).value();
884
885   v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view
886
887   std::stringstream ss;
888   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
889      << "     Term    |    White    |    Black    |    Total   \n"
890      << "             |   MG    EG  |   MG    EG  |   MG    EG \n"
891      << " ------------+-------------+-------------+------------\n"
892      << "    Material | " << Term(MATERIAL)
893      << "   Imbalance | " << Term(IMBALANCE)
894      << "       Pawns | " << Term(PAWN)
895      << "     Knights | " << Term(KNIGHT)
896      << "     Bishops | " << Term(BISHOP)
897      << "       Rooks | " << Term(ROOK)
898      << "      Queens | " << Term(QUEEN)
899      << "    Mobility | " << Term(MOBILITY)
900      << " King safety | " << Term(KING)
901      << "     Threats | " << Term(THREAT)
902      << "      Passed | " << Term(PASSED)
903      << "       Space | " << Term(SPACE)
904      << "  Initiative | " << Term(INITIATIVE)
905      << " ------------+-------------+-------------+------------\n"
906      << "       Total | " << Term(TOTAL);
907
908   ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";
909
910   return ss.str();
911 }