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