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