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