Rewrite options handling in an object oriented fashion
[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-2010 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
21 ////
22 //// Includes
23 ////
24
25 #include <cassert>
26
27 #include "bitcount.h"
28 #include "evaluate.h"
29 #include "material.h"
30 #include "pawns.h"
31 #include "thread.h"
32 #include "ucioption.h"
33
34
35 ////
36 //// Local definitions
37 ////
38
39 namespace {
40
41   // Struct EvalInfo contains various information computed and collected
42   // by the evaluation functions.
43   struct EvalInfo {
44
45     // Pointer to pawn hash table entry
46     PawnInfo* pi;
47
48     // attackedBy[color][piece type] is a bitboard representing all squares
49     // attacked by a given color and piece type, attackedBy[color][0] contains
50     // all squares attacked by the given color.
51     Bitboard attackedBy[2][8];
52
53     // kingZone[color] is the zone around the enemy king which is considered
54     // by the king safety evaluation. This consists of the squares directly
55     // adjacent to the king, and the three (or two, for a king on an edge file)
56     // squares two ranks in front of the king. For instance, if black's king
57     // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
58     // f7, g7, h7, f6, g6 and h6.
59     Bitboard kingZone[2];
60
61     // kingAttackersCount[color] is the number of pieces of the given color
62     // which attack a square in the kingZone of the enemy king.
63     int kingAttackersCount[2];
64
65     // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
66     // given color which attack a square in the kingZone of the enemy king. The
67     // weights of the individual piece types are given by the variables
68     // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
69     // KnightAttackWeight in evaluate.cpp
70     int kingAttackersWeight[2];
71
72     // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
73     // directly adjacent to the king of the given color. Pieces which attack
74     // more than one square are counted multiple times. For instance, if black's
75     // king is on g8 and there's a white knight on g5, this knight adds
76     // 2 to kingAdjacentZoneAttacksCount[BLACK].
77     int kingAdjacentZoneAttacksCount[2];
78   };
79
80   // Evaluation grain size, must be a power of 2
81   const int GrainSize = 8;
82
83   // Evaluation weights, initialized from UCI options
84   enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
85   Score Weights[6];
86
87   typedef Value V;
88   #define S(mg, eg) make_score(mg, eg)
89
90   // Internal evaluation weights. These are applied on top of the evaluation
91   // weights read from UCI parameters. The purpose is to be able to change
92   // the evaluation weights while keeping the default values of the UCI
93   // parameters at 100, which looks prettier.
94   //
95   // Values modified by Joona Kiiski
96   const Score WeightsInternal[] = {
97       S(248, 271), S(233, 201), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
98   };
99
100   // MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
101   // end game, indexed by piece type and number of attacked squares not occupied
102   // by friendly pieces.
103   const Score MobilityBonus[][32] = {
104      {}, {},
105      { S(-38,-33), S(-25,-23), S(-12,-13), S( 0, -3), S(12,  7), S(25, 17), // Knights
106        S( 31, 22), S( 38, 27), S( 38, 27) },
107      { S(-25,-30), S(-11,-16), S(  3, -2), S(17, 12), S(31, 26), S(45, 40), // Bishops
108        S( 57, 52), S( 65, 60), S( 71, 65), S(74, 69), S(76, 71), S(78, 73),
109        S( 79, 74), S( 80, 75), S( 81, 76), S(81, 76) },
110      { S(-20,-36), S(-14,-19), S( -8, -3), S(-2, 13), S( 4, 29), S(10, 46), // Rooks
111        S( 14, 62), S( 19, 79), S( 23, 95), S(26,106), S(27,111), S(28,114),
112        S( 29,116), S( 30,117), S( 31,118), S(32,118) },
113      { S(-10,-18), S( -8,-13), S( -6, -7), S(-3, -2), S(-1,  3), S( 1,  8), // Queens
114        S(  3, 13), S(  5, 19), S(  8, 23), S(10, 27), S(12, 32), S(15, 34),
115        S( 16, 35), S( 17, 35), S( 18, 35), S(20, 35), S(20, 35), S(20, 35),
116        S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
117        S( 20, 35), S( 20, 35), S( 20, 35), S(20, 35), S(20, 35), S(20, 35),
118        S( 20, 35), S( 20, 35) }
119   };
120
121   // OutpostBonus[PieceType][Square] contains outpost bonuses of knights and
122   // bishops, indexed by piece type and square (from white's point of view).
123   const Value OutpostBonus[][64] = {
124   {
125   //  A     B     C     D     E     F     G     H
126     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights
127     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
128     V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0),
129     V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0),
130     V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0),
131     V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0) },
132   {
133     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops
134     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
135     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0),
136     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0),
137     V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0),
138     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) }
139   };
140
141   // ThreatBonus[attacking][attacked] contains threat bonuses according to
142   // which piece type attacks which one.
143   const Score ThreatBonus[][8] = {
144     {}, {},
145     { S(0, 0), S( 7, 39), S( 0,  0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
146     { S(0, 0), S( 7, 39), S(24, 49), S( 0,  0), S(41,100), S(41,100) }, // BISHOP
147     { S(0, 0), S(-1, 29), S(15, 49), S(15, 49), S( 0,  0), S(24, 49) }, // ROOK
148     { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0,  0) }  // QUEEN
149   };
150
151   // ThreatedByPawnPenalty[PieceType] contains a penalty according to which
152   // piece type is attacked by an enemy pawn.
153   const Score ThreatedByPawnPenalty[] = {
154     S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
155   };
156
157   #undef S
158
159   // Rooks and queens on the 7th rank (modified by Joona Kiiski)
160   const Score RookOn7thBonus  = make_score(47, 98);
161   const Score QueenOn7thBonus = make_score(27, 54);
162
163   // Rooks on open files (modified by Joona Kiiski)
164   const Score RookOpenFileBonus = make_score(43, 43);
165   const Score RookHalfOpenFileBonus = make_score(19, 19);
166
167   // Penalty for rooks trapped inside a friendly king which has lost the
168   // right to castle.
169   const Value TrappedRookPenalty = Value(180);
170
171   // The SpaceMask[Color] contains the area of the board which is considered
172   // by the space evaluation. In the middle game, each side is given a bonus
173   // based on how many squares inside this area are safe and available for
174   // friendly minor pieces.
175   const Bitboard SpaceMask[] = {
176     (1ULL << SQ_C2) | (1ULL << SQ_D2) | (1ULL << SQ_E2) | (1ULL << SQ_F2) |
177     (1ULL << SQ_C3) | (1ULL << SQ_D3) | (1ULL << SQ_E3) | (1ULL << SQ_F3) |
178     (1ULL << SQ_C4) | (1ULL << SQ_D4) | (1ULL << SQ_E4) | (1ULL << SQ_F4),
179     (1ULL << SQ_C7) | (1ULL << SQ_D7) | (1ULL << SQ_E7) | (1ULL << SQ_F7) |
180     (1ULL << SQ_C6) | (1ULL << SQ_D6) | (1ULL << SQ_E6) | (1ULL << SQ_F6) |
181     (1ULL << SQ_C5) | (1ULL << SQ_D5) | (1ULL << SQ_E5) | (1ULL << SQ_F5)
182   };
183
184   // King danger constants and variables. The king danger scores are taken
185   // from the KingDangerTable[]. Various little "meta-bonuses" measuring
186   // the strength of the enemy attack are added up into an integer, which
187   // is used as an index to KingDangerTable[].
188   //
189   // KingAttackWeights[PieceType] contains king attack weights by piece type
190   const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
191
192   // Bonuses for enemy's safe checks
193   const int QueenContactCheckBonus = 6;
194   const int RookContactCheckBonus  = 4;
195   const int QueenCheckBonus        = 3;
196   const int RookCheckBonus         = 2;
197   const int BishopCheckBonus       = 1;
198   const int KnightCheckBonus       = 1;
199
200   // InitKingDanger[Square] contains penalties based on the position of the
201   // defending king, indexed by king's square (from white's point of view).
202   const int InitKingDanger[] = {
203      2,  0,  2,  5,  5,  2,  0,  2,
204      2,  2,  4,  8,  8,  4,  2,  2,
205      7, 10, 12, 12, 12, 12, 10,  7,
206     15, 15, 15, 15, 15, 15, 15, 15,
207     15, 15, 15, 15, 15, 15, 15, 15,
208     15, 15, 15, 15, 15, 15, 15, 15,
209     15, 15, 15, 15, 15, 15, 15, 15,
210     15, 15, 15, 15, 15, 15, 15, 15
211   };
212
213   // KingDangerTable[Color][attackUnits] contains the actual king danger
214   // weighted scores, indexed by color and by a calculated integer number.
215   Score KingDangerTable[2][128];
216
217   // Pawn and material hash tables, indexed by the current thread id.
218   // Note that they will be initialized at 0 being global variables.
219   MaterialInfoTable* MaterialTable[MAX_THREADS];
220   PawnInfoTable* PawnTable[MAX_THREADS];
221
222   // Function prototypes
223   template<bool HasPopCnt>
224   Value do_evaluate(const Position& pos, Value& margin);
225
226   template<Color Us, bool HasPopCnt>
227   void init_eval_info(const Position& pos, EvalInfo& ei);
228
229   template<Color Us, bool HasPopCnt>
230   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
231
232   template<Color Us, bool HasPopCnt>
233   Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]);
234
235   template<Color Us>
236   Score evaluate_threats(const Position& pos, EvalInfo& ei);
237
238   template<Color Us, bool HasPopCnt>
239   int evaluate_space(const Position& pos, EvalInfo& ei);
240
241   template<Color Us>
242   Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
243
244   inline Score apply_weight(Score v, Score weight);
245   Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf);
246   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
247   void init_safety();
248 }
249
250
251 ////
252 //// Functions
253 ////
254
255
256 /// Prefetches in pawn hash tables
257
258 void prefetchPawn(Key key, int threadID) {
259
260     PawnTable[threadID]->prefetch(key);
261 }
262
263
264 /// evaluate() is the main evaluation function. It always computes two
265 /// values, an endgame score and a middle game score, and interpolates
266 /// between them based on the remaining material.
267 Value evaluate(const Position& pos, Value& margin) {
268
269     return CpuHasPOPCNT ? do_evaluate<true>(pos, margin)
270                         : do_evaluate<false>(pos, margin);
271 }
272
273 namespace {
274
275 template<bool HasPopCnt>
276 Value do_evaluate(const Position& pos, Value& margin) {
277
278   EvalInfo ei;
279   Value margins[2];
280   Score mobilityWhite, mobilityBlack;
281
282   assert(pos.is_ok());
283   assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
284   assert(!pos.is_check());
285
286   // Initialize value by reading the incrementally updated scores included
287   // in the position object (material + piece square tables).
288   Score bonus = pos.value();
289
290   // margins[] store the uncertainty estimation of position's evaluation
291   // that typically is used by the search for pruning decisions.
292   margins[WHITE] = margins[BLACK] = VALUE_ZERO;
293
294   // Probe the material hash table
295   MaterialInfo* mi = MaterialTable[pos.thread()]->get_material_info(pos);
296   bonus += mi->material_value();
297
298   // If we have a specialized evaluation function for the current material
299   // configuration, call it and return.
300   if (mi->specialized_eval_exists())
301   {
302       margin = VALUE_ZERO;
303       return mi->evaluate(pos);
304   }
305
306   // Probe the pawn hash table
307   ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
308   bonus += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
309
310   // Initialize attack and king safety bitboards
311   init_eval_info<WHITE, HasPopCnt>(pos, ei);
312   init_eval_info<BLACK, HasPopCnt>(pos, ei);
313
314   // Evaluate pieces and mobility
315   bonus +=  evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei, mobilityWhite)
316           - evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei, mobilityBlack);
317
318   bonus += apply_weight(mobilityWhite - mobilityBlack, Weights[Mobility]);
319
320   // Evaluate kings after all other pieces because we need complete attack
321   // information when computing the king safety evaluation.
322   bonus +=  evaluate_king<WHITE, HasPopCnt>(pos, ei, margins)
323           - evaluate_king<BLACK, HasPopCnt>(pos, ei, margins);
324
325   // Evaluate tactical threats, we need full attack information including king
326   bonus +=  evaluate_threats<WHITE>(pos, ei)
327           - evaluate_threats<BLACK>(pos, ei);
328
329   // Evaluate passed pawns, we need full attack information including king
330   bonus +=  evaluate_passed_pawns<WHITE>(pos, ei)
331           - evaluate_passed_pawns<BLACK>(pos, ei);
332
333   // Evaluate space for both sides, only in middle-game.
334   if (mi->space_weight())
335   {
336       int s = evaluate_space<WHITE, HasPopCnt>(pos, ei) - evaluate_space<BLACK, HasPopCnt>(pos, ei);
337       bonus += apply_weight(make_score(s * mi->space_weight(), 0), Weights[Space]);
338   }
339
340   // Scale winning side if position is more drawish that what it appears
341   ScaleFactor sf = eg_value(bonus) > VALUE_DRAW ? mi->scale_factor(pos, WHITE)
342                                                 : mi->scale_factor(pos, BLACK);
343   Phase phase = mi->game_phase();
344
345   // If we don't already have an unusual scale factor, check for opposite
346   // colored bishop endgames, and use a lower scale for those.
347   if (   phase < PHASE_MIDGAME
348       && pos.opposite_colored_bishops()
349       && sf == SCALE_FACTOR_NORMAL)
350   {
351       // Only the two bishops ?
352       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
353           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
354       {
355           // Check for KBP vs KB with only a single pawn that is almost
356           // certainly a draw or at least two pawns.
357           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
358           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
359       }
360       else
361           // Endgame with opposite-colored bishops, but also other pieces. Still
362           // a bit drawish, but not as drawish as with only the two bishops.
363            sf = ScaleFactor(50);
364   }
365
366   // Interpolate between the middle game and the endgame score
367   margin = margins[pos.side_to_move()];
368   Value v = scale_by_game_phase(bonus, phase, sf);
369   return pos.side_to_move() == WHITE ? v : -v;
370 }
371
372 } // namespace
373
374
375 /// init_eval() initializes various tables used by the evaluation function
376
377 void init_eval(int threads) {
378
379   assert(threads <= MAX_THREADS);
380
381   for (int i = 0; i < MAX_THREADS; i++)
382   {
383       if (i >= threads)
384       {
385           delete PawnTable[i];
386           delete MaterialTable[i];
387           PawnTable[i] = NULL;
388           MaterialTable[i] = NULL;
389           continue;
390       }
391       if (!PawnTable[i])
392           PawnTable[i] = new PawnInfoTable();
393
394       if (!MaterialTable[i])
395           MaterialTable[i] = new MaterialInfoTable();
396   }
397 }
398
399
400 /// quit_eval() releases heap-allocated memory at program termination
401
402 void quit_eval() {
403
404   init_eval(0);
405 }
406
407
408 /// read_weights() reads evaluation weights from the corresponding UCI parameters
409
410 void read_weights(Color us) {
411
412   // King safety is asymmetrical. Our king danger level is weighted by
413   // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
414   const int kingDangerUs   = (us == WHITE ? KingDangerUs   : KingDangerThem);
415   const int kingDangerThem = (us == WHITE ? KingDangerThem : KingDangerUs);
416
417   Weights[Mobility]       = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
418   Weights[PawnStructure]  = weight_option("Pawn Structure (Middle Game)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
419   Weights[PassedPawns]    = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
420   Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
421   Weights[kingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
422   Weights[kingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
423
424   // If running in analysis mode, make sure we use symmetrical king safety. We do this
425   // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
426   if (Options["UCI_AnalyseMode"].value<bool>())
427       Weights[kingDangerUs] = Weights[kingDangerThem] = (Weights[kingDangerUs] + Weights[kingDangerThem]) / 2;
428
429   init_safety();
430 }
431
432
433 namespace {
434
435   // init_eval_info() initializes king bitboards for given color adding
436   // pawn attacks. To be done at the beginning of the evaluation.
437
438   template<Color Us, bool HasPopCnt>
439   void init_eval_info(const Position& pos, EvalInfo& ei) {
440
441     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
442     const Color Them = (Us == WHITE ? BLACK : WHITE);
443
444     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
445     ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
446
447     // Init king safety tables only if we are going to use them
448     if (   pos.piece_count(Us, QUEEN)
449         && pos.non_pawn_material(Us) >= QueenValueMidgame + RookValueMidgame)
450     {
451         ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
452         b &= ei.attackedBy[Us][PAWN];
453         ei.kingAttackersCount[Us] = b ? count_1s<Max15>(b) / 2 : 0;
454         ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
455     } else
456         ei.kingZone[Us] = ei.kingAttackersCount[Us] = 0;
457   }
458
459
460   // evaluate_outposts() evaluates bishop and knight outposts squares
461
462   template<PieceType Piece, Color Us>
463   Score evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
464
465     const Color Them = (Us == WHITE ? BLACK : WHITE);
466
467     assert (Piece == BISHOP || Piece == KNIGHT);
468
469     // Initial bonus based on square
470     Value bonus = OutpostBonus[Piece == BISHOP][relative_square(Us, s)];
471
472     // Increase bonus if supported by pawn, especially if the opponent has
473     // no minor piece which can exchange the outpost piece.
474     if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
475     {
476         if (    pos.pieces(KNIGHT, Them) == EmptyBoardBB
477             && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
478             bonus += bonus + bonus / 2;
479         else
480             bonus += bonus / 2;
481     }
482     return make_score(bonus, bonus);
483   }
484
485
486   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
487
488   template<PieceType Piece, Color Us, bool HasPopCnt>
489   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
490
491     Bitboard b;
492     Square s, ksq;
493     int mob;
494     File f;
495     Score bonus = SCORE_ZERO;
496
497     const BitCountType Full  = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64 : CNT32;
498     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
499     const Color Them = (Us == WHITE ? BLACK : WHITE);
500     const Square* ptr = pos.piece_list_begin(Us, Piece);
501
502     ei.attackedBy[Us][Piece] = EmptyBoardBB;
503
504     while ((s = *ptr++) != SQ_NONE)
505     {
506         // Find attacked squares, including x-ray attacks for bishops and rooks
507         if (Piece == KNIGHT || Piece == QUEEN)
508             b = pos.attacks_from<Piece>(s);
509         else if (Piece == BISHOP)
510             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
511         else if (Piece == ROOK)
512             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
513         else
514             assert(false);
515
516         // Update attack info
517         ei.attackedBy[Us][Piece] |= b;
518
519         // King attacks
520         if (b & ei.kingZone[Us])
521         {
522             ei.kingAttackersCount[Us]++;
523             ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
524             Bitboard bb = (b & ei.attackedBy[Them][KING]);
525             if (bb)
526                 ei.kingAdjacentZoneAttacksCount[Us] += count_1s<Max15>(bb);
527         }
528
529         // Mobility
530         mob = (Piece != QUEEN ? count_1s<Max15>(b & mobilityArea)
531                               : count_1s<Full >(b & mobilityArea));
532
533         mobility += MobilityBonus[Piece][mob];
534
535         // Decrease score if we are attacked by an enemy pawn. Remaining part
536         // of threat evaluation must be done later when we have full attack info.
537         if (bit_is_set(ei.attackedBy[Them][PAWN], s))
538             bonus -= ThreatedByPawnPenalty[Piece];
539
540         // Bishop and knight outposts squares
541         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Us))
542             bonus += evaluate_outposts<Piece, Us>(pos, ei, s);
543
544         // Queen or rook on 7th rank
545         if (  (Piece == ROOK || Piece == QUEEN)
546             && relative_rank(Us, s) == RANK_7
547             && relative_rank(Us, pos.king_square(Them)) == RANK_8)
548         {
549             bonus += (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
550         }
551
552         // Special extra evaluation for rooks
553         if (Piece == ROOK)
554         {
555             // Open and half-open files
556             f = square_file(s);
557             if (ei.pi->file_is_half_open(Us, f))
558             {
559                 if (ei.pi->file_is_half_open(Them, f))
560                     bonus += RookOpenFileBonus;
561                 else
562                     bonus += RookHalfOpenFileBonus;
563             }
564
565             // Penalize rooks which are trapped inside a king. Penalize more if
566             // king has lost right to castle.
567             if (mob > 6 || ei.pi->file_is_half_open(Us, f))
568                 continue;
569
570             ksq = pos.king_square(Us);
571
572             if (    square_file(ksq) >= FILE_E
573                 &&  square_file(s) > square_file(ksq)
574                 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
575             {
576                 // Is there a half-open file between the king and the edge of the board?
577                 if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
578                     bonus -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
579                                                            : (TrappedRookPenalty - mob * 16), 0);
580             }
581             else if (    square_file(ksq) <= FILE_D
582                      &&  square_file(s) < square_file(ksq)
583                      && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
584             {
585                 // Is there a half-open file between the king and the edge of the board?
586                 if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
587                     bonus -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
588                                                            : (TrappedRookPenalty - mob * 16), 0);
589             }
590         }
591     }
592     return bonus;
593   }
594
595
596   // evaluate_threats<>() assigns bonuses according to the type of attacking piece
597   // and the type of attacked one.
598
599   template<Color Us>
600   Score evaluate_threats(const Position& pos, EvalInfo& ei) {
601
602     const Color Them = (Us == WHITE ? BLACK : WHITE);
603
604     Bitboard b;
605     Score bonus = SCORE_ZERO;
606
607     // Enemy pieces not defended by a pawn and under our attack
608     Bitboard weakEnemies =  pos.pieces_of_color(Them)
609                           & ~ei.attackedBy[Them][PAWN]
610                           & ei.attackedBy[Us][0];
611     if (!weakEnemies)
612         return SCORE_ZERO;
613
614     // Add bonus according to type of attacked enemy piece and to the
615     // type of attacking piece, from knights to queens. Kings are not
616     // considered because are already handled in king evaluation.
617     for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
618     {
619         b = ei.attackedBy[Us][pt1] & weakEnemies;
620         if (b)
621             for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
622                 if (b & pos.pieces(pt2))
623                     bonus += ThreatBonus[pt1][pt2];
624     }
625     return bonus;
626   }
627
628
629   // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
630   // pieces of a given color.
631
632   template<Color Us, bool HasPopCnt>
633   Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility) {
634
635     const Color Them = (Us == WHITE ? BLACK : WHITE);
636
637     Score bonus = mobility = SCORE_ZERO;
638
639     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
640     const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
641
642     bonus += evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
643     bonus += evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
644     bonus += evaluate_pieces<ROOK,   Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
645     bonus += evaluate_pieces<QUEEN,  Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
646
647     // Sum up all attacked squares
648     ei.attackedBy[Us][0] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
649                            | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
650                            | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
651     return bonus;
652   }
653
654
655   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
656
657   template<Color Us, bool HasPopCnt>
658   Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
659
660     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
661     const Color Them = (Us == WHITE ? BLACK : WHITE);
662
663     Bitboard undefended, b, b1, b2, safe;
664     int attackUnits;
665     const Square ksq = pos.king_square(Us);
666
667     // King shelter
668     Score bonus = ei.pi->king_shelter<Us>(pos, ksq);
669
670     // King safety. This is quite complicated, and is almost certainly far
671     // from optimally tuned.
672     if (   ei.kingAttackersCount[Them] >= 2
673         && ei.kingAdjacentZoneAttacksCount[Them])
674     {
675         // Find the attacked squares around the king which has no defenders
676         // apart from the king itself
677         undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
678         undefended &= ~(  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
679                         | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
680                         | ei.attackedBy[Us][QUEEN]);
681
682         // Initialize the 'attackUnits' variable, which is used later on as an
683         // index to the KingDangerTable[] array. The initial value is based on
684         // the number and types of the enemy's attacking pieces, the number of
685         // attacked and undefended squares around our king, the square of the
686         // king, and the quality of the pawn shelter.
687         attackUnits =  Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
688                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s<Max15>(undefended))
689                      + InitKingDanger[relative_square(Us, ksq)]
690                      - mg_value(ei.pi->king_shelter<Us>(pos, ksq)) / 32;
691
692         // Analyse enemy's safe queen contact checks. First find undefended
693         // squares around the king attacked by enemy queen...
694         b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces_of_color(Them);
695         if (b)
696         {
697             // ...then remove squares not supported by another enemy piece
698             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
699                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
700             if (b)
701                 attackUnits +=  QueenContactCheckBonus
702                               * count_1s<Max15>(b)
703                               * (Them == pos.side_to_move() ? 2 : 1);
704         }
705
706         // Analyse enemy's safe rook contact checks. First find undefended
707         // squares around the king attacked by enemy rooks...
708         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces_of_color(Them);
709
710         // Consider only squares where the enemy rook gives check
711         b &= RookPseudoAttacks[ksq];
712
713         if (b)
714         {
715             // ...then remove squares not supported by another enemy piece
716             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
717                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
718             if (b)
719                 attackUnits +=  RookContactCheckBonus
720                               * count_1s<Max15>(b)
721                               * (Them == pos.side_to_move() ? 2 : 1);
722         }
723
724         // Analyse enemy's safe distance checks for sliders and knights
725         safe = ~(pos.pieces_of_color(Them) | ei.attackedBy[Us][0]);
726
727         b1 = pos.attacks_from<ROOK>(ksq) & safe;
728         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
729
730         // Enemy queen safe checks
731         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
732         if (b)
733             attackUnits += QueenCheckBonus * count_1s<Max15>(b);
734
735         // Enemy rooks safe checks
736         b = b1 & ei.attackedBy[Them][ROOK];
737         if (b)
738             attackUnits += RookCheckBonus * count_1s<Max15>(b);
739
740         // Enemy bishops safe checks
741         b = b2 & ei.attackedBy[Them][BISHOP];
742         if (b)
743             attackUnits += BishopCheckBonus * count_1s<Max15>(b);
744
745         // Enemy knights safe checks
746         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
747         if (b)
748             attackUnits += KnightCheckBonus * count_1s<Max15>(b);
749
750         // To index KingDangerTable[] attackUnits must be in [0, 99] range
751         attackUnits = Min(99, Max(0, attackUnits));
752
753         // Finally, extract the king danger score from the KingDangerTable[]
754         // array and subtract the score from evaluation. Set also margins[]
755         // value that will be used for pruning because this value can sometimes
756         // be very big, and so capturing a single attacking piece can therefore
757         // result in a score change far bigger than the value of the captured piece.
758         bonus -= KingDangerTable[Us][attackUnits];
759         margins[Us] += mg_value(KingDangerTable[Us][attackUnits]);
760     }
761     return bonus;
762   }
763
764
765   // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
766
767   template<Color Us>
768   Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
769
770     const Color Them = (Us == WHITE ? BLACK : WHITE);
771
772     Score bonus = SCORE_ZERO;
773     Bitboard squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
774     Bitboard b = ei.pi->passed_pawns(Us);
775
776     if (!b)
777         return SCORE_ZERO;
778
779     do {
780         Square s = pop_1st_bit(&b);
781
782         assert(pos.pawn_is_passed(Us, s));
783
784         int r = int(relative_rank(Us, s) - RANK_2);
785         int rr = r * (r - 1);
786
787         // Base bonus based on rank
788         Value mbonus = Value(20 * rr);
789         Value ebonus = Value(10 * (rr + r + 1));
790
791         if (rr)
792         {
793             Square blockSq = s + pawn_push(Us);
794
795             // Adjust bonus based on kings proximity
796             ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * rr);
797             ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
798             ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * rr);
799
800             // If the pawn is free to advance, increase bonus
801             if (pos.square_is_empty(blockSq))
802             {
803                 squaresToQueen = squares_in_front_of(Us, s);
804                 defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
805
806                 // If there is an enemy rook or queen attacking the pawn from behind,
807                 // add all X-ray attacks by the rook or queen. Otherwise consider only
808                 // the squares in the pawn's path attacked or occupied by the enemy.
809                 if (   (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them))
810                     && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
811                     unsafeSquares = squaresToQueen;
812                 else
813                     unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces_of_color(Them));
814
815                 // If there aren't enemy attacks or pieces along the path to queen give
816                 // huge bonus. Even bigger if we protect the pawn's path.
817                 if (!unsafeSquares)
818                     ebonus += Value(rr * (squaresToQueen == defendedSquares ? 17 : 15));
819                 else
820                     // OK, there are enemy attacks or pieces (but not pawns). Are those
821                     // squares which are attacked by the enemy also attacked by us ?
822                     // If yes, big bonus (but smaller than when there are no enemy attacks),
823                     // if no, somewhat smaller bonus.
824                     ebonus += Value(rr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
825
826                 // At last, add a small bonus when there are no *friendly* pieces
827                 // in the pawn's path.
828                 if (!(squaresToQueen & pos.pieces_of_color(Us)))
829                     ebonus += Value(rr);
830             }
831         } // rr != 0
832
833         // Increase the bonus if the passed pawn is supported by a friendly pawn
834         // on the same rank and a bit smaller if it's on the previous rank.
835         supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
836         if (supportingPawns & rank_bb(s))
837             ebonus += Value(r * 20);
838         else if (supportingPawns & rank_bb(s - pawn_push(Us)))
839             ebonus += Value(r * 12);
840
841         // Rook pawns are a special case: They are sometimes worse, and
842         // sometimes better than other passed pawns. It is difficult to find
843         // good rules for determining whether they are good or bad. For now,
844         // we try the following: Increase the value for rook pawns if the
845         // other side has no pieces apart from a knight, and decrease the
846         // value if the other side has a rook or queen.
847         if (square_file(s) == FILE_A || square_file(s) == FILE_H)
848         {
849             if (pos.non_pawn_material(Them) <= KnightValueMidgame)
850                 ebonus += ebonus / 4;
851             else if (pos.pieces(ROOK, QUEEN, Them))
852                 ebonus -= ebonus / 4;
853         }
854         bonus += make_score(mbonus, ebonus);
855
856     } while (b);
857
858     // Add the scores to the middle game and endgame eval
859     return apply_weight(bonus, Weights[PassedPawns]);
860   }
861
862
863   // evaluate_space() computes the space evaluation for a given side. The
864   // space evaluation is a simple bonus based on the number of safe squares
865   // available for minor pieces on the central four files on ranks 2--4. Safe
866   // squares one, two or three squares behind a friendly pawn are counted
867   // twice. Finally, the space bonus is scaled by a weight taken from the
868   // material hash table. The aim is to improve play on game opening.
869   template<Color Us, bool HasPopCnt>
870   int evaluate_space(const Position& pos, EvalInfo& ei) {
871
872     const BitCountType Max15 = HasPopCnt ? CNT_POPCNT : CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
873     const Color Them = (Us == WHITE ? BLACK : WHITE);
874
875     // Find the safe squares for our pieces inside the area defined by
876     // SpaceMask[]. A square is unsafe if it is attacked by an enemy
877     // pawn, or if it is undefended and attacked by an enemy piece.
878     Bitboard safe =   SpaceMask[Us]
879                    & ~pos.pieces(PAWN, Us)
880                    & ~ei.attackedBy[Them][PAWN]
881                    & (ei.attackedBy[Us][0] | ~ei.attackedBy[Them][0]);
882
883     // Find all squares which are at most three squares behind some friendly pawn
884     Bitboard behind = pos.pieces(PAWN, Us);
885     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
886     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
887
888     return count_1s<Max15>(safe) + count_1s<Max15>(behind & safe);
889   }
890
891
892   // apply_weight() applies an evaluation weight to a value trying to prevent overflow
893
894   inline Score apply_weight(Score v, Score w) {
895       return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
896                         (int(eg_value(v)) * eg_value(w)) / 0x100);
897   }
898
899
900   // scale_by_game_phase() interpolates between a middle game and an endgame score,
901   // based on game phase. It also scales the return value by a ScaleFactor array.
902
903   Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf) {
904
905     assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
906     assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
907     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
908
909     Value eg = eg_value(v);
910     Value ev = Value((eg * int(sf)) / SCALE_FACTOR_NORMAL);
911
912     int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
913     return Value(result & ~(GrainSize - 1));
914   }
915
916
917   // weight_option() computes the value of an evaluation weight, by combining
918   // two UCI-configurable weights (midgame and endgame) with an internal weight.
919
920   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
921
922     // Scale option value from 100 to 256
923     int mg = Options[mgOpt].value<int>() * 256 / 100;
924     int eg = Options[egOpt].value<int>() * 256 / 100;
925
926     return apply_weight(make_score(mg, eg), internalWeight);
927   }
928
929
930   // init_safety() initizes the king safety evaluation, based on UCI
931   // parameters. It is called from read_weights().
932
933   void init_safety() {
934
935     const Value MaxSlope = Value(30);
936     const Value Peak = Value(1280);
937     Value t[100];
938
939     // First setup the base table
940     for (int i = 0; i < 100; i++)
941     {
942         t[i] = Value(int(0.4 * i * i));
943
944         if (i > 0)
945             t[i] = Min(t[i], t[i - 1] + MaxSlope);
946
947         t[i] = Min(t[i], Peak);
948     }
949
950     // Then apply the weights and get the final KingDangerTable[] array
951     for (Color c = WHITE; c <= BLACK; c++)
952         for (int i = 0; i < 100; i++)
953             KingDangerTable[c][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);
954   }
955 }