Introduce init_attack_tables() in evaluate()
[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 init_attack_tables(const Position& pos, EvalInfo& ei);
247
248   template<Color Us, bool HasPopCnt>
249   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
250
251   template<Color Us, bool HasPopCnt>
252   void evaluate_king(const Position& pos, EvalInfo& ei);
253
254   template<Color Us>
255   void evaluate_threats(const Position& pos, EvalInfo& ei);
256
257   template<Color Us, bool HasPopCnt>
258   void evaluate_space(const Position& pos, EvalInfo& ei);
259
260   template<Color Us>
261   void evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
262
263   void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
264   void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo& ei);
265   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei);
266   inline Score apply_weight(Score v, Score weight);
267   Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]);
268   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
269   void init_safety();
270 }
271
272
273 ////
274 //// Functions
275 ////
276
277 /// evaluate() is the main evaluation function. It always computes two
278 /// values, an endgame score and a middle game score, and interpolates
279 /// between them based on the remaining material.
280 Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
281
282     return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
283                         : do_evaluate<false>(pos, ei, threadID);
284 }
285
286 namespace {
287
288 template<bool HasPopCnt>
289 Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
290
291   ScaleFactor factor[2];
292
293   assert(pos.is_ok());
294   assert(threadID >= 0 && threadID < MAX_THREADS);
295   assert(!pos.is_check());
296
297   memset(&ei, 0, sizeof(EvalInfo));
298
299   // Initialize by reading the incrementally updated scores included in the
300   // position object (material + piece square tables)
301   ei.value = pos.value();
302
303   // Probe the material hash table
304   ei.mi = MaterialTable[threadID]->get_material_info(pos);
305   ei.value += ei.mi->material_value();
306
307   // If we have a specialized evaluation function for the current material
308   // configuration, call it and return
309   if (ei.mi->specialized_eval_exists())
310       return ei.mi->evaluate(pos);
311
312   // After get_material_info() call that modifies them
313   factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
314   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
315
316   // Probe the pawn hash table
317   ei.pi = PawnTable[threadID]->get_pawn_info(pos);
318   ei.value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
319
320   // Initialize attack bitboards with pawns evaluation
321   init_attack_tables<WHITE, HasPopCnt>(pos, ei);
322   init_attack_tables<BLACK, HasPopCnt>(pos, ei);
323
324   // Evaluate pieces
325   evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei);
326   evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei);
327
328   // Kings. Kings are evaluated after all other pieces for both sides,
329   // because we need complete attack information for all pieces when computing
330   // the king safety evaluation.
331   evaluate_king<WHITE, HasPopCnt>(pos, ei);
332   evaluate_king<BLACK, HasPopCnt>(pos, ei);
333
334   // Evaluate tactical threats, we need full attack info including king
335   evaluate_threats<WHITE>(pos, ei);
336   evaluate_threats<BLACK>(pos, ei);
337
338   // Evaluate passed pawns, we need full attack info including king
339   evaluate_passed_pawns<WHITE>(pos, ei);
340   evaluate_passed_pawns<BLACK>(pos, ei);
341
342   // If one side has only a king, check whether exsists any unstoppable passed pawn
343   if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
344       evaluate_unstoppable_pawns(pos, ei);
345
346   Phase phase = ei.mi->game_phase();
347
348   // Middle-game specific evaluation terms
349   if (phase > PHASE_ENDGAME)
350   {
351     // Pawn storms in positions with opposite castling
352     if (   square_file(pos.king_square(WHITE)) >= FILE_E
353         && square_file(pos.king_square(BLACK)) <= FILE_D)
354
355         ei.value += make_score(ei.pi->queenside_storm_value(WHITE) - ei.pi->kingside_storm_value(BLACK), 0);
356
357     else if (   square_file(pos.king_square(WHITE)) <= FILE_D
358              && square_file(pos.king_square(BLACK)) >= FILE_E)
359
360         ei.value += make_score(ei.pi->kingside_storm_value(WHITE) - ei.pi->queenside_storm_value(BLACK), 0);
361
362     // Evaluate space for both sides
363     if (ei.mi->space_weight() > 0)
364     {
365         evaluate_space<WHITE, HasPopCnt>(pos, ei);
366         evaluate_space<BLACK, HasPopCnt>(pos, ei);
367     }
368   }
369
370   // Mobility
371   ei.value += apply_weight(ei.mobility, Weights[Mobility]);
372
373   // If we don't already have an unusual scale factor, check for opposite
374   // colored bishop endgames, and use a lower scale for those
375   if (   phase < PHASE_MIDGAME
376       && pos.opposite_colored_bishops()
377       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && eg_value(ei.value) > Value(0))
378           || (factor[BLACK] == SCALE_FACTOR_NORMAL && eg_value(ei.value) < Value(0))))
379   {
380       ScaleFactor sf;
381
382       // Only the two bishops ?
383       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
384           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
385       {
386           // Check for KBP vs KB with only a single pawn that is almost
387           // certainly a draw or at least two pawns.
388           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
389           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
390       }
391       else
392           // Endgame with opposite-colored bishops, but also other pieces. Still
393           // a bit drawish, but not as drawish as with only the two bishops.
394            sf = ScaleFactor(50);
395
396       if (factor[WHITE] == SCALE_FACTOR_NORMAL)
397           factor[WHITE] = sf;
398       if (factor[BLACK] == SCALE_FACTOR_NORMAL)
399           factor[BLACK] = sf;
400   }
401
402   // Interpolate between the middle game and the endgame score
403   return Sign[pos.side_to_move()] * scale_by_game_phase(ei.value, phase, factor);
404 }
405
406 } // namespace
407
408 /// init_eval() initializes various tables used by the evaluation function
409
410 void init_eval(int threads) {
411
412   assert(threads <= MAX_THREADS);
413
414   for (int i = 0; i < MAX_THREADS; i++)
415   {
416     if (i >= threads)
417     {
418         delete PawnTable[i];
419         delete MaterialTable[i];
420         PawnTable[i] = NULL;
421         MaterialTable[i] = NULL;
422         continue;
423     }
424     if (!PawnTable[i])
425         PawnTable[i] = new PawnInfoTable(PawnTableSize);
426     if (!MaterialTable[i])
427         MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
428   }
429 }
430
431
432 /// quit_eval() releases heap-allocated memory at program termination
433
434 void quit_eval() {
435
436   for (int i = 0; i < MAX_THREADS; i++)
437   {
438       delete PawnTable[i];
439       delete MaterialTable[i];
440       PawnTable[i] = NULL;
441       MaterialTable[i] = NULL;
442   }
443 }
444
445
446 /// read_weights() reads evaluation weights from the corresponding UCI parameters
447
448 void read_weights(Color us) {
449
450   // King safety is asymmetrical. Our king danger level is weighted by
451   // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
452   const int kingDangerUs   = (us == WHITE ? KingDangerUs   : KingDangerThem);
453   const int kingDangerThem = (us == WHITE ? KingDangerThem : KingDangerUs);
454
455   Weights[Mobility]       = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
456   Weights[PawnStructure]  = weight_option("Pawn Structure (Middle Game)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
457   Weights[PassedPawns]    = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
458   Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
459   Weights[kingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
460   Weights[kingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
461
462   // If running in analysis mode, make sure we use symmetrical king safety. We do this
463   // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
464   if (get_option_value_bool("UCI_AnalyseMode"))
465       Weights[kingDangerUs] = Weights[kingDangerThem] = (Weights[kingDangerUs] + Weights[kingDangerThem]) / 2;
466
467   init_safety();
468 }
469
470
471 namespace {
472
473   // init_king_tables() initializes king bitboards for both sides adding
474   // pawn attacks. To be done before other evaluations.
475
476   template<Color Us, bool HasPopCnt>
477   void init_attack_tables(const Position& pos, EvalInfo& ei) {
478
479     const Color Them = (Us == WHITE ? BLACK : WHITE);
480
481     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
482     ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
483     ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
484     b &= ei.attackedBy[Us][PAWN];
485     if (b)
486         ei.kingAttackersCount[Us] = count_1s_max_15<HasPopCnt>(b) / 2;
487   }
488
489
490   // evaluate_outposts() evaluates bishop and knight outposts squares
491
492   template<PieceType Piece, Color Us>
493   void evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
494
495     const Color Them = (Us == WHITE ? BLACK : WHITE);
496
497     // Initial bonus based on square
498     Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(Us, s)]
499                                    : KnightOutpostBonus[relative_square(Us, s)]);
500
501     // Increase bonus if supported by pawn, especially if the opponent has
502     // no minor piece which can exchange the outpost piece
503     if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
504     {
505         if (    pos.pieces(KNIGHT, Them) == EmptyBoardBB
506             && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
507             bonus += bonus + bonus / 2;
508         else
509             bonus += bonus / 2;
510     }
511     ei.value += Sign[Us] * make_score(bonus, bonus);
512   }
513
514
515   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
516
517   template<PieceType Piece, Color Us, bool HasPopCnt>
518   void evaluate_pieces(const Position& pos, EvalInfo& ei, Bitboard no_mob_area) {
519
520     Bitboard b;
521     Square s, ksq;
522     int mob;
523     File f;
524
525     const Color Them = (Us == WHITE ? BLACK : WHITE);
526     const Square* ptr = pos.piece_list_begin(Us, Piece);
527
528     while ((s = *ptr++) != SQ_NONE)
529     {
530         // Find attacked squares, including x-ray attacks for bishops and rooks
531         if (Piece == KNIGHT || Piece == QUEEN)
532             b = pos.attacks_from<Piece>(s);
533         else if (Piece == BISHOP)
534             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, Us));
535         else if (Piece == ROOK)
536             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(ROOK, QUEEN, Us));
537         else
538             assert(false);
539
540         // Update attack info
541         ei.attackedBy[Us][Piece] |= b;
542
543         // King attacks
544         if (b & ei.kingZone[Us])
545         {
546             ei.kingAttackersCount[Us]++;
547             ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
548             Bitboard bb = (b & ei.attackedBy[Them][KING]);
549             if (bb)
550                 ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
551         }
552
553         // Mobility
554         mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & no_mob_area)
555                               : count_1s<HasPopCnt>(b & no_mob_area));
556
557         ei.mobility += Sign[Us] * MobilityBonus[Piece][mob];
558
559         // Decrease score if we are attacked by an enemy pawn. Remaining part
560         // of threat evaluation must be done later when we have full attack info.
561         if (bit_is_set(ei.attackedBy[Them][PAWN], s))
562             ei.value -= Sign[Us] * ThreatedByPawnPenalty[Piece];
563
564         // Bishop and knight outposts squares
565         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Us))
566             evaluate_outposts<Piece, Us>(pos, ei, s);
567
568         // Special patterns: trapped bishops on a7/h7/a2/h2
569         // and trapped bishops on a1/h1/a8/h8 in Chess960.
570         if (Piece == BISHOP)
571         {
572             if (bit_is_set(MaskA7H7[Us], s))
573                 evaluate_trapped_bishop_a7h7(pos, s, Us, ei);
574
575             if (Chess960 && bit_is_set(MaskA1H1[Us], s))
576                 evaluate_trapped_bishop_a1h1(pos, s, Us, ei);
577         }
578
579         // Queen or rook on 7th rank
580         if (  (Piece == ROOK || Piece == QUEEN)
581             && relative_rank(Us, s) == RANK_7
582             && relative_rank(Us, pos.king_square(Them)) == RANK_8)
583         {
584             ei.value += Sign[Us] * (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
585         }
586
587         // Special extra evaluation for rooks
588         if (Piece == ROOK)
589         {
590             // Open and half-open files
591             f = square_file(s);
592             if (ei.pi->file_is_half_open(Us, f))
593             {
594                 if (ei.pi->file_is_half_open(Them, f))
595                     ei.value += Sign[Us] * RookOpenFileBonus;
596                 else
597                     ei.value += Sign[Us] * RookHalfOpenFileBonus;
598             }
599
600             // Penalize rooks which are trapped inside a king. Penalize more if
601             // king has lost right to castle.
602             if (mob > 6 || ei.pi->file_is_half_open(Us, f))
603                 continue;
604
605             ksq = pos.king_square(Us);
606
607             if (    square_file(ksq) >= FILE_E
608                 &&  square_file(s) > square_file(ksq)
609                 && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
610             {
611                 // Is there a half-open file between the king and the edge of the board?
612                 if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
613                     ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
614                                                                          : (TrappedRookPenalty - mob * 16), 0);
615             }
616             else if (    square_file(ksq) <= FILE_D
617                      &&  square_file(s) < square_file(ksq)
618                      && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
619             {
620                 // Is there a half-open file between the king and the edge of the board?
621                 if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
622                     ei.value -= Sign[Us] * make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
623                                                                          : (TrappedRookPenalty - mob * 16), 0);
624             }
625         }
626     }
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   void evaluate_threats(const Position& pos, EvalInfo& ei) {
635
636     const Color Them = (Us == WHITE ? BLACK : WHITE);
637
638     Bitboard b;
639     Score bonus = make_score(0, 0);
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;
647
648     // Add bonus according to type of attacked enemy pieces and to the
649     // type of attacking piece, from knights to queens. Kings are not
650     // considered because are already special 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     ei.value += Sign[Us] * 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   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei) {
668
669     const Color Them = (Us == WHITE ? BLACK : WHITE);
670
671     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
672     const Bitboard no_mob_area = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
673
674     evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei, no_mob_area);
675     evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei, no_mob_area);
676     evaluate_pieces<ROOK,   Us, HasPopCnt>(pos, ei, no_mob_area);
677     evaluate_pieces<QUEEN,  Us, HasPopCnt>(pos, ei, no_mob_area);
678
679     // Sum up all attacked squares
680     ei.attackedBy[Us][0] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
681                            | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
682                            | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
683   }
684
685
686   // evaluate_king<>() assigns bonuses and penalties to a king of a given color
687
688   template<Color Us, bool HasPopCnt>
689   void evaluate_king(const Position& pos, EvalInfo& ei) {
690
691     const Color Them = (Us == WHITE ? BLACK : WHITE);
692
693     Bitboard undefended, b, b1, b2, safe;
694     bool sente;
695     int attackUnits, shelter = 0;
696     const Square ksq = pos.king_square(Us);
697
698     // King shelter
699     if (relative_rank(Us, ksq) <= RANK_4)
700     {
701         shelter = ei.pi->get_king_shelter(pos, Us, ksq);
702         ei.value += Sign[Us] * make_score(shelter, 0);
703     }
704
705     // King safety. This is quite complicated, and is almost certainly far
706     // from optimally tuned.
707     if (   pos.piece_count(Them, QUEEN) >= 1
708         && ei.kingAttackersCount[Them]  >= 2
709         && pos.non_pawn_material(Them)  >= QueenValueMidgame + RookValueMidgame
710         && ei.kingAdjacentZoneAttacksCount[Them])
711     {
712         // Is it the attackers turn to move?
713         sente = (Them == pos.side_to_move());
714
715         // Find the attacked squares around the king which has no defenders
716         // apart from the king itself
717         undefended = ei.attacked_by(Them) & ei.attacked_by(Us, KING);
718         undefended &= ~(  ei.attacked_by(Us, PAWN)   | ei.attacked_by(Us, KNIGHT)
719                         | ei.attacked_by(Us, BISHOP) | ei.attacked_by(Us, ROOK)
720                         | ei.attacked_by(Us, QUEEN));
721
722         // Initialize the 'attackUnits' variable, which is used later on as an
723         // index to the KingDangerTable[] array. The initial value is based on
724         // the number and types of the enemy's attacking pieces, the number of
725         // attacked and undefended squares around our king, the square of the
726         // king, and the quality of the pawn shelter.
727         attackUnits =  Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
728                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended))
729                      + InitKingDanger[relative_square(Us, ksq)]
730                      - shelter / 32;
731
732         // Analyse enemy's safe queen contact checks. First find undefended
733         // squares around the king attacked by enemy queen...
734         b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
735         if (b)
736         {
737             // ...then remove squares not supported by another enemy piece
738             b &= (  ei.attacked_by(Them, PAWN)   | ei.attacked_by(Them, KNIGHT)
739                   | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK));
740             if (b)
741                 attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
742         }
743
744         // Analyse enemy's safe distance checks for sliders and knights
745         safe = ~(pos.pieces_of_color(Them) | ei.attacked_by(Us));
746
747         b1 = pos.attacks_from<ROOK>(ksq) & safe;
748         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
749
750         // Enemy queen safe checks
751         b = (b1 | b2) & ei.attacked_by(Them, QUEEN);
752         if (b)
753             attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
754
755         // Enemy rooks safe checks
756         b = b1 & ei.attacked_by(Them, ROOK);
757         if (b)
758             attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
759
760         // Enemy bishops safe checks
761         b = b2 & ei.attacked_by(Them, BISHOP);
762         if (b)
763             attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
764
765         // Enemy knights safe checks
766         b = pos.attacks_from<KNIGHT>(ksq) & ei.attacked_by(Them, KNIGHT) & safe;
767         if (b)
768             attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
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 }