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