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