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