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