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