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