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