X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fevaluate.cpp;h=359222811593e621fdd16d9b2320961eeaf13182;hp=4984d08ce53c5344b8e1937fb7f8263df6e8e819;hb=3376c68f4bb83dc9fd874eb9d710dab09609ae54;hpb=c45818e9f86fea63a6b46d0726cdcfe87516d01b

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 4984d08c..35922281 100644
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -25,6 +25,7 @@
 #include <cassert>
 #include <cstring>
 
+#include "bitcount.h"
 #include "evaluate.h"
 #include "material.h"
 #include "pawns.h"
@@ -39,34 +40,33 @@
 
 namespace {
 
-  const int Sign[2] = {1, -1};
+  const int Sign[2] = { 1, -1 };
 
-  // Evaluation grain size, must be a power of 2.
+  // Evaluation grain size, must be a power of 2
   const int GrainSize = 4;
 
-  // Evaluation weights
-  int WeightMobilityMidgame      = 0x100;
-  int WeightMobilityEndgame      = 0x100;
-  int WeightPawnStructureMidgame = 0x100;
-  int WeightPawnStructureEndgame = 0x100;
-  int WeightPassedPawnsMidgame   = 0x100;
-  int WeightPassedPawnsEndgame   = 0x100;
-  int WeightKingSafety[2] = { 0x100, 0x100 };
+  // Evaluation weights, initialized from UCI options
+  int WeightMobilityMidgame, WeightMobilityEndgame;
+  int WeightPawnStructureMidgame, WeightPawnStructureEndgame;
+  int WeightPassedPawnsMidgame, WeightPassedPawnsEndgame;
+  int WeightKingSafety[2];
   int WeightSpace;
 
-  // Internal evaluation weights.  These are applied on top of the evaluation
-  // weights read from UCI parameters.  The purpose is to be able to change
+  // Internal evaluation weights. These are applied on top of the evaluation
+  // weights read from UCI parameters. The purpose is to be able to change
   // the evaluation weights while keeping the default values of the UCI
   // parameters at 100, which looks prettier.
-  const int WeightMobilityMidgameInternal      = 0x100;
-  const int WeightMobilityEndgameInternal      = 0x100;
-  const int WeightPawnStructureMidgameInternal = 0x100;
-  const int WeightPawnStructureEndgameInternal = 0x100;
-  const int WeightPassedPawnsMidgameInternal   = 0x100;
-  const int WeightPassedPawnsEndgameInternal   = 0x100;
-  const int WeightKingSafetyInternal           = 0x110;
-  const int WeightKingOppSafetyInternal        = 0x110;
-  const int WeightSpaceInternal                = 0x30;
+  //
+  // Values modified by Joona Kiiski
+  const int WeightMobilityMidgameInternal      = 0x0FA;
+  const int WeightMobilityEndgameInternal      = 0x10A;
+  const int WeightPawnStructureMidgameInternal = 0x0EC;
+  const int WeightPawnStructureEndgameInternal = 0x0CD;
+  const int WeightPassedPawnsMidgameInternal   = 0x108;
+  const int WeightPassedPawnsEndgameInternal   = 0x109;
+  const int WeightKingSafetyInternal           = 0x0F7;
+  const int WeightKingOppSafetyInternal        = 0x101;
+  const int WeightSpaceInternal                = 0x02F;
 
   // Visually better to define tables constants
   typedef Value V;
@@ -84,7 +84,7 @@ namespace {
   };
 
   // Bishop mobility bonus in middle game and endgame, indexed by the number
-  // of attacked squares not occupied by friendly pieces.  X-ray attacks through
+  // of attacked squares not occupied by friendly pieces. X-ray attacks through
   // queens are also included.
   const Value MidgameBishopMobilityBonus[] = {
   //    0       1      2      3      4      5      6      7
@@ -101,7 +101,7 @@ namespace {
   };
 
   // Rook mobility bonus in middle game and endgame, indexed by the number
-  // of attacked squares not occupied by friendly pieces.  X-ray attacks through
+  // of attacked squares not occupied by friendly pieces. X-ray attacks through
   // queens and rooks are also included.
   const Value MidgameRookMobilityBonus[] = {
   //    0       1      2      3      4      5      6      7
@@ -167,46 +167,46 @@ namespace {
     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
   };
 
-  // Bonus for unstoppable passed pawns:
+  // Bonus for unstoppable passed pawns
   const Value UnstoppablePawnValue = Value(0x500);
 
-  // Rooks and queens on the 7th rank:
-  const Value MidgameRookOn7thBonus  = Value(50);
-  const Value EndgameRookOn7thBonus  = Value(100);
-  const Value MidgameQueenOn7thBonus = Value(25);
-  const Value EndgameQueenOn7thBonus = Value(50);
+  // Rooks and queens on the 7th rank
+  const Value MidgameRookOn7thBonus  = Value(47);
+  const Value EndgameRookOn7thBonus  = Value(98);
+  const Value MidgameQueenOn7thBonus = Value(27);
+  const Value EndgameQueenOn7thBonus = Value(54);
 
-  // Rooks on open files:
-  const Value RookOpenFileBonus     = Value(40);
-  const Value RookHalfOpenFileBonus = Value(20);
+  // Rooks on open files
+  const Value RookOpenFileBonus = Value(43);
+  const Value RookHalfOpenFileBonus = Value(19);
 
   // Penalty for rooks trapped inside a friendly king which has lost the
-  // right to castle:
+  // right to castle.
   const Value TrappedRookPenalty = Value(180);
 
   // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
-  // enemy pawns:
+  // enemy pawns.
   const Value TrappedBishopA7H7Penalty = Value(300);
 
-  // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black):
+  // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
   const Bitboard MaskA7H7[2] = {
     ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
     ((1ULL << SQ_A2) | (1ULL << SQ_H2))
   };
 
   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
-  // a friendly pawn on b2/g2 (b7/g7 for black).  This can obviously only
+  // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
   // happen in Chess960 games.
   const Value TrappedBishopA1H1Penalty = Value(100);
 
-  // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black):
+  // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
   const Bitboard MaskA1H1[2] = {
     ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
     ((1ULL << SQ_A8) | (1ULL << SQ_H8))
   };
 
   // The SpaceMask[color] contains area of the board which is consdered by
-  // the space evaluation.  In the middle game, each side is given a bonus
+  // the space evaluation. In the middle game, each side is given a bonus
   // based on how many squares inside this area are safe and available for
   // friendly minor pieces.
   const Bitboard SpaceMask[2] = {
@@ -218,30 +218,26 @@ namespace {
     (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
   };
 
-  /// King safety constants and variables.  The king safety scores are taken
-  /// from the array SafetyTable[].  Various little "meta-bonuses" measuring
+  /// King safety constants and variables. The king safety scores are taken
+  /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
   /// the strength of the attack are added up into an integer, which is used
   /// as an index to SafetyTable[].
 
-  // Attack weights for each piece type.
+  // Attack weights for each piece type
   const int QueenAttackWeight  = 5;
   const int RookAttackWeight   = 3;
   const int BishopAttackWeight = 2;
   const int KnightAttackWeight = 2;
 
-  // Bonuses for safe checks for each piece type.
-  int QueenContactCheckBonus = 3;
-  int QueenCheckBonus        = 2;
-  int RookCheckBonus         = 1;
-  int BishopCheckBonus       = 1;
-  int KnightCheckBonus       = 1;
-  int DiscoveredCheckBonus   = 3;
+  // Bonuses for safe checks, initialized from UCI options
+  int QueenContactCheckBonus, DiscoveredCheckBonus;
+  int QueenCheckBonus, RookCheckBonus, BishopCheckBonus, KnightCheckBonus;
 
   // Scan for queen contact mates?
   const bool QueenContactMates = true;
 
-  // Bonus for having a mate threat.
-  int MateThreatBonus = 3;
+  // Bonus for having a mate threat, initialized from UCI options
+  int MateThreatBonus;
 
   // InitKingDanger[] contains bonuses based on the position of the defending
   // king.
@@ -256,27 +252,27 @@ namespace {
     15, 15, 15, 15, 15, 15, 15, 15
   };
 
-  // SafetyTable[] contains the actual king safety scores.  It is initialized
+  // SafetyTable[] contains the actual king safety scores. It is initialized
   // in init_safety().
   Value SafetyTable[100];
 
   // Pawn and material hash tables, indexed by the current thread id
-  PawnInfoTable *PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
-  MaterialInfoTable *MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
   // Sizes of pawn and material hash tables
   const int PawnTableSize = 16384;
   const int MaterialTableSize = 1024;
 
-  // Array which gives the number of nonzero bits in an 8-bit integer:
+  // Array which gives the number of nonzero bits in an 8-bit integer
   uint8_t BitCount8Bit[256];
 
   // Function prototypes
-  void evaluate_knight(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei);
-  void evaluate_bishop(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei);
-  void evaluate_rook(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei);
-  void evaluate_queen(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei);
-  void evaluate_king(const Position& p, Square s, Color us, EvalInfo& ei);
+  template<PieceType Piece>
+  void evaluate_pieces(const Position& p, Color us, EvalInfo& ei);
+
+  template<>
+  void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo &ei);
 
   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
@@ -288,8 +284,6 @@ namespace {
   inline Value apply_weight(Value v, int w);
   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
 
-  int count_1s_8bit(Bitboard b);
-
   int compute_weight(int uciWeight, int internalWeight);
   int weight_option(const std::string& opt, int weight);
   void init_safety();
@@ -346,60 +340,28 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
   // Initialize pawn attack bitboards for both sides
   ei.attackedBy[WHITE][PAWN] = ((pos.pawns(WHITE) << 9) & ~FileABB) | ((pos.pawns(WHITE) << 7) & ~FileHBB);
   ei.attackedBy[BLACK][PAWN] = ((pos.pawns(BLACK) >> 7) & ~FileABB) | ((pos.pawns(BLACK) >> 9) & ~FileHBB);
-  ei.kingAttackersCount[WHITE] = count_1s_max_15(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
-  ei.kingAttackersCount[BLACK] = count_1s_max_15(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
+  ei.kingAttackersCount[WHITE] = count_1s_max_15<false>(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
+  ei.kingAttackersCount[BLACK] = count_1s_max_15<false>(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
 
   // Evaluate pieces
   for (Color c = WHITE; c <= BLACK; c++)
   {
-    Bitboard pinned = pos.pinned_pieces(c);
-
-    // Knights
-    for (int i = 0; i < pos.piece_count(c, KNIGHT); i++)
-        evaluate_knight(pos, pos.piece_list(c, KNIGHT, i), c, pinned, ei);
-
-    // Bishops
-    for (int i = 0; i < pos.piece_count(c, BISHOP); i++)
-        evaluate_bishop(pos, pos.piece_list(c, BISHOP, i), c, pinned, ei);
-
-    // Rooks
-    for (int i = 0; i < pos.piece_count(c, ROOK); i++)
-        evaluate_rook(pos, pos.piece_list(c, ROOK, i), c, pinned, ei);
-
-    // Queens
-    for(int i = 0; i < pos.piece_count(c, QUEEN); i++)
-        evaluate_queen(pos, pos.piece_list(c, QUEEN, i), c, pinned, ei);
-
-    // Special pattern: trapped bishops on a7/h7/a2/h2
-    Bitboard b = pos.bishops(c) & MaskA7H7[c];
-    while (b)
-    {
-        Square s = pop_1st_bit(&b);
-        evaluate_trapped_bishop_a7h7(pos, s, c, ei);
-    }
-
-    // Special pattern: trapped bishops on a1/h1/a8/h8 in Chess960:
-    if (Chess960)
-    {
-        b = pos.bishops(c) & MaskA1H1[c];
-        while (b)
-        {
-            Square s = pop_1st_bit(&b);
-            evaluate_trapped_bishop_a1h1(pos, s, c, ei);
-        }
-    }
-
-    // Sum up all attacked squares
-    ei.attackedBy[c][0] =   ei.attackedBy[c][PAWN]   | ei.attackedBy[c][KNIGHT]
-                          | ei.attackedBy[c][BISHOP] | ei.attackedBy[c][ROOK]
-                          | ei.attackedBy[c][QUEEN]  | ei.attackedBy[c][KING];
+      evaluate_pieces<KNIGHT>(pos, c, ei);
+      evaluate_pieces<BISHOP>(pos, c, ei);
+      evaluate_pieces<ROOK>(pos, c, ei);
+      evaluate_pieces<QUEEN>(pos, c, ei);
+
+      // Sum up all attacked squares
+      ei.attackedBy[c][0] =   ei.attackedBy[c][PAWN]   | ei.attackedBy[c][KNIGHT]
+                            | ei.attackedBy[c][BISHOP] | ei.attackedBy[c][ROOK]
+                            | ei.attackedBy[c][QUEEN]  | ei.attackedBy[c][KING];
   }
 
   // Kings.  Kings are evaluated after all other pieces for both sides,
   // because we need complete attack information for all pieces when computing
   // the king safety evaluation.
   for (Color c = WHITE; c <= BLACK; c++)
-      evaluate_king(pos, pos.king_square(c), c, ei);
+      evaluate_pieces<KING>(pos, c, ei);
 
   // Evaluate passed pawns.  We evaluate passed pawns for both sides at once,
   // because we need to know which side promotes first in positions where
@@ -519,7 +481,10 @@ void init_eval(int threads) {
   }
 
   for (Bitboard b = 0ULL; b < 256ULL; b++)
-      BitCount8Bit[b] = count_1s(b);
+  {
+      assert(count_1s<false>(b) == int(uint8_t(count_1s<false>(b))));
+      BitCount8Bit[b] = (uint8_t)count_1s<false>(b);
+  }
 }
 
 
@@ -531,6 +496,8 @@ void quit_eval() {
   {
       delete PawnTable[i];
       delete MaterialTable[i];
+      PawnTable[i] = NULL;
+      MaterialTable[i] = NULL;
   }
 }
 
@@ -562,14 +529,13 @@ namespace {
   // evaluate_common() computes terms common to all pieces attack
 
   template<PieceType Piece>
-  int evaluate_common(const Position& p, const Bitboard& b, Color us, Bitboard pinned, EvalInfo& ei, Square s = SQ_NONE) {
+  int evaluate_common(const Position& p, const Bitboard& b, Color us, EvalInfo& ei, Square s = SQ_NONE) {
 
     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
     static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
     static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
     static const Value* OutpostBonus[] = { 0, 0, KnightOutpostBonus, BishopOutpostBonus, 0, 0 };
 
-    int mob;
     Color them = opposite_color(us);
 
     // Update attack info
@@ -582,150 +548,138 @@ namespace {
         ei.kingAttackersWeight[us] += AttackWeight[Piece];
         Bitboard bb = (b & ei.attackedBy[them][KING]);
         if (bb)
-            ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15(bb);
+            ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15<false>(bb);
     }
 
-    if (pinned && bit_is_set(pinned, s))
-        mob = 0;
-    else
-    {
-        // Remove squares protected by enemy pawns
-        Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
+    // Remove squares protected by enemy pawns
+    Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
 
-        // Mobility
-        mob = (Piece != QUEEN ? count_1s_max_15(bb & ~p.pieces_of_color(us))
-                              : count_1s(bb & ~p.pieces_of_color(us)));
+    // Mobility
+    int mob = (Piece != QUEEN ? count_1s_max_15<false>(bb & ~p.pieces_of_color(us))
+                              : count_1s<false>(bb & ~p.pieces_of_color(us)));
 
-        ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
-        ei.egMobility += Sign[us] * EgBonus[Piece][mob];
-    }
+    ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
+    ei.egMobility += Sign[us] * EgBonus[Piece][mob];
 
     // Bishop and Knight outposts
-    if (  (Piece != BISHOP && Piece != KNIGHT) // compile time condition
-        || !p.square_is_weak(s, them))
-        return mob;
-
-    // Initial bonus based on square
-    Value v, bonus;
-    v = bonus = OutpostBonus[Piece][relative_square(us, s)];
-
-    // Increase bonus if supported by pawn, especially if the opponent has
-    // no minor piece which can exchange the outpost piece
-    if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
+    if (   (Piece == BISHOP || Piece == KNIGHT) // compile time condition
+        && p.square_is_weak(s, them))
     {
-        bonus += v / 2;
-        if (   p.piece_count(them, KNIGHT) == 0
-            && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
-            bonus += v;
+        // Initial bonus based on square
+        Value v, bonus;
+        v = bonus = OutpostBonus[Piece][relative_square(us, s)];
+
+        // Increase bonus if supported by pawn, especially if the opponent has
+        // no minor piece which can exchange the outpost piece
+        if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
+        {
+            bonus += v / 2;
+            if (   p.piece_count(them, KNIGHT) == 0
+                   && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
+                bonus += v;
+        }
+        ei.mgValue += Sign[us] * bonus;
+        ei.egValue += Sign[us] * bonus;
     }
-    ei.mgValue += Sign[us] * bonus;
-    ei.egValue += Sign[us] * bonus;
     return mob;
   }
 
 
-  // evaluate_knight() assigns bonuses and penalties to a knight of a given
-  // color on a given square.
-
-  void evaluate_knight(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei) {
-
-    // Attacks, mobility and outposts
-    evaluate_common<KNIGHT>(p, p.piece_attacks<KNIGHT>(s), us, pinned, ei, s);
-  }
-
+  // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
+  // color.
 
-  // evaluate_bishop() assigns bonuses and penalties to a bishop of a given
-  // color on a given square.
-
-  void evaluate_bishop(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei) {
-
-    Bitboard b = bishop_attacks_bb(s, p.occupied_squares() & ~p.queens(us));
-
-    // Attacks, mobility and outposts
-    evaluate_common<BISHOP>(p, b, us, pinned, ei, s);
-  }
-
-
-  // evaluate_rook() assigns bonuses and penalties to a rook of a given
-  // color on a given square.
-
-  void evaluate_rook(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei) {
-
-    Bitboard b = rook_attacks_bb(s, p.occupied_squares() & ~p.rooks_and_queens(us));
-
-    // Attacks and mobility
-    int mob = evaluate_common<ROOK>(p, b, us, pinned, ei);
+  template<PieceType Piece>
+  void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) {
 
-    // Rook on 7th rank
-    Color them = opposite_color(us);
+    Bitboard b;
+    Square s, ksq;
+    Color them;
+    int mob;
+    File f;
 
-    if (   relative_rank(us, s) == RANK_7
-        && relative_rank(us, p.king_square(them)) == RANK_8)
+    for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
     {
-        ei.mgValue += Sign[us] * MidgameRookOn7thBonus;
-        ei.egValue += Sign[us] * EndgameRookOn7thBonus;
-    }
+        s = pos.piece_list(us, Piece, i);
 
-    // Open and half-open files
-    File f = square_file(s);
-    if (ei.pi->file_is_half_open(us, f))
-    {
-        if (ei.pi->file_is_half_open(them, f))
-        {
-            ei.mgValue += Sign[us] * RookOpenFileBonus;
-            ei.egValue += Sign[us] * RookOpenFileBonus;
-        }
-        else
-        {
-            ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
-            ei.egValue += Sign[us] * RookHalfOpenFileBonus;
-        }
-    }
+        if (Piece == KNIGHT || Piece == QUEEN)
+            b = pos.piece_attacks<Piece>(s);
+        else if (Piece == BISHOP)
+            b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.queens(us));
+        else if (Piece == ROOK)
+            b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.rooks_and_queens(us));
 
-    // Penalize rooks which are trapped inside a king. Penalize more if
-    // king has lost right to castle
-    if (mob > 6 || ei.pi->file_is_half_open(us, f))
-        return;
+        // Attacks, mobility and outposts
+        mob = evaluate_common<Piece>(pos, b, us, ei, s);
 
-    Square ksq = p.king_square(us);
+        // Special patterns: trapped bishops on a7/h7/a2/h2
+        // and trapped bishops on a1/h1/a8/h8 in Chess960.
+        if (Piece == BISHOP)
+        {
+            if (bit_is_set(MaskA7H7[us], s))
+                evaluate_trapped_bishop_a7h7(pos, s, us, ei);
 
-    if (    square_file(ksq) >= FILE_E
-        &&  square_file(s) > square_file(ksq)
-        && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
-    {
-        // Is there a half-open file between the king and the edge of the board?
-        if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
-            ei.mgValue -= p.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
-                                          : Sign[us] *  (TrappedRookPenalty - mob * 16);
-    }
-    else if (    square_file(ksq) <= FILE_D
-             &&  square_file(s) < square_file(ksq)
-             && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
-    {
-        // Is there a half-open file between the king and the edge of the board?
-        if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
-            ei.mgValue -= p.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
-                                          : Sign[us] * (TrappedRookPenalty - mob * 16);
-    }
-  }
+            if (Chess960 && bit_is_set(MaskA1H1[us], s))
+                evaluate_trapped_bishop_a1h1(pos, s, us, ei);
+        }
 
+        if (Piece == ROOK || Piece == QUEEN)
+        {
+            // Queen or rook on 7th rank
+            them = opposite_color(us);
 
-  // evaluate_queen() assigns bonuses and penalties to a queen of a given
-  // color on a given square.
+            if (   relative_rank(us, s) == RANK_7
+                && relative_rank(us, pos.king_square(them)) == RANK_8)
+            {
+                ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
+                ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
+            }
+        }
 
-  void evaluate_queen(const Position& p, Square s, Color us, Bitboard pinned, EvalInfo& ei) {
+        // Special extra evaluation for rooks
+        if (Piece == ROOK)
+        {
+            // Open and half-open files
+            f = square_file(s);
+            if (ei.pi->file_is_half_open(us, f))
+            {
+                if (ei.pi->file_is_half_open(them, f))
+                {
+                    ei.mgValue += Sign[us] * RookOpenFileBonus;
+                    ei.egValue += Sign[us] * RookOpenFileBonus;
+                }
+                else
+                {
+                    ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
+                    ei.egValue += Sign[us] * RookHalfOpenFileBonus;
+                }
+            }
 
-    // Attacks and mobility
-    evaluate_common<QUEEN>(p, p.piece_attacks<QUEEN>(s), us, pinned, ei);
+            // Penalize rooks which are trapped inside a king. Penalize more if
+            // king has lost right to castle.
+            if (mob > 6 || ei.pi->file_is_half_open(us, f))
+                continue;
 
-    // Queen on 7th rank
-    Color them = opposite_color(us);
+            ksq = pos.king_square(us);
 
-    if (   relative_rank(us, s) == RANK_7
-        && relative_rank(us, p.king_square(them)) == RANK_8)
-    {
-        ei.mgValue += Sign[us] * MidgameQueenOn7thBonus;
-        ei.egValue += Sign[us] * EndgameQueenOn7thBonus;
+            if (    square_file(ksq) >= FILE_E
+                &&  square_file(s) > square_file(ksq)
+                && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
+            {
+                // Is there a half-open file between the king and the edge of the board?
+                if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
+                    ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
+                                                    : Sign[us] *  (TrappedRookPenalty - mob * 16);
+            }
+            else if (    square_file(ksq) <= FILE_D
+                    &&  square_file(s) < square_file(ksq)
+                    && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
+            {
+                // Is there a half-open file between the king and the edge of the board?
+                if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
+                    ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
+                                                    : Sign[us] * (TrappedRookPenalty - mob * 16);
+            }
+        }
     }
   }
 
@@ -734,21 +688,31 @@ namespace {
     return b >> (num << 3);
   }
 
-  // evaluate_king() assigns bonuses and penalties to a king of a given
-  // color on a given square.
+  // evaluate_pieces<KING>() assigns bonuses and penalties to a king of a given
+  // color.
 
-  void evaluate_king(const Position& p, Square s, Color us, EvalInfo& ei) {
+  template<>
+  void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo& ei) {
 
     int shelter = 0, sign = Sign[us];
+    Square s = p.king_square(us);
 
     // King shelter
     if (relative_rank(us, s) <= RANK_4)
     {
-        Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
-        Rank r = square_rank(s);
-        for (int i = 1; i < 4; i++)
-            shelter += count_1s_8bit(shiftRowsDown(pawns, r+i*sign)) * (128>>i);
-
+        // Shelter cache lookup
+        shelter = ei.pi->kingShelter(us, s);
+        if (shelter == -1)
+        {
+            shelter = 0;
+            Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
+            Rank r = square_rank(s);
+            for (int i = 1; i < 4; i++)
+                shelter += BitCount8Bit[shiftRowsDown(pawns, r+i*sign) & 0xFF] * (128 >> i);
+
+            // Cache shelter value in pawn info
+            ei.pi->setKingShelter(us, s, shelter);
+        }
         ei.mgValue += sign * Value(shelter);
     }
 
@@ -781,7 +745,7 @@ namespace {
       // quality of the pawn shelter.
       int attackUnits =
             Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
-          + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15(undefended)) * 3
+          + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<false>(undefended)) * 3
           + InitKingDanger[relative_square(us, s)] - (shelter >> 5);
 
       // Analyse safe queen contact checks
@@ -797,7 +761,7 @@ namespace {
         {
           // The bitboard b now contains the squares available for safe queen
           // contact checks.
-          int count = count_1s_max_15(b);
+          int count = count_1s_max_15<false>(b);
           attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
 
           // Is there a mate threat?
@@ -819,7 +783,7 @@ namespace {
                         if (    bit_is_set(p.piece_attacks<QUEEN>(from), to)
                             && !bit_is_set(p.pinned_pieces(them), from)
                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
-                            && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us)))
+                            && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.bishops_and_queens(us)))
 
                             ei.mateThreat[them] = make_move(from, to);
                     }
@@ -837,12 +801,12 @@ namespace {
           // Queen checks
           b2 = b & ei.attacked_by(them, QUEEN);
           if( b2)
-              attackUnits += QueenCheckBonus * count_1s_max_15(b2);
+              attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
 
           // Rook checks
           b2 = b & ei.attacked_by(them, ROOK);
           if (b2)
-              attackUnits += RookCheckBonus * count_1s_max_15(b2);
+              attackUnits += RookCheckBonus * count_1s_max_15<false>(b2);
       }
       if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
       {
@@ -851,12 +815,12 @@ namespace {
           // Queen checks
           b2 = b & ei.attacked_by(them, QUEEN);
           if (b2)
-              attackUnits += QueenCheckBonus * count_1s_max_15(b2);
+              attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
 
           // Bishop checks
           b2 = b & ei.attacked_by(them, BISHOP);
           if (b2)
-              attackUnits += BishopCheckBonus * count_1s_max_15(b2);
+              attackUnits += BishopCheckBonus * count_1s_max_15<false>(b2);
       }
       if (KnightCheckBonus > 0)
       {
@@ -865,7 +829,7 @@ namespace {
           // Knight checks
           b2 = b & ei.attacked_by(them, KNIGHT);
           if (b2)
-              attackUnits += KnightCheckBonus * count_1s_max_15(b2);
+              attackUnits += KnightCheckBonus * count_1s_max_15<false>(b2);
       }
 
       // Analyse discovered checks (only for non-pawns right now, consider
@@ -874,7 +838,7 @@ namespace {
       {
         b = p.discovered_check_candidates(them) & ~p.pawns();
         if (b)
-          attackUnits += DiscoveredCheckBonus * count_1s_max_15(b) * (sente? 2 : 1);
+          attackUnits += DiscoveredCheckBonus * count_1s_max_15<false>(b) * (sente? 2 : 1);
       }
 
       // Has a mate threat been found?  We don't do anything here if the
@@ -1009,7 +973,7 @@ namespace {
                 if (d < 0)
                 {
                     int mtg = RANK_8 - relative_rank(us, s);
-                    int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
+                    int blockerCount = count_1s_max_15<false>(squares_in_front_of(us,s) & pos.occupied_squares());
                     mtg += blockerCount;
                     d += blockerCount;
                     if (d < 0)
@@ -1170,8 +1134,8 @@ namespace {
         behindFriendlyPawns |= (behindFriendlyPawns << 16);
     }
 
-    int space =  count_1s_max_15(safeSquares)
-               + count_1s_max_15(behindFriendlyPawns & safeSquares);
+    int space =  count_1s_max_15<false>(safeSquares)
+               + count_1s_max_15<false>(behindFriendlyPawns & safeSquares);
 
     ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
   }
@@ -1201,15 +1165,6 @@ namespace {
   }
 
 
-  // count_1s_8bit() counts the number of nonzero bits in the 8 least
-  // significant bits of a Bitboard. This function is used by the king
-  // shield evaluation.
-
-  int count_1s_8bit(Bitboard b) {
-    return int(BitCount8Bit[b & 0xFF]);
-  }
-
-
   // compute_weight() computes the value of an evaluation weight, by combining
   // an UCI-configurable weight with an internal weight.