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