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