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