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