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