fe28da3f0692ad0253d29f61eea4a70311eeffa7
[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         // Analyse enemy's discovered checks (only for non-pawns right now,
765         // consider adding pawns later).
766         b = pos.discovered_check_candidates(Them) & ~pos.pieces(PAWN);
767         if (b)
768             attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
769
770         // To index KingDangerTable[] attackUnits must be in [0, 99] range
771         attackUnits = Min(99, Max(0, attackUnits));
772
773         // Finally, extract the king danger score from the KingDangerTable[]
774         // array and subtract the score from evaluation. Set also ei.kingDanger[]
775         // value that will be used for pruning because this value can sometimes
776         // be very big, and so capturing a single attacking piece can therefore
777         // result in a score change far bigger than the value of the captured piece.
778         ei.value -= Sign[Us] * KingDangerTable[Us][attackUnits];
779         ei.kingDanger[Us] = mg_value(KingDangerTable[Us][attackUnits]);
780     }
781   }
782
783
784   // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
785
786   template<Color Us>
787   void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
788
789     const Color Them = (Us == WHITE ? BLACK : WHITE);
790
791     Bitboard squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
792     Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(Us);
793
794     while (b)
795     {
796         Square s = pop_1st_bit(&b);
797
798         assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
799         assert(pos.pawn_is_passed(Us, s));
800
801         int r = int(relative_rank(Us, s) - RANK_2);
802         int tr = r * (r - 1);
803
804         // Base bonus based on rank
805         Value mbonus = Value(20 * tr);
806         Value ebonus = Value(10 + r * r * 10);
807
808         if (tr)
809         {
810             Square blockSq = s + pawn_push(Us);
811
812             // Adjust bonus based on kings proximity
813             ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * tr);
814             ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * 1 * tr);
815             ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * tr);
816
817             // If the pawn is free to advance, increase bonus
818             if (pos.square_is_empty(blockSq))
819             {
820                 squaresToQueen = squares_in_front_of(Us, s);
821                 defendedSquares = squaresToQueen & ei.attacked_by(Us);
822
823                 // There are no enemy pawns in the pawn's path
824                 assert(!(squaresToQueen & pos.pieces(PAWN, Them)));
825
826                 // If there is an enemy rook or queen attacking the pawn from behind,
827                 // add all X-ray attacks by the rook or queen. Otherwise consider only
828                 // the squares in the pawn's path attacked or occupied by the enemy.
829                 if (   (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them))
830                     && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<QUEEN>(s)))
831                     unsafeSquares = squaresToQueen;
832                 else
833                     unsafeSquares = squaresToQueen & (ei.attacked_by(Them) | pos.pieces_of_color(Them));
834
835                 // If there aren't enemy attacks or pieces along the path to queen give
836                 // huge bonus. Even bigger if we protect the pawn's path.
837                 if (!unsafeSquares)
838                     ebonus += Value(tr * (squaresToQueen == defendedSquares ? 17 : 15));
839                 else
840                     // OK, there are enemy attacks or pieces (but not pawns). Are those
841                     // squares which are attacked by the enemy also attacked by us ?
842                     // If yes, big bonus (but smaller than when there are no enemy attacks),
843                     // if no, somewhat smaller bonus.
844                     ebonus += Value(tr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
845
846                 // At last, add a small bonus when there are no *friendly* pieces
847                 // in the pawn's path.
848                 if (!(squaresToQueen & pos.pieces_of_color(Us)))
849                     ebonus += Value(tr);
850             }
851         } // tr != 0
852
853         // Increase the bonus if the passed pawn is supported by a friendly pawn
854         // on the same rank and a bit smaller if it's on the previous rank.
855         supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
856         if (supportingPawns & rank_bb(s))
857             ebonus += Value(r * 20);
858         else if (supportingPawns & rank_bb(s - pawn_push(Us)))
859             ebonus += Value(r * 12);
860
861         // Rook pawns are a special case: They are sometimes worse, and
862         // sometimes better than other passed pawns. It is difficult to find
863         // good rules for determining whether they are good or bad. For now,
864         // we try the following: Increase the value for rook pawns if the
865         // other side has no pieces apart from a knight, and decrease the
866         // value if the other side has a rook or queen.
867         if (square_file(s) == FILE_A || square_file(s) == FILE_H)
868         {
869             if (   pos.non_pawn_material(Them) <= KnightValueMidgame
870                 && pos.piece_count(Them, KNIGHT) <= 1)
871                 ebonus += ebonus / 4;
872             else if (pos.pieces(ROOK, QUEEN, Them))
873                 ebonus -= ebonus / 4;
874         }
875
876         // Add the scores for this pawn to the middle game and endgame eval
877         ei.value += Sign[Us] * apply_weight(make_score(mbonus, ebonus), Weights[PassedPawns]);
878
879     } // while
880   }
881
882
883   // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides
884
885   void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
886
887     int movesToGo[2] = {0, 0};
888     Square pawnToGo[2] = {SQ_NONE, SQ_NONE};
889
890     for (Color c = WHITE; c <= BLACK; c++)
891     {
892         // Skip evaluation if other side has non-pawn pieces
893         if (pos.non_pawn_material(opposite_color(c)))
894             continue;
895
896         Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(c);
897
898         while (b)
899         {
900             Square s = pop_1st_bit(&b);
901             Square queeningSquare = relative_square(c, make_square(square_file(s), RANK_8));
902             int d =  square_distance(s, queeningSquare)
903                    - square_distance(pos.king_square(opposite_color(c)), queeningSquare)
904                    + int(c != pos.side_to_move());
905
906             if (d < 0)
907             {
908                 int mtg = RANK_8 - relative_rank(c, s);
909                 int blockerCount = count_1s_max_15(squares_in_front_of(c, s) & pos.occupied_squares());
910                 mtg += blockerCount;
911                 d += blockerCount;
912                 if (d < 0 && (!movesToGo[c] || movesToGo[c] > mtg))
913                 {
914                     movesToGo[c] = mtg;
915                     pawnToGo[c] = s;
916                 }
917             }
918         }
919     }
920
921     // Neither side has an unstoppable passed pawn?
922     if (!(movesToGo[WHITE] | movesToGo[BLACK]))
923         return;
924
925     // Does only one side have an unstoppable passed pawn?
926     if (!movesToGo[WHITE] || !movesToGo[BLACK])
927     {
928         Color winnerSide = movesToGo[WHITE] ? WHITE : BLACK;
929         ei.value += make_score(0, Sign[winnerSide] * (UnstoppablePawnValue - Value(0x40 * movesToGo[winnerSide])));
930     }
931     else
932     {   // Both sides have unstoppable pawns! Try to find out who queens
933         // first. We begin by transforming 'movesToGo' to the number of
934         // plies until the pawn queens for both sides.
935         movesToGo[WHITE] *= 2;
936         movesToGo[BLACK] *= 2;
937         movesToGo[pos.side_to_move()]--;
938
939         Color winnerSide = movesToGo[WHITE] < movesToGo[BLACK] ? WHITE : BLACK;
940         Color loserSide = opposite_color(winnerSide);
941
942         // If one side queens at least three plies before the other, that side wins
943         if (movesToGo[winnerSide] <= movesToGo[loserSide] - 3)
944             ei.value += Sign[winnerSide] * make_score(0, UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2)));
945
946         // If one side queens one ply before the other and checks the king or attacks
947         // the undefended opponent's queening square, that side wins. To avoid cases
948         // where the opponent's king could move somewhere before first pawn queens we
949         // consider only free paths to queen for both pawns.
950         else if (   !(squares_in_front_of(WHITE, pawnToGo[WHITE]) & pos.occupied_squares())
951                  && !(squares_in_front_of(BLACK, pawnToGo[BLACK]) & pos.occupied_squares()))
952         {
953             assert(movesToGo[loserSide] - movesToGo[winnerSide] == 1);
954
955             Square winnerQSq = relative_square(winnerSide, make_square(square_file(pawnToGo[winnerSide]), RANK_8));
956             Square loserQSq = relative_square(loserSide, make_square(square_file(pawnToGo[loserSide]), RANK_8));
957
958             Bitboard b = pos.occupied_squares();
959             clear_bit(&b, pawnToGo[winnerSide]);
960             clear_bit(&b, pawnToGo[loserSide]);
961             b = queen_attacks_bb(winnerQSq, b);
962
963             if (  (b & pos.pieces(KING, loserSide))
964                 ||(bit_is_set(b, loserQSq) && !bit_is_set(ei.attacked_by(loserSide), loserQSq)))
965                 ei.value += Sign[winnerSide] * make_score(0, UnstoppablePawnValue - Value(0x40 * (movesToGo[winnerSide]/2)));
966         }
967     }
968   }
969
970
971   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
972   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
973   // if it is.
974
975   void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo &ei) {
976
977     assert(square_is_ok(s));
978     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
979
980     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
981     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
982
983     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
984         && pos.see(s, b6) < 0
985         && pos.see(s, b8) < 0)
986     {
987         ei.value -= Sign[us] * TrappedBishopA7H7Penalty;
988     }
989   }
990
991
992   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
993   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
994   // black), and assigns a penalty if it is. This pattern can obviously
995   // only occur in Chess960 games.
996
997   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei) {
998
999     Piece pawn = piece_of_color_and_type(us, PAWN);
1000     Square b2, b3, c3;
1001
1002     assert(Chess960);
1003     assert(square_is_ok(s));
1004     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1005
1006     if (square_file(s) == FILE_A)
1007     {
1008         b2 = relative_square(us, SQ_B2);
1009         b3 = relative_square(us, SQ_B3);
1010         c3 = relative_square(us, SQ_C3);
1011     }
1012     else
1013     {
1014         b2 = relative_square(us, SQ_G2);
1015         b3 = relative_square(us, SQ_G3);
1016         c3 = relative_square(us, SQ_F3);
1017     }
1018
1019     if (pos.piece_on(b2) == pawn)
1020     {
1021         Score penalty;
1022
1023         if (!pos.square_is_empty(b3))
1024             penalty = 2 * TrappedBishopA1H1Penalty;
1025         else if (pos.piece_on(c3) == pawn)
1026             penalty = TrappedBishopA1H1Penalty;
1027         else
1028             penalty = TrappedBishopA1H1Penalty / 2;
1029
1030         ei.value -= Sign[us] * penalty;
1031     }
1032   }
1033
1034
1035   // evaluate_space() computes the space evaluation for a given side. The
1036   // space evaluation is a simple bonus based on the number of safe squares
1037   // available for minor pieces on the central four files on ranks 2--4. Safe
1038   // squares one, two or three squares behind a friendly pawn are counted
1039   // twice. Finally, the space bonus is scaled by a weight taken from the
1040   // material hash table.
1041   template<Color Us, bool HasPopCnt>
1042   void evaluate_space(const Position& pos, EvalInfo& ei) {
1043
1044     const Color Them = (Us == WHITE ? BLACK : WHITE);
1045
1046     // Find the safe squares for our pieces inside the area defined by
1047     // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
1048     // pawn, or if it is undefended and attacked by an enemy piece.
1049     Bitboard safeSquares =   SpaceMask[Us]
1050                           & ~pos.pieces(PAWN, Us)
1051                           & ~ei.attacked_by(Them, PAWN)
1052                           & (ei.attacked_by(Us) | ~ei.attacked_by(Them));
1053
1054     // Find all squares which are at most three squares behind some friendly pawn
1055     Bitboard behindFriendlyPawns = pos.pieces(PAWN, Us);
1056     behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >>  8 : behindFriendlyPawns <<  8);
1057     behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >> 16 : behindFriendlyPawns << 16);
1058
1059     int space =  count_1s_max_15<HasPopCnt>(safeSquares)
1060                + count_1s_max_15<HasPopCnt>(behindFriendlyPawns & safeSquares);
1061
1062     ei.value += Sign[Us] * apply_weight(make_score(space * ei.mi->space_weight(), 0), Weights[Space]);
1063   }
1064
1065
1066   // apply_weight() applies an evaluation weight to a value trying to prevent overflow
1067
1068   inline Score apply_weight(Score v, Score w) {
1069       return make_score((int(mg_value(v)) * mg_value(w)) / 0x100, (int(eg_value(v)) * eg_value(w)) / 0x100);
1070   }
1071
1072
1073   // scale_by_game_phase() interpolates between a middle game and an endgame
1074   // score, based on game phase.  It also scales the return value by a
1075   // ScaleFactor array.
1076
1077   Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]) {
1078
1079     assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
1080     assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
1081     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1082
1083     Value ev = apply_scale_factor(eg_value(v), sf[(eg_value(v) > Value(0) ? WHITE : BLACK)]);
1084
1085     int result = (mg_value(v) * ph + ev * (128 - ph)) / 128;
1086     return Value(result & ~(GrainSize - 1));
1087   }
1088
1089
1090   // weight_option() computes the value of an evaluation weight, by combining
1091   // two UCI-configurable weights (midgame and endgame) with an internal weight.
1092
1093   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
1094
1095     // Scale option value from 100 to 256
1096     int mg = get_option_value_int(mgOpt) * 256 / 100;
1097     int eg = get_option_value_int(egOpt) * 256 / 100;
1098
1099     return apply_weight(make_score(mg, eg), internalWeight);
1100   }
1101
1102   // init_safety() initizes the king safety evaluation, based on UCI
1103   // parameters. It is called from read_weights().
1104
1105   void init_safety() {
1106
1107     const Value MaxSlope = Value(30);
1108     const Value Peak = Value(1280);
1109     Value t[100];
1110
1111     // First setup the base table
1112     for (int i = 0; i < 100; i++)
1113     {
1114         t[i] = Value(int(0.4 * i * i));
1115
1116         if (i > 0)
1117             t[i] = Min(t[i], t[i - 1] + MaxSlope);
1118
1119         t[i] = Min(t[i], Peak);
1120     }
1121
1122     // Then apply the weights and get the final KingDangerTable[] array
1123     for (Color c = WHITE; c <= BLACK; c++)
1124         for (int i = 0; i < 100; i++)
1125             KingDangerTable[c][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);
1126   }
1127 }