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