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