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