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