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