Restrict queen mobility to safe squares
[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-2014 Marco Costalba, Joona Kiiski, Tord Romstad
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 #include <cassert>
21 #include <iomanip>
22 #include <sstream>
23 #include <algorithm>
24
25 #include "bitcount.h"
26 #include "evaluate.h"
27 #include "material.h"
28 #include "pawns.h"
29 #include "thread.h"
30 #include "ucioption.h"
31
32 namespace {
33
34   // Struct EvalInfo contains various information computed and collected
35   // by the evaluation functions.
36   struct EvalInfo {
37
38     // Pointers to material and pawn hash table entries
39     Material::Entry* mi;
40     Pawns::Entry* pi;
41
42     // attackedBy[color][piece type] is a bitboard representing all squares
43     // attacked by a given color and piece type, attackedBy[color][ALL_PIECES]
44     // contains all squares attacked by the given color.
45     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
46
47     // kingRing[color] is the zone around the king which is considered
48     // by the king safety evaluation. This consists of the squares directly
49     // adjacent to the king, and the three (or two, for a king on an edge file)
50     // squares two ranks in front of the king. For instance, if black's king
51     // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
52     // f7, g7, h7, f6, g6 and h6.
53     Bitboard kingRing[COLOR_NB];
54
55     // kingAttackersCount[color] is the number of pieces of the given color
56     // which attack a square in the kingRing of the enemy king.
57     int kingAttackersCount[COLOR_NB];
58
59     // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
60     // given color which attack a square in the kingRing of the enemy king. The
61     // weights of the individual piece types are given by the variables
62     // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
63     // KnightAttackWeight in evaluate.cpp
64     int kingAttackersWeight[COLOR_NB];
65
66     // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
67     // directly adjacent to the king of the given color. Pieces which attack
68     // more than one square are counted multiple times. For instance, if black's
69     // king is on g8 and there's a white knight on g5, this knight adds
70     // 2 to kingAdjacentZoneAttacksCount[BLACK].
71     int kingAdjacentZoneAttacksCount[COLOR_NB];
72
73     Bitboard pinnedPieces[COLOR_NB];
74   };
75
76   namespace Tracing {
77
78     enum Terms { // First 8 entries are for PieceType
79       PST = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERMS_NB
80     };
81
82     Score terms[COLOR_NB][TERMS_NB];
83     EvalInfo ei;
84     ScaleFactor sf;
85
86     double to_cp(Value v);
87     void add_term(int idx, Score term_w, Score term_b = SCORE_ZERO);
88     void format_row(std::stringstream& ss, const char* name, int idx);
89     std::string do_trace(const Position& pos);
90   }
91
92   // Evaluation weights, initialized from UCI options
93   enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
94   struct Weight { int mg, eg; } Weights[6];
95
96   typedef Value V;
97   #define S(mg, eg) make_score(mg, eg)
98
99   // Internal evaluation weights. These are applied on top of the evaluation
100   // weights read from UCI parameters. The purpose is to be able to change
101   // the evaluation weights while keeping the default values of the UCI
102   // parameters at 100, which looks prettier.
103   //
104   // Values modified by Joona Kiiski
105   const Score WeightsInternal[] = {
106     S(289, 344), S(233, 201), S(221, 273), S(46, 0), S(271, 0), S(307, 0)
107   };
108
109   // MobilityBonus[PieceType][attacked] contains bonuses for middle and end
110   // game, indexed by piece type and number of attacked squares not occupied by
111   // friendly pieces.
112   const Score MobilityBonus[][32] = {
113     {}, {},
114     { S(-35,-30), S(-22,-20), S(-9,-10), S( 3,  0), S(15, 10), S(27, 20), // Knights
115       S( 37, 28), S( 42, 31), S(44, 33) },
116     { S(-22,-27), S( -8,-13), S( 6,  1), S(20, 15), S(34, 29), S(48, 43), // Bishops
117       S( 60, 55), S( 68, 63), S(74, 68), S(77, 72), S(80, 75), S(82, 77),
118       S( 84, 79), S( 86, 81) },
119     { S(-17,-33), S(-11,-16), S(-5,  0), S( 1, 16), S( 7, 32), S(13, 48), // Rooks
120       S( 18, 64), S( 22, 80), S(26, 96), S(29,109), S(31,115), S(33,119),
121       S( 35,122), S( 36,123), S(37,124) },
122     { S(-12,-20), S( -8,-13), S(-5, -7), S( 0,  0), S( 6, 10), S(11, 19), // Queens
123       S( 13, 29), S( 18, 38), S(20, 40), S(21, 41), S(22, 41), S(22, 41),
124       S( 22, 41), S( 23, 41), S(24, 41), S(25, 41), S(25, 41), S(25, 41),
125       S( 25, 41), S( 25, 41), S(25, 41), S(25, 41), S(25, 41), S(25, 41),
126       S( 25, 41), S( 25, 41), S(25, 41), S(25, 41) }
127   };
128
129   // Outpost[PieceType][Square] contains bonuses for knights and bishops outposts,
130   // indexed by piece type and square (from white's point of view).
131   const Value Outpost[][SQUARE_NB] = {
132   {// A     B     C     D     E     F     G     H
133     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights
134     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
135     V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0),
136     V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0),
137     V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0),
138     V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0) },
139   {
140     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops
141     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
142     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0),
143     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0),
144     V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0),
145     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) }
146   };
147
148   // Threat[attacking][attacked] contains bonuses according to which piece
149   // type attacks which one.
150   const Score Threat[][PIECE_TYPE_NB] = {
151     { S(0, 0), S( 7, 39), S(24, 49), S(24, 49), S(41,100), S(41,100) }, // Minor
152     { S(0, 0), S(15, 39), S(15, 45), S(15, 45), S(15, 45), S(24, 49) }  // Major
153   };
154
155   // ThreatenedByPawn[PieceType] contains a penalty according to which piece
156   // type is attacked by an enemy pawn.
157   const Score ThreatenedByPawn[] = {
158     S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
159   };
160
161   #undef S
162
163   const Score Tempo            = make_score(24, 11);
164   const Score RookOn7th        = make_score(11, 20);
165   const Score RookOnPawn       = make_score(10, 28);
166   const Score RookOpenFile     = make_score(43, 21);
167   const Score RookSemiopenFile = make_score(19, 10);
168   const Score BishopPawns      = make_score( 8, 12);
169   const Score KnightPawns      = make_score( 8,  4);
170   const Score MinorBehindPawn  = make_score(16,  0);
171   const Score UndefendedMinor  = make_score(25, 10);
172   const Score TrappedRook      = make_score(90,  0);
173   const Score Unstoppable      = make_score( 0, 20);
174
175   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
176   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
177   // happen in Chess960 games.
178   const Score TrappedBishopA1H1 = make_score(50, 50);
179
180   // SpaceMask[Color] contains the area of the board which is considered
181   // by the space evaluation. In the middlegame, each side is given a bonus
182   // based on how many squares inside this area are safe and available for
183   // friendly minor pieces.
184   const Bitboard SpaceMask[] = {
185     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB),
186     (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB)
187   };
188
189   // King danger constants and variables. The king danger scores are taken
190   // from KingDanger[]. Various little "meta-bonuses" measuring the strength
191   // of the enemy attack are added up into an integer, which is used as an
192   // index to KingDanger[].
193   //
194   // KingAttackWeights[PieceType] contains king attack weights by piece type
195   const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
196
197   // Bonuses for enemy's safe checks
198   const int QueenContactCheck = 24;
199   const int RookContactCheck  = 16;
200   const int QueenCheck        = 12;
201   const int RookCheck         = 8;
202   const int BishopCheck       = 2;
203   const int KnightCheck       = 3;
204
205   // KingDanger[Color][attackUnits] contains the actual king danger weighted
206   // scores, indexed by color and by a calculated integer number.
207   Score KingDanger[COLOR_NB][128];
208
209   // Function prototypes
210   template<bool Trace>
211   Value do_evaluate(const Position& pos);
212
213   template<Color Us>
214   void init_eval_info(const Position& pos, EvalInfo& ei);
215
216   template<bool Trace>
217   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility);
218
219   template<Color Us, bool Trace>
220   Score evaluate_king(const Position& pos, const EvalInfo& ei);
221
222   template<Color Us, bool Trace>
223   Score evaluate_threats(const Position& pos, const EvalInfo& ei);
224
225   template<Color Us, bool Trace>
226   Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei);
227
228   template<Color Us>
229   int evaluate_space(const Position& pos, const EvalInfo& ei);
230
231   Score evaluate_unstoppable_pawns(const Position& pos, Color us, const EvalInfo& ei);
232
233   Value interpolate(const Score& v, Phase ph, ScaleFactor sf);
234   Score apply_weight(Score v, const Weight& w);
235   Weight weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
236 }
237
238
239 namespace Eval {
240
241   /// evaluate() is the main evaluation function. It always computes two
242   /// values, an endgame score and a middlegame score, and interpolates
243   /// between them based on the remaining material.
244
245   Value evaluate(const Position& pos) {
246     return do_evaluate<false>(pos);
247   }
248
249
250   /// trace() is like evaluate(), but instead of returning a value, it returns
251   /// a string (suitable for outputting to stdout) that contains the detailed
252   /// descriptions and values of each evaluation term. It's mainly used for
253   /// debugging.
254   std::string trace(const Position& pos) {
255     return Tracing::do_trace(pos);
256   }
257
258
259   /// init() computes evaluation weights from the corresponding UCI parameters
260   /// and setup king tables.
261
262   void init() {
263
264     Weights[Mobility]       = weight_option("Mobility (Midgame)", "Mobility (Endgame)", WeightsInternal[Mobility]);
265     Weights[PawnStructure]  = weight_option("Pawn Structure (Midgame)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
266     Weights[PassedPawns]    = weight_option("Passed Pawns (Midgame)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
267     Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
268     Weights[KingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
269     Weights[KingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
270
271     const int MaxSlope = 30;
272     const int Peak = 1280;
273
274     for (int t = 0, i = 1; i < 100; ++i)
275     {
276         t = std::min(Peak, std::min(int(0.4 * i * i), t + MaxSlope));
277
278         KingDanger[1][i] = apply_weight(make_score(t, 0), Weights[KingDangerUs]);
279         KingDanger[0][i] = apply_weight(make_score(t, 0), Weights[KingDangerThem]);
280     }
281   }
282
283 } // namespace Eval
284
285
286 namespace {
287
288 template<bool Trace>
289 Value do_evaluate(const Position& pos) {
290
291   assert(!pos.checkers());
292
293   EvalInfo ei;
294   Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
295   Thread* thisThread = pos.this_thread();
296
297   // Initialize score by reading the incrementally updated scores included
298   // in the position object (material + piece square tables) and adding a
299   // Tempo bonus. Score is computed from the point of view of white.
300   score = pos.psq_score() + (pos.side_to_move() == WHITE ? Tempo : -Tempo);
301
302   // Probe the material hash table
303   ei.mi = Material::probe(pos, thisThread->materialTable, thisThread->endgames);
304   score += ei.mi->material_value();
305
306   // If we have a specialized evaluation function for the current material
307   // configuration, call it and return.
308   if (ei.mi->specialized_eval_exists())
309       return ei.mi->evaluate(pos);
310
311   // Probe the pawn hash table
312   ei.pi = Pawns::probe(pos, thisThread->pawnsTable);
313   score += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
314
315   // Initialize attack and king safety bitboards
316   init_eval_info<WHITE>(pos, ei);
317   init_eval_info<BLACK>(pos, ei);
318
319   // Evaluate pieces and mobility
320   score += evaluate_pieces<Trace>(pos, ei, mobility);
321
322   score += apply_weight(mobility[WHITE] - mobility[BLACK], Weights[Mobility]);
323
324   // Evaluate kings after all other pieces because we need complete attack
325   // information when computing the king safety evaluation.
326   score +=  evaluate_king<WHITE, Trace>(pos, ei)
327           - evaluate_king<BLACK, Trace>(pos, ei);
328
329   // Evaluate tactical threats, we need full attack information including king
330   score +=  evaluate_threats<WHITE, Trace>(pos, ei)
331           - evaluate_threats<BLACK, Trace>(pos, ei);
332
333   // Evaluate passed pawns, we need full attack information including king
334   score +=  evaluate_passed_pawns<WHITE, Trace>(pos, ei)
335           - evaluate_passed_pawns<BLACK, Trace>(pos, ei);
336
337   // If one side has only a king, score for potential unstoppable pawns
338   if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
339       score +=  evaluate_unstoppable_pawns(pos, WHITE, ei)
340               - evaluate_unstoppable_pawns(pos, BLACK, ei);
341
342   // Evaluate space for both sides, only in middlegame
343   if (ei.mi->space_weight())
344   {
345       int s = evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei);
346       score += apply_weight(s * ei.mi->space_weight(), Weights[Space]);
347   }
348
349   // Scale winning side if position is more drawish than it appears
350   ScaleFactor sf = eg_value(score) > VALUE_DRAW ? ei.mi->scale_factor(pos, WHITE)
351                                                 : ei.mi->scale_factor(pos, BLACK);
352
353   // If we don't already have an unusual scale factor, check for opposite
354   // colored bishop endgames, and use a lower scale for those.
355   if (    ei.mi->game_phase() < PHASE_MIDGAME
356       &&  pos.opposite_bishops()
357       && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))
358   {
359       // Ignoring any pawns, do both sides only have a single bishop and no
360       // other pieces?
361       if (   pos.non_pawn_material(WHITE) == BishopValueMg
362           && pos.non_pawn_material(BLACK) == BishopValueMg)
363       {
364           // Check for KBP vs KB with only a single pawn that is almost
365           // certainly a draw or at least two pawns.
366           bool one_pawn = (pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK) == 1);
367           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
368       }
369       else
370           // Endgame with opposite-colored bishops, but also other pieces. Still
371           // a bit drawish, but not as drawish as with only the two bishops.
372            sf = ScaleFactor(50 * sf / SCALE_FACTOR_NORMAL);
373   }
374
375   Value v = interpolate(score, ei.mi->game_phase(), sf);
376
377   // In case of tracing add all single evaluation contributions for both white and black
378   if (Trace)
379   {
380       Tracing::add_term(Tracing::PST, pos.psq_score());
381       Tracing::add_term(Tracing::IMBALANCE, ei.mi->material_value());
382       Tracing::add_term(PAWN, ei.pi->pawns_value());
383       Score w = ei.mi->space_weight() * evaluate_space<WHITE>(pos, ei);
384       Score b = ei.mi->space_weight() * evaluate_space<BLACK>(pos, ei);
385       Tracing::add_term(Tracing::SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
386       Tracing::add_term(Tracing::TOTAL, score);
387       Tracing::ei = ei;
388       Tracing::sf = sf;
389   }
390
391   return pos.side_to_move() == WHITE ? v : -v;
392 }
393
394
395   // init_eval_info() initializes king bitboards for given color adding
396   // pawn attacks. To be done at the beginning of the evaluation.
397
398   template<Color Us>
399   void init_eval_info(const Position& pos, EvalInfo& ei) {
400
401     const Color  Them = (Us == WHITE ? BLACK : WHITE);
402     const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);
403
404     ei.pinnedPieces[Us] = pos.pinned_pieces(Us);
405
406     Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
407     ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
408
409     // Init king safety tables only if we are going to use them
410     if (pos.count<QUEEN>(Us) && pos.non_pawn_material(Us) > QueenValueMg + PawnValueMg)
411     {
412         ei.kingRing[Them] = b | shift_bb<Down>(b);
413         b &= ei.attackedBy[Us][PAWN];
414         ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) : 0;
415         ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
416     }
417     else
418         ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
419   }
420
421
422   // evaluate_outposts() evaluates bishop and knight outpost squares
423
424   template<PieceType Pt, Color Us>
425   Score evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
426
427     const Color Them = (Us == WHITE ? BLACK : WHITE);
428
429     assert (Pt == BISHOP || Pt == KNIGHT);
430
431     // Initial bonus based on square
432     Value bonus = Outpost[Pt == BISHOP][relative_square(Us, s)];
433
434     // Increase bonus if supported by pawn, especially if the opponent has
435     // no minor piece which can trade with the outpost piece.
436     if (bonus && (ei.attackedBy[Us][PAWN] & s))
437     {
438         if (   !pos.pieces(Them, KNIGHT)
439             && !(squares_of_color(s) & pos.pieces(Them, BISHOP)))
440             bonus += bonus + bonus / 2;
441         else
442             bonus += bonus / 2;
443     }
444
445     return make_score(bonus, bonus);
446   }
447
448
449   // evaluate_pieces() assigns bonuses and penalties to the pieces of a given color
450
451   template<PieceType Pt, Color Us, bool Trace>
452   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, Bitboard mobilityArea) {
453
454     Bitboard b;
455     Square s;
456     Score score = SCORE_ZERO;
457
458     const Color Them = (Us == WHITE ? BLACK : WHITE);
459     const Square* pl = pos.list<Pt>(Us);
460
461     ei.attackedBy[Us][Pt] = 0;
462
463     while ((s = *pl++) != SQ_NONE)
464     {
465         // Find attacked squares, including x-ray attacks for bishops and rooks
466         b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
467           : Pt ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
468                          : pos.attacks_from<Pt>(s);
469
470         if (ei.pinnedPieces[Us] & s)
471             b &= LineBB[pos.king_square(Us)][s];
472
473         ei.attackedBy[Us][Pt] |= b;
474
475         if (b & ei.kingRing[Them])
476         {
477             ei.kingAttackersCount[Us]++;
478             ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
479             Bitboard bb = b & ei.attackedBy[Them][KING];
480             if (bb)
481                 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
482         }
483
484         if (Pt == QUEEN)
485             b &= ~(  ei.attackedBy[Them][KNIGHT]
486                    | ei.attackedBy[Them][BISHOP]
487                    | ei.attackedBy[Them][ROOK]);
488
489         int mob = Pt != QUEEN ? popcount<Max15>(b & mobilityArea)
490                               : popcount<Full >(b & mobilityArea);
491
492         mobility[Us] += MobilityBonus[Pt][mob];
493
494         // Decrease score if we are attacked by an enemy pawn. The remaining part
495         // of threat evaluation must be done later when we have full attack info.
496         if (ei.attackedBy[Them][PAWN] & s)
497             score -= ThreatenedByPawn[Pt];
498
499         if (Pt == BISHOP || Pt == KNIGHT)
500         {
501             // Penalty for bishop with same colored pawns
502             if (Pt == BISHOP)
503                 score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);
504
505             // Penalty for knight when there are few enemy pawns
506             if (Pt == KNIGHT)
507                 score -= KnightPawns * std::max(5 - pos.count<PAWN>(Them), 0);
508
509             // Bishop and knight outposts squares
510             if (!(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))
511                 score += evaluate_outposts<Pt, Us>(pos, ei, s);
512
513             // Bishop or knight behind a pawn
514             if (    relative_rank(Us, s) < RANK_5
515                 && (pos.pieces(PAWN) & (s + pawn_push(Us))))
516                 score += MinorBehindPawn;
517         }
518
519         if (Pt == ROOK)
520         {
521             // Rook on 7th rank and enemy king trapped on 8th
522             if (   relative_rank(Us, s) == RANK_7
523                 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
524                 score += RookOn7th;
525
526             // Rook piece attacking enemy pawns on the same rank/file
527             if (relative_rank(Us, s) >= RANK_5)
528             {
529                 Bitboard pawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];
530                 if (pawns)
531                     score += popcount<Max15>(pawns) * RookOnPawn;
532             }
533
534             // Give a bonus for a rook on a open or semi-open file
535             if (ei.pi->semiopen(Us, file_of(s)))
536                 score += ei.pi->semiopen(Them, file_of(s)) ? RookOpenFile : RookSemiopenFile;
537
538             if (mob > 3 || ei.pi->semiopen(Us, file_of(s)))
539                 continue;
540
541             Square ksq = pos.king_square(Us);
542
543             // Penalize rooks which are trapped by a king. Penalize more if the
544             // king has lost its castling capability.
545             if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
546                 && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)
547                 && !ei.pi->semiopen_on_side(Us, file_of(ksq), file_of(ksq) < FILE_E))
548                 score -= (TrappedRook - make_score(mob * 8, 0)) * (pos.can_castle(Us) ? 1 : 2);
549         }
550
551         // An important Chess960 pattern: A cornered bishop blocked by a friendly
552         // pawn diagonally in front of it is a very serious problem, especially
553         // when that pawn is also blocked.
554         if (   Pt == BISHOP
555             && pos.is_chess960()
556             && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
557         {
558             Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
559             if (pos.piece_on(s + d) == make_piece(Us, PAWN))
560                 score -= !pos.empty(s + d + pawn_push(Us))                ? TrappedBishopA1H1 * 4
561                         : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
562                                                                           : TrappedBishopA1H1;
563         }
564     }
565
566     if (Trace)
567         Tracing::terms[Us][Pt] = score;
568
569     return score;
570   }
571
572
573   // evaluate_pieces() assigns bonuses and penalties to all the pieces of both colors
574
575   template<bool Trace>
576   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) {
577
578     // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
579     const Bitboard whiteMobilityArea = ~(ei.attackedBy[BLACK][PAWN] | pos.pieces(WHITE, PAWN, KING));
580     const Bitboard blackMobilityArea = ~(ei.attackedBy[WHITE][PAWN] | pos.pieces(BLACK, PAWN, KING));
581
582     Score score;
583
584     score  =  evaluate_pieces<KNIGHT, WHITE, Trace>(pos, ei, mobility, whiteMobilityArea)
585             - evaluate_pieces<KNIGHT, BLACK, Trace>(pos, ei, mobility, blackMobilityArea);
586     score +=  evaluate_pieces<BISHOP, WHITE, Trace>(pos, ei, mobility, whiteMobilityArea)
587             - evaluate_pieces<BISHOP, BLACK, Trace>(pos, ei, mobility, blackMobilityArea);
588     score +=  evaluate_pieces<  ROOK, WHITE, Trace>(pos, ei, mobility, whiteMobilityArea)
589             - evaluate_pieces<  ROOK, BLACK, Trace>(pos, ei, mobility, blackMobilityArea);
590     score +=  evaluate_pieces< QUEEN, WHITE, Trace>(pos, ei, mobility, whiteMobilityArea)
591             - evaluate_pieces< QUEEN, BLACK, Trace>(pos, ei, mobility, blackMobilityArea);
592
593     // Sum up all attacked squares (updated in evaluate_pieces)
594     ei.attackedBy[WHITE][ALL_PIECES] =  ei.attackedBy[WHITE][PAWN]   | ei.attackedBy[WHITE][KNIGHT]
595                                       | ei.attackedBy[WHITE][BISHOP] | ei.attackedBy[WHITE][ROOK]
596                                       | ei.attackedBy[WHITE][QUEEN]  | ei.attackedBy[WHITE][KING];
597
598     ei.attackedBy[BLACK][ALL_PIECES] =  ei.attackedBy[BLACK][PAWN]   | ei.attackedBy[BLACK][KNIGHT]
599                                       | ei.attackedBy[BLACK][BISHOP] | ei.attackedBy[BLACK][ROOK]
600                                       | ei.attackedBy[BLACK][QUEEN]  | ei.attackedBy[BLACK][KING];
601     if (Trace)
602     {
603         Tracing::terms[WHITE][Tracing::MOBILITY] = apply_weight(mobility[WHITE], Weights[Mobility]);
604         Tracing::terms[BLACK][Tracing::MOBILITY] = apply_weight(mobility[BLACK], Weights[Mobility]);
605     }
606
607     return score;
608   }
609
610
611   // evaluate_king() assigns bonuses and penalties to a king of a given color
612
613   template<Color Us, bool Trace>
614   Score evaluate_king(const Position& pos, const EvalInfo& ei) {
615
616     const Color Them = (Us == WHITE ? BLACK : WHITE);
617
618     Bitboard undefended, b, b1, b2, safe;
619     int attackUnits;
620     const Square ksq = pos.king_square(Us);
621
622     // King shelter and enemy pawns storm
623     Score score = ei.pi->king_safety<Us>(pos, ksq);
624
625     // Main king safety evaluation
626     if (ei.kingAttackersCount[Them])
627     {
628         // Find the attacked squares around the king which have no defenders
629         // apart from the king itself
630         undefended =  ei.attackedBy[Them][ALL_PIECES]
631                     & ei.attackedBy[Us][KING]
632                     & ~(  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
633                         | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
634                         | ei.attackedBy[Us][QUEEN]);
635
636         // Initialize the 'attackUnits' variable, which is used later on as an
637         // index to the KingDanger[] array. The initial value is based on the
638         // number and types of the enemy's attacking pieces, the number of
639         // attacked and undefended squares around our king and the quality of
640         // the pawn shelter (current 'score' value).
641         attackUnits =  std::min(20, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
642                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + popcount<Max15>(undefended))
643                      + 2 * (ei.pinnedPieces[Us] != 0)
644                      - mg_value(score) / 32;
645
646         // Analyse the enemy's safe queen contact checks. Firstly, find the
647         // undefended squares around the king that are attacked by the enemy's
648         // queen...
649         b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);
650         if (b)
651         {
652             // ...and then remove squares not supported by another enemy piece
653             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
654                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
655
656             if (b)
657                 attackUnits +=  QueenContactCheck
658                               * popcount<Max15>(b)
659                               * (Them == pos.side_to_move() ? 2 : 1);
660         }
661
662         // Analyse the enemy's safe rook contact checks. Firstly, find the
663         // undefended squares around the king that are attacked by the enemy's
664         // rooks...
665         b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them);
666
667         // Consider only squares where the enemy's rook gives check
668         b &= PseudoAttacks[ROOK][ksq];
669
670         if (b)
671         {
672             // ...and then remove squares not supported by another enemy piece
673             b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
674                   | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]);
675
676             if (b)
677                 attackUnits +=  RookContactCheck
678                               * popcount<Max15>(b)
679                               * (Them == pos.side_to_move() ? 2 : 1);
680         }
681
682         // Analyse the enemy's safe distance checks for sliders and knights
683         safe = ~(pos.pieces(Them) | ei.attackedBy[Us][ALL_PIECES]);
684
685         b1 = pos.attacks_from<ROOK>(ksq) & safe;
686         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
687
688         // Enemy queen safe checks
689         b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
690         if (b)
691             attackUnits += QueenCheck * popcount<Max15>(b);
692
693         // Enemy rooks safe checks
694         b = b1 & ei.attackedBy[Them][ROOK];
695         if (b)
696             attackUnits += RookCheck * popcount<Max15>(b);
697
698         // Enemy bishops safe checks
699         b = b2 & ei.attackedBy[Them][BISHOP];
700         if (b)
701             attackUnits += BishopCheck * popcount<Max15>(b);
702
703         // Enemy knights safe checks
704         b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
705         if (b)
706             attackUnits += KnightCheck * popcount<Max15>(b);
707
708         // To index KingDanger[] attackUnits must be in [0, 99] range
709         attackUnits = std::min(99, std::max(0, attackUnits));
710
711         // Finally, extract the king danger score from the KingDanger[]
712         // array and subtract the score from evaluation.
713         score -= KingDanger[Us == Search::RootColor][attackUnits];
714     }
715
716     if (Trace)
717         Tracing::terms[Us][KING] = score;
718
719     return score;
720   }
721
722
723   // evaluate_threats() assigns bonuses according to the type of attacking piece
724   // and the type of attacked one.
725
726   template<Color Us, bool Trace>
727   Score evaluate_threats(const Position& pos, const EvalInfo& ei) {
728
729     const Color Them = (Us == WHITE ? BLACK : WHITE);
730
731     Bitboard b, undefendedMinors, weakEnemies;
732     Score score = SCORE_ZERO;
733
734     // Undefended minors get penalized even if they are not under attack
735     undefendedMinors =  pos.pieces(Them, BISHOP, KNIGHT)
736                       & ~ei.attackedBy[Them][ALL_PIECES];
737
738     if (undefendedMinors)
739         score += UndefendedMinor;
740
741     // Enemy pieces not defended by a pawn and under our attack
742     weakEnemies =  pos.pieces(Them)
743                  & ~ei.attackedBy[Them][PAWN]
744                  & ei.attackedBy[Us][ALL_PIECES];
745
746     // Add a bonus according if the attacking pieces are minor or major
747     if (weakEnemies)
748     {
749         b = weakEnemies & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);
750         if (b)
751             score += Threat[0][type_of(pos.piece_on(lsb(b)))];
752
753         b = weakEnemies & (ei.attackedBy[Us][ROOK] | ei.attackedBy[Us][QUEEN]);
754         if (b)
755             score += Threat[1][type_of(pos.piece_on(lsb(b)))];
756     }
757
758     if (Trace)
759         Tracing::terms[Us][Tracing::THREAT] = score;
760
761     return score;
762   }
763
764
765   // evaluate_passed_pawns() evaluates the passed pawns of the given color
766
767   template<Color Us, bool Trace>
768   Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) {
769
770     const Color Them = (Us == WHITE ? BLACK : WHITE);
771
772     Bitboard b, squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
773     Score score = SCORE_ZERO;
774
775     b = ei.pi->passed_pawns(Us);
776
777     while (b)
778     {
779         Square s = pop_lsb(&b);
780
781         assert(pos.pawn_passed(Us, s));
782
783         int r = int(relative_rank(Us, s) - RANK_2);
784         int rr = r * (r - 1);
785
786         // Base bonus based on rank
787         Value mbonus = Value(17 * rr);
788         Value ebonus = Value(7 * (rr + r + 1));
789
790         if (rr)
791         {
792             Square blockSq = s + pawn_push(Us);
793
794             // Adjust bonus based on the king's proximity
795             ebonus +=  Value(square_distance(pos.king_square(Them), blockSq) * 5 * rr)
796                      - Value(square_distance(pos.king_square(Us  ), blockSq) * 2 * rr);
797
798             // If blockSq is not the queening square then consider also a second push
799             if (relative_rank(Us, blockSq) != RANK_8)
800                 ebonus -= Value(rr * square_distance(pos.king_square(Us), blockSq + pawn_push(Us)));
801
802             // If the pawn is free to advance, then increase the bonus
803             if (pos.empty(blockSq))
804             {
805                 squaresToQueen = forward_bb(Us, s);
806
807                 // If there is an enemy rook or queen attacking the pawn from behind,
808                 // add all X-ray attacks by the rook or queen. Otherwise consider only
809                 // the squares in the pawn's path attacked or occupied by the enemy.
810                 if (    unlikely(forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN))
811                     && (forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
812                     unsafeSquares = squaresToQueen;
813                 else
814                     unsafeSquares = squaresToQueen & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
815
816                 if (    unlikely(forward_bb(Them, s) & pos.pieces(Us, ROOK, QUEEN))
817                     && (forward_bb(Them, s) & pos.pieces(Us, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
818                     defendedSquares = squaresToQueen;
819                 else
820                     defendedSquares = squaresToQueen & ei.attackedBy[Us][ALL_PIECES];
821
822                 // If there aren't any enemy attacks, then assign a huge bonus.
823                 // The bonus will be a bit smaller if at least the block square
824                 // isn't attacked, otherwise assign the smallest possible bonus.
825                 int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 3;
826
827                 // Assign a big bonus if the path to the queen is fully defended,
828                 // otherwise assign a bit less of a bonus if at least the block
829                 // square is defended.
830                 if (defendedSquares == squaresToQueen)
831                     k += 6;
832
833                 else if (defendedSquares & blockSq)
834                     k += (unsafeSquares & defendedSquares) == unsafeSquares ? 4 : 2;
835
836                 mbonus += Value(k * rr), ebonus += Value(k * rr);
837             }
838         } // rr != 0
839
840         // Increase the bonus if the passed pawn is supported by a friendly pawn
841         // on the same rank and a bit smaller if it's on the previous rank.
842         supportingPawns = pos.pieces(Us, PAWN) & adjacent_files_bb(file_of(s));
843         if (supportingPawns & rank_bb(s))
844             ebonus += Value(r * 20);
845
846         else if (supportingPawns & rank_bb(s - pawn_push(Us)))
847             ebonus += Value(r * 12);
848
849         // Rook pawns are a special case: They are sometimes worse, and
850         // sometimes better than other passed pawns. It is difficult to find
851         // good rules for determining whether they are good or bad. For now,
852         // we try the following: Increase the value for rook pawns if the
853         // other side has no pieces apart from a knight, and decrease the
854         // value if the other side has a rook or queen.
855         if (file_of(s) == FILE_A || file_of(s) == FILE_H)
856         {
857             if (pos.non_pawn_material(Them) <= KnightValueMg)
858                 ebonus += ebonus / 4;
859
860             else if (pos.pieces(Them, ROOK, QUEEN))
861                 ebonus -= ebonus / 4;
862         }
863
864         if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
865             ebonus += ebonus / 4;
866
867         score += make_score(mbonus, ebonus);
868     }
869
870     if (Trace)
871         Tracing::terms[Us][Tracing::PASSED] = apply_weight(score, Weights[PassedPawns]);
872
873     // Add the scores to the middlegame and endgame eval
874     return apply_weight(score, Weights[PassedPawns]);
875   }
876
877
878   // evaluate_unstoppable_pawns() scores the most advanced among the passed and
879   // candidate pawns. In case opponent has no pieces but pawns, this is somewhat
880   // related to the possibility that pawns are unstoppable.
881
882   Score evaluate_unstoppable_pawns(const Position& pos, Color us, const EvalInfo& ei) {
883
884     Bitboard b = ei.pi->passed_pawns(us) | ei.pi->candidate_pawns(us);
885
886     if (!b || pos.non_pawn_material(~us))
887         return SCORE_ZERO;
888
889     return Unstoppable * int(relative_rank(us, frontmost_sq(us, b)));
890   }
891
892
893   // evaluate_space() computes the space evaluation for a given side. The
894   // space evaluation is a simple bonus based on the number of safe squares
895   // available for minor pieces on the central four files on ranks 2--4. Safe
896   // squares one, two or three squares behind a friendly pawn are counted
897   // twice. Finally, the space bonus is scaled by a weight taken from the
898   // material hash table. The aim is to improve play on game opening.
899   template<Color Us>
900   int evaluate_space(const Position& pos, const EvalInfo& ei) {
901
902     const Color Them = (Us == WHITE ? BLACK : WHITE);
903
904     // Find the safe squares for our pieces inside the area defined by
905     // SpaceMask[]. A square is unsafe if it is attacked by an enemy
906     // pawn, or if it is undefended and attacked by an enemy piece.
907     Bitboard safe =   SpaceMask[Us]
908                    & ~pos.pieces(Us, PAWN)
909                    & ~ei.attackedBy[Them][PAWN]
910                    & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);
911
912     // Find all squares which are at most three squares behind some friendly pawn
913     Bitboard behind = pos.pieces(Us, PAWN);
914     behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
915     behind |= (Us == WHITE ? behind >> 16 : behind << 16);
916
917     // Since SpaceMask[Us] is fully on our half of the board
918     assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
919
920     // Count safe + (behind & safe) with a single popcount
921     return popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
922   }
923
924
925   // interpolate() interpolates between a middlegame and an endgame score,
926   // based on game phase. It also scales the return value by a ScaleFactor array.
927
928   Value interpolate(const Score& v, Phase ph, ScaleFactor sf) {
929
930     assert(-VALUE_INFINITE < mg_value(v) && mg_value(v) < VALUE_INFINITE);
931     assert(-VALUE_INFINITE < eg_value(v) && eg_value(v) < VALUE_INFINITE);
932     assert(PHASE_ENDGAME <= ph && ph <= PHASE_MIDGAME);
933
934     int eg = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
935     return Value((mg_value(v) * int(ph) + eg * int(PHASE_MIDGAME - ph)) / PHASE_MIDGAME);
936   }
937
938   // apply_weight() weights score v by score w trying to prevent overflow
939   Score apply_weight(Score v, const Weight& w) {
940
941     return make_score(mg_value(v) * w.mg / 256, eg_value(v) * w.eg / 256);
942   }
943
944   // weight_option() computes the value of an evaluation weight, by combining
945   // two UCI-configurable weights (midgame and endgame) with an internal weight.
946
947   Weight weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
948
949     Weight w = { Options[mgOpt] * mg_value(internalWeight) / 100,
950                  Options[egOpt] * eg_value(internalWeight) / 100 };
951     return w;
952   }
953
954
955   // Tracing function definitions
956
957   double Tracing::to_cp(Value v) { return double(v) / PawnValueEg; }
958
959   void Tracing::add_term(int idx, Score wScore, Score bScore) {
960
961     terms[WHITE][idx] = wScore;
962     terms[BLACK][idx] = bScore;
963   }
964
965   void Tracing::format_row(std::stringstream& ss, const char* name, int idx) {
966
967     Score wScore = terms[WHITE][idx];
968     Score bScore = terms[BLACK][idx];
969
970     switch (idx) {
971     case PST: case IMBALANCE: case PAWN: case TOTAL:
972         ss << std::setw(20) << name << " |   ---   --- |   ---   --- | "
973            << std::setw(5)  << to_cp(mg_value(wScore - bScore)) << " "
974            << std::setw(5)  << to_cp(eg_value(wScore - bScore)) << " \n";
975         break;
976     default:
977         ss << std::setw(20) << name << " | " << std::noshowpos
978            << std::setw(5)  << to_cp(mg_value(wScore)) << " "
979            << std::setw(5)  << to_cp(eg_value(wScore)) << " | "
980            << std::setw(5)  << to_cp(mg_value(bScore)) << " "
981            << std::setw(5)  << to_cp(eg_value(bScore)) << " | "
982            << std::setw(5)  << to_cp(mg_value(wScore - bScore)) << " "
983            << std::setw(5)  << to_cp(eg_value(wScore - bScore)) << " \n";
984     }
985   }
986
987   std::string Tracing::do_trace(const Position& pos) {
988
989     std::memset(terms, 0, sizeof(terms));
990
991     Value v = do_evaluate<true>(pos);
992     v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
993
994     std::stringstream ss;
995     ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
996        << "           Eval term |    White    |    Black    |    Total    \n"
997        << "                     |   MG    EG  |   MG    EG  |   MG    EG  \n"
998        << "---------------------+-------------+-------------+-------------\n";
999
1000     format_row(ss, "Material, PST, Tempo", PST);
1001     format_row(ss, "Material imbalance", IMBALANCE);
1002     format_row(ss, "Pawns", PAWN);
1003     format_row(ss, "Knights", KNIGHT);
1004     format_row(ss, "Bishops", BISHOP);
1005     format_row(ss, "Rooks", ROOK);
1006     format_row(ss, "Queens", QUEEN);
1007     format_row(ss, "Mobility", MOBILITY);
1008     format_row(ss, "King safety", KING);
1009     format_row(ss, "Threats", THREAT);
1010     format_row(ss, "Passed pawns", PASSED);
1011     format_row(ss, "Space", SPACE);
1012
1013     ss << "---------------------+-------------+-------------+-------------\n";
1014     format_row(ss, "Total", TOTAL);
1015
1016     ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";
1017
1018     return ss.str();
1019   }
1020 }