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