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