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