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