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