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