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