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