Merge mobility area tweak
authorMarco Costalba <mcostalba@gmail.com>
Fri, 3 May 2013 08:10:08 +0000 (10:10 +0200)
committerMarco Costalba <mcostalba@gmail.com>
Fri, 3 May 2013 08:12:31 +0000 (10:12 +0200)
A nice improvment.

Was good at 15+0.05
LLR: 2.96 (-2.94,2.94)
Total: 10731 W: 2176 L: 2040 D: 6515

And at 60"+0.05
LLR: 2.96 (-2.94,2.94)
Total: 10601 W: 1968 L: 1810 D: 6823

bench: 4676606

1  2 
src/evaluate.cpp

diff --combined src/evaluate.cpp
index e861f5f032e95d80f54bb4137447e617686b338b,a06fcabd02baac3335e376d4a5988e95680a6f08..5a8a292f9a24c34596309562f6c86c79a29fb4c0
  
  #include "bitcount.h"
  #include "evaluate.h"
 +#include "material.h"
 +#include "pawns.h"
  #include "thread.h"
  #include "ucioption.h"
  
 -using namespace Eval;
 -
  namespace {
  
 +  // Struct EvalInfo contains various information computed and collected
 +  // by the evaluation functions.
 +  struct EvalInfo {
 +
 +    // Pointers to material and pawn hash table entries
 +    Material::Entry* mi;
 +    Pawns::Entry* pi;
 +
 +    // attackedBy[color][piece type] is a bitboard representing all squares
 +    // attacked by a given color and piece type, attackedBy[color][ALL_PIECES]
 +    // contains all squares attacked by the given color.
 +    Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
 +
 +    // kingRing[color] is the zone around the king which is considered
 +    // by the king safety evaluation. This consists of the squares directly
 +    // adjacent to the king, and the three (or two, for a king on an edge file)
 +    // squares two ranks in front of the king. For instance, if black's king
 +    // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
 +    // f7, g7, h7, f6, g6 and h6.
 +    Bitboard kingRing[COLOR_NB];
 +
 +    // kingAttackersCount[color] is the number of pieces of the given color
 +    // which attack a square in the kingRing of the enemy king.
 +    int kingAttackersCount[COLOR_NB];
 +
 +    // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
 +    // given color which attack a square in the kingRing of the enemy king. The
 +    // weights of the individual piece types are given by the variables
 +    // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
 +    // KnightAttackWeight in evaluate.cpp
 +    int kingAttackersWeight[COLOR_NB];
 +
 +    // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
 +    // directly adjacent to the king of the given color. Pieces which attack
 +    // more than one square are counted multiple times. For instance, if black's
 +    // king is on g8 and there's a white knight on g5, this knight adds
 +    // 2 to kingAdjacentZoneAttacksCount[BLACK].
 +    int kingAdjacentZoneAttacksCount[COLOR_NB];
 +  };
 +
    // Evaluation grain size, must be a power of 2
    const int GrainSize = 8;
  
  
    // Function prototypes
    template<bool Trace>
 -  Value do_evaluate(const Position& pos, Value& margin, Info& ei);
 +  Value do_evaluate(const Position& pos, Value& margin);
  
    template<Color Us>
 -  void init_eval_info(const Position& pos, Info& ei);
 +  void init_eval_info(const Position& pos, EvalInfo& ei);
  
    template<Color Us, bool Trace>
 -  Score evaluate_pieces_of_color(const Position& pos, Info& ei, Score& mobility);
 +  Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
  
    template<Color Us, bool Trace>
 -  Score evaluate_king(const Position& pos, Info& ei, Value margins[]);
 +  Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]);
  
    template<Color Us>
 -  Score evaluate_threats(const Position& pos, Info& ei);
 +  Score evaluate_threats(const Position& pos, EvalInfo& ei);
  
    template<Color Us>
 -  int evaluate_space(const Position& pos, Info& ei);
 +  int evaluate_space(const Position& pos, EvalInfo& ei);
  
    template<Color Us>
 -  Score evaluate_passed_pawns(const Position& pos, Info& ei);
 +  Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
  
 -  Score evaluate_unstoppable_pawns(const Position& pos, Info& ei);
 +  Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
  
    Value interpolate(const Score& v, Phase ph, ScaleFactor sf);
    Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
@@@ -276,8 -236,8 +276,8 @@@ namespace Eval 
    /// values, an endgame score and a middle game score, and interpolates
    /// between them based on the remaining material.
  
 -  Value evaluate(const Position& pos, Value& margin, Info* ei) {
 -    return do_evaluate<false>(pos, margin, *ei);
 +  Value evaluate(const Position& pos, Value& margin) {
 +    return do_evaluate<false>(pos, margin);
    }
  
  
  
      Value margin;
      std::string totals;
 -    Info ei;
  
      Search::RootColor = pos.side_to_move();
  
      TraceStream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
      memset(TracedScores, 0, 2 * 16 * sizeof(Score));
  
 -    do_evaluate<true>(pos, margin, ei);
 +    do_evaluate<true>(pos, margin);
  
      totals = TraceStream.str();
      TraceStream.str("");
  namespace {
  
  template<bool Trace>
 -Value do_evaluate(const Position& pos, Value& margin, Info& ei) {
 +Value do_evaluate(const Position& pos, Value& margin) {
  
    assert(!pos.checkers());
  
 +  EvalInfo ei;
    Value margins[COLOR_NB];
    Score score, mobilityWhite, mobilityBlack;
    Thread* th = pos.this_thread();
    // pawn attacks. To be done at the beginning of the evaluation.
  
    template<Color Us>
 -  void init_eval_info(const Position& pos, Info& ei) {
 +  void init_eval_info(const Position& pos, EvalInfo& ei) {
  
      const Color Them = (Us == WHITE ? BLACK : WHITE);
  
    // evaluate_outposts() evaluates bishop and knight outposts squares
  
    template<PieceType Piece, Color Us>
 -  Score evaluate_outposts(const Position& pos, Info& ei, Square s) {
 +  Score evaluate_outposts(const Position& pos, EvalInfo& ei, Square s) {
  
      const Color Them = (Us == WHITE ? BLACK : WHITE);
  
    // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
  
    template<PieceType Piece, Color Us, bool Trace>
 -  Score evaluate_pieces(const Position& pos, Info& ei, Score& mobility, Bitboard mobilityArea) {
 +  Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
  
      Bitboard b;
      Square s, ksq;
    // and the type of attacked one.
  
    template<Color Us>
 -  Score evaluate_threats(const Position& pos, Info& ei) {
 +  Score evaluate_threats(const Position& pos, EvalInfo& ei) {
  
      const Color Them = (Us == WHITE ? BLACK : WHITE);
  
    // pieces of a given color.
  
    template<Color Us, bool Trace>
 -  Score evaluate_pieces_of_color(const Position& pos, Info& ei, Score& mobility) {
 +  Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility) {
  
      const Color Them = (Us == WHITE ? BLACK : WHITE);
  
      Score score = mobility = SCORE_ZERO;
  
      // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
-     const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us));
+     const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us, PAWN, KING));
  
      score += evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea);
      score += evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea);
    // evaluate_king<>() assigns bonuses and penalties to a king of a given color
  
    template<Color Us, bool Trace>
 -  Score evaluate_king(const Position& pos, Info& ei, Value margins[]) {
 +  Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
  
      const Color Them = (Us == WHITE ? BLACK : WHITE);
  
    // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
  
    template<Color Us>
 -  Score evaluate_passed_pawns(const Position& pos, Info& ei) {
 +  Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
  
      const Color Them = (Us == WHITE ? BLACK : WHITE);
  
    // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides, this is quite
    // conservative and returns a winning score only when we are very sure that the pawn is winning.
  
 -  Score evaluate_unstoppable_pawns(const Position& pos, Info& ei) {
 +  Score evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
  
      Bitboard b, b2, blockers, supporters, queeningPath, candidates;
      Square s, blockSq, queeningSquare;
    // twice. Finally, the space bonus is scaled by a weight taken from the
    // material hash table. The aim is to improve play on game opening.
    template<Color Us>
 -  int evaluate_space(const Position& pos, Info& ei) {
 +  int evaluate_space(const Position& pos, EvalInfo& ei) {
  
      const Color Them = (Us == WHITE ? BLACK : WHITE);