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