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