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