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