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