]> git.sesse.net Git - stockfish/blob - src/evaluate.cpp
Remove the Queen from the mobility area of minor pieces
[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     int mob;
304
305     attackedBy[Us][Pt] = 0;
306
307     while ((s = *pl++) != SQ_NONE)
308     {
309         // Find attacked squares, including x-ray attacks for bishops and rooks
310         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
311           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
312                          : pos.attacks_from<Pt>(s);
313
314         if (pos.blockers_for_king(Us) & s)
315             b &= LineBB[pos.square<KING>(Us)][s];
316
317         attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
318         attackedBy[Us][Pt] |= b;
319         attackedBy[Us][ALL_PIECES] |= b;
320
321         if (b & kingRing[Them])
322         {
323             kingAttackersCount[Us]++;
324             kingAttackersWeight[Us] += KingAttackWeights[Pt];
325             kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
326         }
327
328         mob = (Pt == KNIGHT || Pt == BISHOP) ? popcount(b & mobilityArea[Us] & ~pos.pieces(Us, QUEEN))
329                                              : popcount(b & mobilityArea[Us]);
330
331         mobility[Us] += MobilityBonus[Pt - 2][mob];
332
333         // Penalty if the piece is far from the king
334         score -= KingProtector[Pt - 2] * distance(s, pos.square<KING>(Us));
335
336         if (Pt == BISHOP || Pt == KNIGHT)
337         {
338             // Bonus if piece is on an outpost square or can reach one
339             bb = OutpostRanks & ~pe->pawn_attacks_span(Them);
340             if (bb & s)
341                 score += Outpost[Pt == BISHOP][bool(attackedBy[Us][PAWN] & s)] * 2;
342
343             else if (bb &= b & ~pos.pieces(Us))
344                 score += Outpost[Pt == BISHOP][bool(attackedBy[Us][PAWN] & bb)];
345
346             // Bonus when behind a pawn
347             if (    relative_rank(Us, s) < RANK_5
348                 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
349                 score += MinorBehindPawn;
350
351             if (Pt == BISHOP)
352             {
353                 // Penalty according to number of pawns on the same color square as the bishop
354                 score -= BishopPawns * pe->pawns_on_same_color_squares(Us, s);
355
356                 // Bonus for bishop on a long diagonal which can "see" both center squares
357                 if (more_than_one(Center & (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) | s)))
358                     score += LongDiagonalBishop;
359             }
360
361             // An important Chess960 pattern: A cornered bishop blocked by a friendly
362             // pawn diagonally in front of it is a very serious problem, especially
363             // when that pawn is also blocked.
364             if (   Pt == BISHOP
365                 && pos.is_chess960()
366                 && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
367             {
368                 Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
369                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
370                     score -= !pos.empty(s + d + pawn_push(Us))                ? CorneredBishop * 4
371                             : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
372                                                                               : CorneredBishop;
373             }
374         }
375
376         if (Pt == ROOK)
377         {
378             // Bonus for aligning rook with enemy pawns on the same rank/file
379             if (relative_rank(Us, s) >= RANK_5)
380                 score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
381
382             // Bonus for rook on an open or semi-open file
383             if (pe->semiopen_file(Us, file_of(s)))
384                 score += RookOnFile[bool(pe->semiopen_file(Them, file_of(s)))];
385
386             // Penalty when trapped by the king, even more if the king cannot castle
387             else if (mob <= 3)
388             {
389                 File kf = file_of(pos.square<KING>(Us));
390                 if ((kf < FILE_E) == (file_of(s) < kf))
391                     score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
392             }
393         }
394
395         if (Pt == QUEEN)
396         {
397             // Penalty if any relative pin or discovered attack against the queen
398             Bitboard queenPinners;
399             if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners))
400                 score -= WeakQueen;
401         }
402     }
403     if (T)
404         Trace::add(Pt, Us, score);
405
406     return score;
407   }
408
409
410   // Evaluation::king() assigns bonuses and penalties to a king of a given color
411   template<Tracing T> template<Color Us>
412   Score Evaluation<T>::king() const {
413
414     constexpr Color    Them = (Us == WHITE ? BLACK : WHITE);
415     constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
416                                            : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
417
418     const Square ksq = pos.square<KING>(Us);
419     Bitboard weak, b, b1, b2, safe, unsafeChecks, pinned;
420
421     // King shelter and enemy pawns storm
422     Score score = pe->king_safety<Us>(pos, ksq);
423
424     // Main king safety evaluation
425     if (kingAttackersCount[Them] > 1 - pos.count<QUEEN>(Them))
426     {
427         int kingDanger = 0;
428         unsafeChecks = 0;
429
430         // Attacked squares defended at most once by our queen or king
431         weak =  attackedBy[Them][ALL_PIECES]
432               & ~attackedBy2[Us]
433               & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]);
434
435         // Analyse the safe enemy's checks which are possible on next move
436         safe  = ~pos.pieces(Them);
437         safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
438
439         b1 = attacks_bb<ROOK  >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
440         b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
441
442         // Enemy queen safe checks
443         if ((b1 | b2) & attackedBy[Them][QUEEN] & safe & ~attackedBy[Us][QUEEN])
444             kingDanger += QueenSafeCheck;
445
446         b1 &= attackedBy[Them][ROOK];
447         b2 &= attackedBy[Them][BISHOP];
448
449         // Enemy rooks checks
450         if (b1 & safe)
451             kingDanger += RookSafeCheck;
452         else
453             unsafeChecks |= b1;
454
455         // Enemy bishops checks
456         if (b2 & safe)
457             kingDanger += BishopSafeCheck;
458         else
459             unsafeChecks |= b2;
460
461         // Enemy knights checks
462         b = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
463         if (b & safe)
464             kingDanger += KnightSafeCheck;
465         else
466             unsafeChecks |= b;
467
468         // Unsafe or occupied checking squares will also be considered, as long as
469         // the square is in the attacker's mobility area.
470         unsafeChecks &= mobilityArea[Them];
471         pinned = pos.blockers_for_king(Us) & pos.pieces(Us);
472
473         kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
474                      + 102 * kingAttacksCount[Them]
475                      + 191 * popcount(kingRing[Us] & weak)
476                      + 143 * popcount(pinned | unsafeChecks)
477                      - 848 * !pos.count<QUEEN>(Them)
478                      -   9 * mg_value(score) / 8
479                      +  40;
480
481         // Transform the kingDanger units into a Score, and subtract it from the evaluation
482         if (kingDanger > 0)
483         {
484             int mobilityDanger = mg_value(mobility[Them] - mobility[Us]);
485             kingDanger = std::max(0, kingDanger + mobilityDanger);
486             score -= make_score(kingDanger * kingDanger / 4096, kingDanger / 16);
487         }
488     }
489
490     Bitboard kf = KingFlank[file_of(ksq)];
491
492     // Penalty when our king is on a pawnless flank
493     if (!(pos.pieces(PAWN) & kf))
494         score -= PawnlessFlank;
495
496     // Find the squares that opponent attacks in our king flank, and the squares
497     // which are attacked twice in that flank but not defended by our pawns.
498     b1 = attackedBy[Them][ALL_PIECES] & kf & Camp;
499     b2 = b1 & attackedBy2[Them] & ~attackedBy[Us][PAWN];
500
501     // King tropism, to anticipate slow motion attacks on our king
502     score -= CloseEnemies * (popcount(b1) + popcount(b2));
503
504     if (T)
505         Trace::add(KING, Us, score);
506
507     return score;
508   }
509
510
511   // Evaluation::threats() assigns bonuses according to the types of the
512   // attacking and the attacked pieces.
513   template<Tracing T> template<Color Us>
514   Score Evaluation<T>::threats() const {
515
516     constexpr Color     Them     = (Us == WHITE ? BLACK   : WHITE);
517     constexpr Direction Up       = (Us == WHITE ? NORTH   : SOUTH);
518     constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
519
520     Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safeThreats;
521     Score score = SCORE_ZERO;
522
523     // Non-pawn enemies attacked by a pawn
524     nonPawnEnemies = pos.pieces(Them) ^ pos.pieces(Them, PAWN);
525
526     // Our safe or protected pawns
527     b =   pos.pieces(Us, PAWN)
528        & (~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES]);
529
530     safeThreats = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
531     score += ThreatBySafePawn * popcount(safeThreats);
532
533     // Squares strongly protected by the enemy, either because they defend the
534     // square with a pawn, or because they defend the square twice and we don't.
535     stronglyProtected =  attackedBy[Them][PAWN]
536                        | (attackedBy2[Them] & ~attackedBy2[Us]);
537
538     // Non-pawn enemies, strongly protected
539     defended = nonPawnEnemies & stronglyProtected;
540
541     // Enemies not strongly protected and under our attack
542     weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
543
544     // Bonus according to the kind of attacking pieces
545     if (defended | weak)
546     {
547         b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
548         while (b)
549         {
550             Square s = pop_lsb(&b);
551             score += ThreatByMinor[type_of(pos.piece_on(s))];
552             if (type_of(pos.piece_on(s)) != PAWN)
553                 score += ThreatByRank * (int)relative_rank(Them, s);
554         }
555
556         b = (pos.pieces(Them, QUEEN) | weak) & attackedBy[Us][ROOK];
557         while (b)
558         {
559             Square s = pop_lsb(&b);
560             score += ThreatByRook[type_of(pos.piece_on(s))];
561             if (type_of(pos.piece_on(s)) != PAWN)
562                 score += ThreatByRank * (int)relative_rank(Them, s);
563         }
564
565         score += Hanging * popcount(weak & ~attackedBy[Them][ALL_PIECES]);
566
567         b = weak & attackedBy[Us][KING];
568         if (b)
569             score += ThreatByKing[more_than_one(b)];
570     }
571
572     // Bonus for enemy unopposed weak pawns
573     if (pos.pieces(Us, ROOK, QUEEN))
574         score += WeakUnopposedPawn * pe->weak_unopposed(Them);
575
576     // Find squares where our pawns can push on the next move
577     b  = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
578     b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
579
580     // Keep only the squares which are not completely unsafe
581     b &= ~attackedBy[Them][PAWN]
582         & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
583
584     // Bonus for safe pawn threats on the next move
585     b =   pawn_attacks_bb<Us>(b)
586        &  pos.pieces(Them)
587        & ~attackedBy[Us][PAWN];
588
589     score += ThreatByPawnPush * popcount(b);
590
591     // Bonus for threats on the next moves against enemy queen
592     if (pos.count<QUEEN>(Them) == 1)
593     {
594         Square s = pos.square<QUEEN>(Them);
595         safeThreats = mobilityArea[Us] & ~stronglyProtected;
596
597         b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
598
599         score += KnightOnQueen * popcount(b & safeThreats);
600
601         b =  (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
602            | (attackedBy[Us][ROOK  ] & pos.attacks_from<ROOK  >(s));
603
604         score += SliderOnQueen * popcount(b & safeThreats & attackedBy2[Us]);
605     }
606
607     // Connectivity: ensure that knights, bishops, rooks, and queens are protected
608     b = (pos.pieces(Us) ^ pos.pieces(Us, PAWN, KING)) & attackedBy[Us][ALL_PIECES];
609     score += Connectivity * popcount(b);
610
611     if (T)
612         Trace::add(THREAT, Us, score);
613
614     return score;
615   }
616
617   // Evaluation::passed() evaluates the passed pawns and candidate passed
618   // pawns of the given color.
619
620   template<Tracing T> template<Color Us>
621   Score Evaluation<T>::passed() const {
622
623     constexpr Color     Them = (Us == WHITE ? BLACK : WHITE);
624     constexpr Direction Up   = (Us == WHITE ? NORTH : SOUTH);
625
626     auto king_proximity = [&](Color c, Square s) {
627       return std::min(distance(pos.square<KING>(c), s), 5);
628     };
629
630     Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
631     Score score = SCORE_ZERO;
632
633     b = pe->passed_pawns(Us);
634
635     while (b)
636     {
637         Square s = pop_lsb(&b);
638
639         assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
640
641         bb = forward_file_bb(Us, s) & (attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
642         score -= HinderPassedPawn * popcount(bb);
643
644         int r = relative_rank(Us, s);
645         int w = PassedDanger[r];
646
647         Score bonus = PassedRank[r];
648
649         if (w)
650         {
651             Square blockSq = s + Up;
652
653             // Adjust bonus based on the king's proximity
654             bonus += make_score(0, (  king_proximity(Them, blockSq) * 5
655                                     - king_proximity(Us,   blockSq) * 2) * w);
656
657             // If blockSq is not the queening square then consider also a second push
658             if (r != RANK_7)
659                 bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
660
661             // If the pawn is free to advance, then increase the bonus
662             if (pos.empty(blockSq))
663             {
664                 // If there is a rook or queen attacking/defending the pawn from behind,
665                 // consider all the squaresToQueen. Otherwise consider only the squares
666                 // in the pawn's path attacked or occupied by the enemy.
667                 defendedSquares = unsafeSquares = squaresToQueen = forward_file_bb(Us, s);
668
669                 bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
670
671                 if (!(pos.pieces(Us) & bb))
672                     defendedSquares &= attackedBy[Us][ALL_PIECES];
673
674                 if (!(pos.pieces(Them) & bb))
675                     unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
676
677                 // If there aren't any enemy attacks, assign a big bonus. Otherwise
678                 // assign a smaller bonus if the block square isn't attacked.
679                 int k = !unsafeSquares ? 20 : !(unsafeSquares & blockSq) ? 9 : 0;
680
681                 // If the path to the queen is fully defended, assign a big bonus.
682                 // Otherwise assign a smaller bonus if the block square is defended.
683                 if (defendedSquares == squaresToQueen)
684                     k += 6;
685
686                 else if (defendedSquares & blockSq)
687                     k += 4;
688
689                 bonus += make_score(k * w, k * w);
690             }
691             else if (pos.pieces(Us) & blockSq)
692                 bonus += make_score(w + r * 2, w + r * 2);
693         } // w != 0
694
695         // Scale down bonus for candidate passers which need more than one
696         // pawn push to become passed or have a pawn in front of them.
697         if (   !pos.pawn_passed(Us, s + Up)
698             || (pos.pieces(PAWN) & forward_file_bb(Us, s)))
699             bonus = bonus / 2;
700
701         score += bonus + PassedFile[file_of(s)];
702     }
703
704     if (T)
705         Trace::add(PASSED, Us, score);
706
707     return score;
708   }
709
710
711   // Evaluation::space() computes the space evaluation for a given side. The
712   // space evaluation is a simple bonus based on the number of safe squares
713   // available for minor pieces on the central four files on ranks 2--4. Safe
714   // squares one, two or three squares behind a friendly pawn are counted
715   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
716   // improve play on game opening.
717
718   template<Tracing T> template<Color Us>
719   Score Evaluation<T>::space() const {
720
721     constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
722     constexpr Bitboard SpaceMask =
723       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
724                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
725
726     if (pos.non_pawn_material() < SpaceThreshold)
727         return SCORE_ZERO;
728
729     // Find the safe squares for our pieces inside the area defined by
730     // SpaceMask. A square is unsafe if it is attacked by an enemy
731     // pawn, or if it is undefended and attacked by an enemy piece.
732     Bitboard safe =   SpaceMask
733                    & ~pos.pieces(Us, PAWN)
734                    & ~attackedBy[Them][PAWN]
735                    & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
736
737     // Find all squares which are at most three squares behind some friendly pawn
738     Bitboard behind = pos.pieces(Us, PAWN);
739     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
740     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
741
742     int bonus = popcount(safe) + popcount(behind & safe);
743     int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
744
745     Score score = make_score(bonus * weight * weight / 16, 0);
746
747     if (T)
748         Trace::add(SPACE, Us, score);
749
750     return score;
751   }
752
753
754   // Evaluation::initiative() computes the initiative correction value
755   // for the position. It is a second order bonus/malus based on the
756   // known attacking/defending status of the players.
757
758   template<Tracing T>
759   Score Evaluation<T>::initiative(Value eg) const {
760
761     int outflanking =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
762                      - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
763
764     bool pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
765                             && (pos.pieces(PAWN) & KingSide);
766
767     // Compute the initiative bonus for the attacking side
768     int complexity =   8 * outflanking
769                     +  8 * pe->pawn_asymmetry()
770                     + 12 * pos.count<PAWN>()
771                     + 16 * pawnsOnBothFlanks
772                     + 48 * !pos.non_pawn_material()
773                     -136 ;
774
775     // Now apply the bonus: note that we find the attacking side by extracting
776     // the sign of the endgame value, and that we carefully cap the bonus so
777     // that the endgame score will never change sign after the bonus.
778     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
779
780     if (T)
781         Trace::add(INITIATIVE, make_score(0, v));
782
783     return make_score(0, v);
784   }
785
786
787   // Evaluation::scale_factor() computes the scale factor for the winning side
788
789   template<Tracing T>
790   ScaleFactor Evaluation<T>::scale_factor(Value eg) const {
791
792     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
793     int sf = me->scale_factor(pos, strongSide);
794
795     // If we don't already have an unusual scale factor, check for certain
796     // types of endgames, and use a lower scale for those.
797     if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
798     {
799         if (pos.opposite_bishops())
800         {
801             // Endgame with opposite-colored bishops and no other pieces is almost a draw
802             if (   pos.non_pawn_material(WHITE) == BishopValueMg
803                 && pos.non_pawn_material(BLACK) == BishopValueMg)
804                 sf = 31;
805
806             // Endgame with opposite-colored bishops, but also other pieces. Still
807             // a bit drawish, but not as drawish as with only the two bishops.
808             else
809                 sf = 46;
810         }
811         // Endings where weaker side can place his king in front of the enemy's
812         // pawns are drawish.
813         else if (    abs(eg) <= BishopValueEg
814                  &&  pos.count<PAWN>(strongSide) <= 2
815                  && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
816             sf = 37 + 7 * pos.count<PAWN>(strongSide);
817     }
818
819     return ScaleFactor(sf);
820   }
821
822
823   // Evaluation::value() is the main function of the class. It computes the various
824   // parts of the evaluation and returns the value of the position from the point
825   // of view of the side to move.
826
827   template<Tracing T>
828   Value Evaluation<T>::value() {
829
830     assert(!pos.checkers());
831
832     // Probe the material hash table
833     me = Material::probe(pos);
834
835     // If we have a specialized evaluation function for the current material
836     // configuration, call it and return.
837     if (me->specialized_eval_exists())
838         return me->evaluate(pos);
839
840     // Initialize score by reading the incrementally updated scores included in
841     // the position object (material + piece square tables) and the material
842     // imbalance. Score is computed internally from the white point of view.
843     Score score = pos.psq_score() + me->imbalance() + pos.this_thread()->contempt;
844
845     // Probe the pawn hash table
846     pe = Pawns::probe(pos);
847     score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
848
849     // Early exit if score is high
850     Value v = (mg_value(score) + eg_value(score)) / 2;
851     if (abs(v) > LazyThreshold)
852        return pos.side_to_move() == WHITE ? v : -v;
853
854     // Main evaluation begins here
855
856     initialize<WHITE>();
857     initialize<BLACK>();
858
859     // Pieces should be evaluated first (populate attack tables)
860     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
861             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
862             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()
863             + pieces<WHITE, QUEEN >() - pieces<BLACK, QUEEN >();
864
865     score += mobility[WHITE] - mobility[BLACK];
866
867     score +=  king<   WHITE>() - king<   BLACK>()
868             + threats<WHITE>() - threats<BLACK>()
869             + passed< WHITE>() - passed< BLACK>()
870             + space<  WHITE>() - space<  BLACK>();
871
872     score += initiative(eg_value(score));
873
874     // Interpolate between a middlegame and a (scaled by 'sf') endgame score
875     ScaleFactor sf = scale_factor(eg_value(score));
876     v =  mg_value(score) * int(me->game_phase())
877        + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
878
879     v /= int(PHASE_MIDGAME);
880
881     // In case of tracing add all remaining individual evaluation terms
882     if (T)
883     {
884         Trace::add(MATERIAL, pos.psq_score());
885         Trace::add(IMBALANCE, me->imbalance());
886         Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
887         Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
888         Trace::add(TOTAL, score);
889     }
890
891     return  (pos.side_to_move() == WHITE ? v : -v) // Side to move point of view
892            + Eval::Tempo;
893   }
894
895 } // namespace
896
897
898 /// evaluate() is the evaluator for the outer world. It returns a static
899 /// evaluation of the position from the point of view of the side to move.
900
901 Value Eval::evaluate(const Position& pos) {
902   return Evaluation<NO_TRACE>(pos).value();
903 }
904
905
906 /// trace() is like evaluate(), but instead of returning a value, it returns
907 /// a string (suitable for outputting to stdout) that contains the detailed
908 /// descriptions and values of each evaluation term. Useful for debugging.
909
910 std::string Eval::trace(const Position& pos) {
911
912   std::memset(scores, 0, sizeof(scores));
913
914   pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt
915
916   Value v = Evaluation<TRACE>(pos).value();
917
918   v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view
919
920   std::stringstream ss;
921   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
922      << "     Term    |    White    |    Black    |    Total   \n"
923      << "             |   MG    EG  |   MG    EG  |   MG    EG \n"
924      << " ------------+-------------+-------------+------------\n"
925      << "    Material | " << Term(MATERIAL)
926      << "   Imbalance | " << Term(IMBALANCE)
927      << "  Initiative | " << Term(INITIATIVE)
928      << "       Pawns | " << Term(PAWN)
929      << "     Knights | " << Term(KNIGHT)
930      << "     Bishops | " << Term(BISHOP)
931      << "       Rooks | " << Term(ROOK)
932      << "      Queens | " << Term(QUEEN)
933      << "    Mobility | " << Term(MOBILITY)
934      << " King safety | " << Term(KING)
935      << "     Threats | " << Term(THREAT)
936      << "      Passed | " << Term(PASSED)
937      << "       Space | " << Term(SPACE)
938      << " ------------+-------------+-------------+------------\n"
939      << "       Total | " << Term(TOTAL);
940
941   ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n";
942
943   return ss.str();
944 }