84c832695dee5d3a43234c9045541b0f30009534
[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, 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     // Non-pawn enemies defended by a pawn
549     defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];
550
551     // Enemies not defended by a pawn and under our attack
552     weak =   pos.pieces(Them)
553           & ~ei.attackedBy[Them][PAWN]
554           &  ei.attackedBy[Us][ALL_PIECES];
555
556     // Add a bonus according to the kind of attacking pieces
557     if (defended | weak)
558     {
559         b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
560         while (b)
561         {
562             Square s = pop_lsb(&b);
563             score += ThreatByMinor[type_of(pos.piece_on(s))];
564             if (type_of(pos.piece_on(s)) != PAWN)
565                 score += ThreatByRank * (int)relative_rank(Them, s);
566         }
567
568         b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];
569         while (b)
570         {
571             Square s = pop_lsb(&b);
572             score += ThreatByRook[type_of(pos.piece_on(s))];
573             if (type_of(pos.piece_on(s)) != PAWN)
574                 score += ThreatByRank * (int)relative_rank(Them, s);
575         }
576
577         score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]);
578
579         b = weak & ei.attackedBy[Us][KING];
580         if (b)
581             score += ThreatByKing[more_than_one(b)];
582     }
583
584     // Bonus if some pawns can safely push and attack an enemy piece
585     b = pos.pieces(Us, PAWN) & ~TRank7BB;
586     b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
587
588     b &=  ~pos.pieces()
589         & ~ei.attackedBy[Them][PAWN]
590         & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
591
592     b =  (shift<Left>(b) | shift<Right>(b))
593        &  pos.pieces(Them)
594        & ~ei.attackedBy[Us][PAWN];
595
596     score += ThreatByPawnPush * popcount(b);
597
598     if (DoTrace)
599         Trace::add(THREAT, Us, score);
600
601     return score;
602   }
603
604
605   // evaluate_passer_pawns() evaluates the passed pawns and candidate passed
606   // pawns of the given color.
607
608   template<Color Us, bool DoTrace>
609   Score evaluate_passer_pawns(const Position& pos, const EvalInfo& ei) {
610
611     const Color Them = (Us == WHITE ? BLACK : WHITE);
612
613     Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
614     Score score = SCORE_ZERO;
615
616     b = ei.pe->passed_pawns(Us);
617
618     while (b)
619     {
620         Square s = pop_lsb(&b);
621
622         assert(!(pos.pieces(PAWN) & forward_bb(Us, s)));
623
624         bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
625         score -= HinderPassedPawn * popcount(bb);
626
627         int r = relative_rank(Us, s) - RANK_2;
628         int rr = r * (r - 1);
629
630         Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];
631
632         if (rr)
633         {
634             Square blockSq = s + pawn_push(Us);
635
636             // Adjust bonus based on the king's proximity
637             ebonus +=  distance(pos.square<KING>(Them), blockSq) * 5 * rr
638                      - distance(pos.square<KING>(Us  ), blockSq) * 2 * rr;
639
640             // If blockSq is not the queening square then consider also a second push
641             if (relative_rank(Us, blockSq) != RANK_8)
642                 ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;
643
644             // If the pawn is free to advance, then increase the bonus
645             if (pos.empty(blockSq))
646             {
647                 // If there is a rook or queen attacking/defending the pawn from behind,
648                 // consider all the squaresToQueen. Otherwise consider only the squares
649                 // in the pawn's path attacked or occupied by the enemy.
650                 defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);
651
652                 bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
653
654                 if (!(pos.pieces(Us) & bb))
655                     defendedSquares &= ei.attackedBy[Us][ALL_PIECES];
656
657                 if (!(pos.pieces(Them) & bb))
658                     unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
659
660                 // If there aren't any enemy attacks, assign a big bonus. Otherwise
661                 // assign a smaller bonus if the block square isn't attacked.
662                 int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;
663
664                 // If the path to the queen is fully defended, assign a big bonus.
665                 // Otherwise assign a smaller bonus if the block square is defended.
666                 if (defendedSquares == squaresToQueen)
667                     k += 6;
668
669                 else if (defendedSquares & blockSq)
670                     k += 4;
671
672                 mbonus += k * rr, ebonus += k * rr;
673             }
674             else if (pos.pieces(Us) & blockSq)
675                 mbonus += rr + r * 2, ebonus += rr + r * 2;
676         } // rr != 0
677
678         // Scale down bonus for candidate passers which need more than one pawn
679         // push to become passed.
680         if (!pos.pawn_passed(Us, s + pawn_push(Us)))
681             mbonus /= 2, ebonus /= 2;
682
683         score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
684     }
685
686     if (DoTrace)
687         Trace::add(PASSED, Us, score);
688
689     // Add the scores to the middlegame and endgame eval
690     return score;
691   }
692
693
694   // evaluate_space() computes the space evaluation for a given side. The
695   // space evaluation is a simple bonus based on the number of safe squares
696   // available for minor pieces on the central four files on ranks 2--4. Safe
697   // squares one, two or three squares behind a friendly pawn are counted
698   // twice. Finally, the space bonus is multiplied by a weight. The aim is to
699   // improve play on game opening.
700   template<Color Us>
701   Score evaluate_space(const Position& pos, const EvalInfo& ei) {
702
703     const Color Them = (Us == WHITE ? BLACK : WHITE);
704     const Bitboard SpaceMask =
705       Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
706                   : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
707
708     // Find the safe squares for our pieces inside the area defined by
709     // SpaceMask. A square is unsafe if it is attacked by an enemy
710     // pawn, or if it is undefended and attacked by an enemy piece.
711     Bitboard safe =   SpaceMask
712                    & ~pos.pieces(Us, PAWN)
713                    & ~ei.attackedBy[Them][PAWN]
714                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
715
716     // Find all squares which are at most three squares behind some friendly pawn
717     Bitboard behind = pos.pieces(Us, PAWN);
718     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
719     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
720
721     // Since SpaceMask[Us] is fully on our half of the board...
722     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
723
724     // ...count safe + (behind & safe) with a single popcount.
725     int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
726     bonus = std::min(16, bonus);
727     int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files();
728
729     return make_score(bonus * weight * weight / 18, 0);
730   }
731
732
733   // evaluate_initiative() computes the initiative correction value for the
734   // position, i.e., second order bonus/malus based on the known attacking/defending
735   // status of the players.
736   Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
737
738     int kingDistance =  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
739                       - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
740     int pawns = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);
741     bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
742
743     // Compute the initiative bonus for the attacking side
744     int initiative = 8 * (asymmetry + kingDistance - 17) + 12 * pawns + 16 * bothFlanks;
745
746     // Now apply the bonus: note that we find the attacking side by extracting
747     // the sign of the endgame value, and that we carefully cap the bonus so
748     // that the endgame score will never change sign after the bonus.
749     int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
750
751     return make_score(0, value);
752   }
753
754
755   // evaluate_scale_factor() computes the scale factor for the winning side
756   ScaleFactor evaluate_scale_factor(const Position& pos, const EvalInfo& ei, Value eg) {
757
758     Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
759     ScaleFactor sf = ei.me->scale_factor(pos, strongSide);
760
761     // If we don't already have an unusual scale factor, check for certain
762     // types of endgames, and use a lower scale for those.
763     if (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)
764     {
765         if (pos.opposite_bishops())
766         {
767             // Endgame with opposite-colored bishops and no other pieces (ignoring pawns)
768             // is almost a draw, in case of KBP vs KB, it is even more a draw.
769             if (   pos.non_pawn_material(WHITE) == BishopValueMg
770                 && pos.non_pawn_material(BLACK) == BishopValueMg)
771                 return more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);
772
773             // Endgame with opposite-colored bishops, but also other pieces. Still
774             // a bit drawish, but not as drawish as with only the two bishops.
775             return ScaleFactor(46);
776         }
777         // Endings where weaker side can place his king in front of the opponent's
778         // pawns are drawish.
779         else if (    abs(eg) <= BishopValueEg
780                  &&  pos.count<PAWN>(strongSide) <= 2
781                  && !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))
782             return ScaleFactor(37 + 7 * pos.count<PAWN>(strongSide));
783     }
784
785     return sf;
786   }
787
788 } // namespace
789
790
791 /// evaluate() is the main evaluation function. It returns a static evaluation
792 /// of the position from the point of view of the side to move.
793
794 template<bool DoTrace>
795 Value Eval::evaluate(const Position& pos) {
796
797   assert(!pos.checkers());
798
799   Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
800   Value v;
801   EvalInfo ei;
802
803   // Probe the material hash table
804   ei.me = Material::probe(pos);
805
806   // If we have a specialized evaluation function for the current material
807   // configuration, call it and return.
808   if (ei.me->specialized_eval_exists())
809       return ei.me->evaluate(pos);
810
811   // Initialize score by reading the incrementally updated scores included in
812   // the position object (material + piece square tables) and the material
813   // imbalance. Score is computed internally from the white point of view.
814   Score score = pos.psq_score() + ei.me->imbalance();
815
816   // Probe the pawn hash table
817   ei.pe = Pawns::probe(pos);
818   score += ei.pe->pawns_score();
819
820   // Early exit if score is high
821   v = (mg_value(score) + eg_value(score)) / 2;
822   if (abs(v) > LazyThreshold)
823      return pos.side_to_move() == WHITE ? v : -v;
824
825   // Initialize attack and king safety bitboards
826   eval_init<WHITE>(pos, ei);
827   eval_init<BLACK>(pos, ei);
828
829   // Evaluate all pieces but king and pawns
830   score += evaluate_pieces<DoTrace>(pos, ei, mobility);
831   score += mobility[WHITE] - mobility[BLACK];
832
833   // Evaluate kings after all other pieces because we need full attack
834   // information when computing the king safety evaluation.
835   score +=  evaluate_king<WHITE, DoTrace>(pos, ei)
836           - evaluate_king<BLACK, DoTrace>(pos, ei);
837
838   // Evaluate tactical threats, we need full attack information including king
839   score +=  evaluate_threats<WHITE, DoTrace>(pos, ei)
840           - evaluate_threats<BLACK, DoTrace>(pos, ei);
841
842   // Evaluate passed pawns, we need full attack information including king
843   score +=  evaluate_passer_pawns<WHITE, DoTrace>(pos, ei)
844           - evaluate_passer_pawns<BLACK, DoTrace>(pos, ei);
845
846   // Evaluate space for both sides, only during opening
847   if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
848       score +=  evaluate_space<WHITE>(pos, ei)
849               - evaluate_space<BLACK>(pos, ei);
850
851   // Evaluate position potential for the winning side
852   score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score));
853
854   // Evaluate scale factor for the winning side
855   ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
856
857   // Interpolate between a middlegame and a (scaled by 'sf') endgame score
858   v =  mg_value(score) * int(ei.me->game_phase())
859      + eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
860
861   v /= int(PHASE_MIDGAME);
862
863   // In case of tracing add all remaining individual evaluation terms
864   if (DoTrace)
865   {
866       Trace::add(MATERIAL, pos.psq_score());
867       Trace::add(IMBALANCE, ei.me->imbalance());
868       Trace::add(PAWN, ei.pe->pawns_score());
869       Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
870       if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
871           Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
872                           , evaluate_space<BLACK>(pos, ei));
873       Trace::add(TOTAL, score);
874   }
875
876   return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
877 }
878
879 // Explicit template instantiations
880 template Value Eval::evaluate<true >(const Position&);
881 template Value Eval::evaluate<false>(const Position&);
882
883
884 /// trace() is like evaluate(), but instead of returning a value, it returns
885 /// a string (suitable for outputting to stdout) that contains the detailed
886 /// descriptions and values of each evaluation term. Useful for debugging.
887
888 std::string Eval::trace(const Position& pos) {
889
890   std::memset(scores, 0, sizeof(scores));
891
892   Value v = evaluate<true>(pos);
893   v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
894
895   std::stringstream ss;
896   ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
897      << "      Eval term |    White    |    Black    |    Total    \n"
898      << "                |   MG    EG  |   MG    EG  |   MG    EG  \n"
899      << "----------------+-------------+-------------+-------------\n"
900      << "       Material | " << Term(MATERIAL)
901      << "      Imbalance | " << Term(IMBALANCE)
902      << "          Pawns | " << Term(PAWN)
903      << "        Knights | " << Term(KNIGHT)
904      << "         Bishop | " << Term(BISHOP)
905      << "          Rooks | " << Term(ROOK)
906      << "         Queens | " << Term(QUEEN)
907      << "       Mobility | " << Term(MOBILITY)
908      << "    King safety | " << Term(KING)
909      << "        Threats | " << Term(THREAT)
910      << "   Passed pawns | " << Term(PASSED)
911      << "          Space | " << Term(SPACE)
912      << "----------------+-------------+-------------+-------------\n"
913      << "          Total | " << Term(TOTAL);
914
915   ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
916
917   return ss.str();
918 }