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