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