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