rename shift variables.
[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.pinned_pieces(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 pinners;
396             if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, pinners))
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;
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
468         kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
469                      + 102 * kingAdjacentZoneAttacksCount[Them]
470                      + 191 * popcount(kingRing[Us] & weak)
471                      + 143 * popcount(pos.pinned_pieces(Us) | unsafeChecks)
472                      - 848 * !pos.count<QUEEN>(Them)
473                      -   9 * mg_value(score) / 8
474                      +  40;
475
476         // Transform the kingDanger units into a Score, and subtract it from the evaluation
477         if (kingDanger > 0)
478         {
479             int mobilityDanger = mg_value(mobility[Them] - mobility[Us]);
480             kingDanger = std::max(0, kingDanger + mobilityDanger);
481             score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
482         }
483     }
484     // Penalty when our king is on a pawnless flank
485     if (!(pos.pieces(PAWN) & KingFlank[file_of(ksq)]))
486         score -= PawnlessFlank;
487
488     // King tropism: firstly, find attacked squares in our king flank
489     b = attackedBy[Them][ALL_PIECES] & KingFlank[file_of(ksq)] & Camp;
490
491     assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
492     assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
493
494     // Secondly, add the squares which are attacked twice in that flank and
495     // which are not defended by our pawns.
496     b =  (Us == WHITE ? b << 4 : b >> 4)
497        | (b & attackedBy2[Them] & ~attackedBy[Us][PAWN]);
498
499     score -= CloseEnemies * popcount(b);
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 = pos.pawn_attacks<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 =   pos.pawn_attacks<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     if (T)
600         Trace::add(THREAT, Us, score);
601
602     return score;
603   }
604
605   // Evaluation::passed() evaluates the passed pawns and candidate passed
606   // pawns of the given color.
607
608   template<Tracing T> template<Color Us>
609   Score Evaluation<T>::passed() const {
610
611     const Color     Them = (Us == WHITE ? BLACK : WHITE);
612     const Direction Up   = (Us == WHITE ? NORTH : SOUTH);
613
614     auto king_proximity = [&](Color c, Square s) {
615       return std::min(distance(pos.square<KING>(c), s), 5);
616     };
617
618     Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
619     Score score = SCORE_ZERO;
620
621     b = pe->passed_pawns(Us);
622
623     while (b)
624     {
625         Square s = pop_lsb(&b);
626
627         assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
628
629         bb = forward_file_bb(Us, s) & (attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
630         score -= HinderPassedPawn * popcount(bb);
631
632         int r = relative_rank(Us, s);
633         int w = PassedDanger[r];
634
635         Score bonus = PassedRank[r];
636
637         if (w)
638         {
639             Square blockSq = s + Up;
640
641             // Adjust bonus based on the king's proximity
642             bonus += make_score(0, (  king_proximity(Them, blockSq) * 5
643                                     - king_proximity(Us,   blockSq) * 2) * w);
644
645             // If blockSq is not the queening square then consider also a second push
646             if (r != RANK_7)
647                 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
648
649             // If the pawn is free to advance, then increase the bonus
650             if (pos.empty(blockSq))
651             {
652                 // If there is a rook or queen attacking/defending the pawn from behind,
653                 // consider all the squaresToQueen. Otherwise consider only the squares
654                 // in the pawn's path attacked or occupied by the enemy.
655                 defendedSquares = unsafeSquares = squaresToQueen = forward_file_bb(Us, s);
656
657                 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
658
659                 if (!(pos.pieces(Us) & bb))
660                     defendedSquares &= attackedBy[Us][ALL_PIECES];
661
662                 if (!(pos.pieces(Them) & bb))
663                     unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
664
665                 // If there aren't any enemy attacks, assign a big bonus. Otherwise
666                 // assign a smaller bonus if the block square isn't attacked.
667                 int k = !unsafeSquares ? 20 : !(unsafeSquares & blockSq) ? 9 : 0;
668
669                 // If the path to the queen is fully defended, assign a big bonus.
670                 // Otherwise assign a smaller bonus if the block square is defended.
671                 if (defendedSquares == squaresToQueen)
672                     k += 6;
673
674                 else if (defendedSquares & blockSq)
675                     k += 4;
676
677                 bonus += make_score(k * w, k * w);
678             }
679             else if (pos.pieces(Us) & blockSq)
680                 bonus += make_score(w + r * 2, w + r * 2);
681         } // rr != 0
682
683         // Scale down bonus for candidate passers which need more than one
684         // pawn push to become passed or have a pawn in front of them.
685         if (   !pos.pawn_passed(Us, s + Up)
686             || (pos.pieces(PAWN) & forward_file_bb(Us, s)))
687             bonus = bonus / 2;
688
689         score += bonus + PassedFile[file_of(s)];
690     }
691
692     if (T)
693         Trace::add(PASSED, Us, score);
694
695     return score;
696   }
697
698
699   // Evaluation::space() computes the space evaluation for a given side. The
700   // space evaluation is a simple bonus based on the number of safe squares
701   // available for minor pieces on the central four files on ranks 2--4. Safe
702   // squares one, two or three squares behind a friendly pawn are counted
703   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
704   // improve play on game opening.
705
706   template<Tracing T> template<Color Us>
707   Score Evaluation<T>::space() const {
708
709     const Color Them = (Us == WHITE ? BLACK : WHITE);
710     const Bitboard SpaceMask =
711       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
712                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
713
714     if (pos.non_pawn_material() < SpaceThreshold)
715         return SCORE_ZERO;
716
717     // Find the safe squares for our pieces inside the area defined by
718     // SpaceMask. A square is unsafe if it is attacked by an enemy
719     // pawn, or if it is undefended and attacked by an enemy piece.
720     Bitboard safe =   SpaceMask
721                    & ~pos.pieces(Us, PAWN)
722                    & ~attackedBy[Them][PAWN]
723                    & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
724
725     // Find all squares which are at most three squares behind some friendly pawn
726     Bitboard behind = pos.pieces(Us, PAWN);
727     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
728     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
729
730     // Since SpaceMask[Us] is fully on our half of the board...
731     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
732
733     // ...count safe + (behind & safe) with a single popcount.
734     int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
735     int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
736     Score score = make_score(bonus * weight * weight / 16, 0);
737
738     if (T)
739         Trace::add(SPACE, Us, score);
740
741     return score;
742   }
743
744
745   // Evaluation::initiative() computes the initiative correction value
746   // for the position. It is a second order bonus/malus based on the
747   // known attacking/defending status of the players.
748
749   template<Tracing T>
750   Score Evaluation<T>::initiative(Value eg) const {
751
752     int outflanking =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
753                      - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
754
755     bool pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
756                             && (pos.pieces(PAWN) & KingSide);
757
758     // Compute the initiative bonus for the attacking side
759     int complexity =   8 * outflanking
760                     +  8 * pe->pawn_asymmetry()
761                     + 12 * pos.count<PAWN>()
762                     + 16 * pawnsOnBothFlanks
763                     -136 ;
764
765     // Now apply the bonus: note that we find the attacking side by extracting
766     // the sign of the endgame value, and that we carefully cap the bonus so
767     // that the endgame score will never change sign after the bonus.
768     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
769
770     if (T)
771         Trace::add(INITIATIVE, make_score(0, v));
772
773     return make_score(0, v);
774   }
775
776
777   // Evaluation::scale_factor() computes the scale factor for the winning side
778
779   template<Tracing T>
780   ScaleFactor Evaluation<T>::scale_factor(Value eg) const {
781
782     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
783     int sf = me->scale_factor(pos, strongSide);
784
785     // If we don't already have an unusual scale factor, check for certain
786     // types of endgames, and use a lower scale for those.
787     if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
788     {
789         if (pos.opposite_bishops())
790         {
791             // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
792             // is almost a draw, in case of KBP vs KB, it is even more a draw.
793             if (   pos.non_pawn_material(WHITE) == BishopValueMg
794                 && pos.non_pawn_material(BLACK) == BishopValueMg)
795                 sf = more_than_one(pos.pieces(PAWN)) ? 31 : 9;
796
797             // Endgame with opposite-colored bishops, but also other pieces. Still
798             // a bit drawish, but not as drawish as with only the two bishops.
799             else
800                 sf = 46;
801         }
802         // Endings where weaker side can place his king in front of the enemy's
803         // pawns are drawish.
804         else if (    abs(eg) <= BishopValueEg
805                  &&  pos.count<PAWN>(strongSide) <= 2
806                  && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
807             sf = 37 + 7 * pos.count<PAWN>(strongSide);
808     }
809
810     return ScaleFactor(sf);
811   }
812
813
814   // Evaluation::value() is the main function of the class. It computes the various
815   // parts of the evaluation and returns the value of the position from the point
816   // of view of the side to move.
817
818   template<Tracing T>
819   Value Evaluation<T>::value() {
820
821     assert(!pos.checkers());
822
823     // Probe the material hash table
824     me = Material::probe(pos);
825
826     // If we have a specialized evaluation function for the current material
827     // configuration, call it and return.
828     if (me->specialized_eval_exists())
829         return me->evaluate(pos);
830
831     // Initialize score by reading the incrementally updated scores included in
832     // the position object (material + piece square tables) and the material
833     // imbalance. Score is computed internally from the white point of view.
834     Score score = pos.psq_score() + me->imbalance() + Eval::Contempt;
835
836     // Probe the pawn hash table
837     pe = Pawns::probe(pos);
838     score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
839
840     // Early exit if score is high
841     Value v = (mg_value(score) + eg_value(score)) / 2;
842     if (abs(v) > LazyThreshold)
843        return pos.side_to_move() == WHITE ? v : -v;
844
845     // Main evaluation begins here
846
847     initialize<WHITE>();
848     initialize<BLACK>();
849
850     // Pieces should be evaluated first (populate attack tables)
851     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
852             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
853             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()
854             + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
855
856     score += mobility[WHITE] - mobility[BLACK];
857
858     score +=  king<   WHITE>() - king<   BLACK>()
859             + threats<WHITE>() - threats<BLACK>()
860             + passed< WHITE>() - passed< BLACK>()
861             + space<  WHITE>() - space<  BLACK>();
862
863     score += initiative(eg_value(score));
864
865     // Interpolate between a middlegame and a (scaled by 'sf') endgame score
866     ScaleFactor sf = scale_factor(eg_value(score));
867     v =  mg_value(score) * int(me->game_phase())
868        + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
869
870     v /= int(PHASE_MIDGAME);
871
872     // In case of tracing add all remaining individual evaluation terms
873     if (T)
874     {
875         Trace::add(MATERIAL, pos.psq_score());
876         Trace::add(IMBALANCE, me->imbalance());
877         Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
878         Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
879         Trace::add(TOTAL, score);
880     }
881
882     return pos.side_to_move() == WHITE ? v : -v; // Side to move point of view
883   }
884
885 } // namespace
886
887
888 /// evaluate() is the evaluator for the outer world. It returns a static
889 /// evaluation of the position from the point of view of the side to move.
890
891 Value Eval::evaluate(const Position& pos) {
892   return Evaluation<NO_TRACE>(pos).value() + Eval::Tempo;
893 }
894
895
896 /// trace() is like evaluate(), but instead of returning a value, it returns
897 /// a string (suitable for outputting to stdout) that contains the detailed
898 /// descriptions and values of each evaluation term. Useful for debugging.
899
900 std::string Eval::trace(const Position& pos) {
901
902   std::memset(scores, 0, sizeof(scores));
903
904   Eval::Contempt = SCORE_ZERO; // Reset any dynamic contempt
905
906   Value v = Evaluation<TRACE>(pos).value() + Eval::Tempo;
907
908   v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view
909
910   std::stringstream ss;
911   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
912      << "     Term    |    White    |    Black    |    Total   \n"
913      << "             |   MG    EG  |   MG    EG  |   MG    EG \n"
914      << " ------------+-------------+-------------+------------\n"
915      << "    Material | " << Term(MATERIAL)
916      << "   Imbalance | " << Term(IMBALANCE)
917      << "  Initiative | " << Term(INITIATIVE)
918      << "       Pawns | " << Term(PAWN)
919      << "     Knights | " << Term(KNIGHT)
920      << "     Bishops | " << Term(BISHOP)
921      << "       Rooks | " << Term(ROOK)
922      << "      Queens | " << Term(QUEEN)
923      << "    Mobility | " << Term(MOBILITY)
924      << " King safety | " << Term(KING)
925      << "     Threats | " << Term(THREAT)
926      << "      Passed | " << Term(PASSED)
927      << "       Space | " << Term(SPACE)
928      << " ------------+-------------+-------------+------------\n"
929      << "       Total | " << Term(TOTAL);
930
931   ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";
932
933   return ss.str();
934 }