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