V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0),
V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0),
V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0),
- V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0),
- V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
- V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) },
+ V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0) },
{
V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops
V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0),
V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0),
V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0),
- V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0),
- V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0),
- V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0) }
+ V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) }
};
// ThreatBonus[attacking][attacked] contains threat bonuses according to
// Function prototypes
template<bool HasPopCnt>
- Value do_evaluate(const Position& pos, Value margins[]);
+ Value do_evaluate(const Position& pos, Value& margin);
template<Color Us, bool HasPopCnt>
void init_eval_info(const Position& pos, EvalInfo& ei);
Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
template<Color Us, bool HasPopCnt>
- Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]);
+ Score evaluate_king(const Position& pos, EvalInfo& ei, Value& margin);
template<Color Us>
Score evaluate_threats(const Position& pos, EvalInfo& ei);
Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
Score apply_weight(Score v, Score weight);
- Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]);
+ Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf);
Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
void init_safety();
}
/// evaluate() is the main evaluation function. It always computes two
/// values, an endgame score and a middle game score, and interpolates
/// between them based on the remaining material.
-Value evaluate(const Position& pos, Value margins[]) {
+Value evaluate(const Position& pos, Value& margin) {
- return CpuHasPOPCNT ? do_evaluate<true>(pos, margins)
- : do_evaluate<false>(pos, margins);
+ return CpuHasPOPCNT ? do_evaluate<true>(pos, margin)
+ : do_evaluate<false>(pos, margin);
}
namespace {
template<bool HasPopCnt>
-Value do_evaluate(const Position& pos, Value margins[]) {
+Value do_evaluate(const Position& pos, Value& margin) {
EvalInfo ei;
- ScaleFactor factor[2];
Score mobilityWhite, mobilityBlack;
assert(pos.is_ok());
// in the position object (material + piece square tables).
Score bonus = pos.value();
- // margins[color] is the uncertainty estimation of position's evaluation
+ // margin is the uncertainty estimation of position's evaluation
// and typically is used by the search for pruning decisions.
- margins[WHITE] = margins[BLACK] = VALUE_ZERO;
+ margin = VALUE_ZERO;
// Probe the material hash table
MaterialInfo* mi = MaterialTable[pos.thread()]->get_material_info(pos);
if (mi->specialized_eval_exists())
return mi->evaluate(pos);
- // After get_material_info() call that modifies them
- factor[WHITE] = mi->scale_factor(pos, WHITE);
- factor[BLACK] = mi->scale_factor(pos, BLACK);
-
// Probe the pawn hash table
ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
bonus += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
// Evaluate kings after all other pieces because we need complete attack
// information when computing the king safety evaluation.
- bonus += evaluate_king<WHITE, HasPopCnt>(pos, ei, margins)
- - evaluate_king<BLACK, HasPopCnt>(pos, ei, margins);
+ bonus += evaluate_king<WHITE, HasPopCnt>(pos, ei, margin)
+ - evaluate_king<BLACK, HasPopCnt>(pos, ei, margin);
// Evaluate tactical threats, we need full attack information including king
bonus += evaluate_threats<WHITE>(pos, ei)
bonus += apply_weight(make_score(s * mi->space_weight(), 0), Weights[Space]);
}
+ // Scale winning side if position is more drawish that what it appears
+ ScaleFactor sf = eg_value(bonus) > VALUE_ZERO ? mi->scale_factor(pos, WHITE)
+ : mi->scale_factor(pos, BLACK);
+
// If we don't already have an unusual scale factor, check for opposite
- // colored bishop endgames, and use a lower scale for those
+ // colored bishop endgames, and use a lower scale for those.
if ( phase < PHASE_MIDGAME
&& pos.opposite_colored_bishops()
- && ( (factor[WHITE] == SCALE_FACTOR_NORMAL && eg_value(bonus) > VALUE_ZERO)
- || (factor[BLACK] == SCALE_FACTOR_NORMAL && eg_value(bonus) < VALUE_ZERO)))
+ && sf == SCALE_FACTOR_NORMAL)
{
- ScaleFactor sf;
-
// Only the two bishops ?
if ( pos.non_pawn_material(WHITE) == BishopValueMidgame
&& pos.non_pawn_material(BLACK) == BishopValueMidgame)
// Endgame with opposite-colored bishops, but also other pieces. Still
// a bit drawish, but not as drawish as with only the two bishops.
sf = ScaleFactor(50);
-
- if (factor[WHITE] == SCALE_FACTOR_NORMAL)
- factor[WHITE] = sf;
- if (factor[BLACK] == SCALE_FACTOR_NORMAL)
- factor[BLACK] = sf;
}
// Interpolate between the middle game and the endgame score
- Value v = scale_by_game_phase(bonus, phase, factor);
+ Value v = scale_by_game_phase(bonus, phase, sf);
return pos.side_to_move() == WHITE ? v : -v;
}
// evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given color
template<PieceType Piece, Color Us, bool HasPopCnt>
- Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard no_mob_area) {
+ Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
Bitboard b;
Square s, ksq;
}
// Mobility
- mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & no_mob_area)
- : count_1s<HasPopCnt>(b & no_mob_area));
+ mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & mobilityArea)
+ : count_1s<HasPopCnt>(b & mobilityArea));
mobility += MobilityBonus[Piece][mob];
Score bonus = mobility = SCORE_ZERO;
// Do not include in mobility squares protected by enemy pawns or occupied by our pieces
- const Bitboard no_mob_area = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
+ const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
- bonus += evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei, mobility, no_mob_area);
- bonus += evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei, mobility, no_mob_area);
- bonus += evaluate_pieces<ROOK, Us, HasPopCnt>(pos, ei, mobility, no_mob_area);
- bonus += evaluate_pieces<QUEEN, Us, HasPopCnt>(pos, ei, mobility, no_mob_area);
+ bonus += evaluate_pieces<KNIGHT, Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
+ bonus += evaluate_pieces<BISHOP, Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
+ bonus += evaluate_pieces<ROOK, Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
+ bonus += evaluate_pieces<QUEEN, Us, HasPopCnt>(pos, ei, mobility, mobilityArea);
// Sum up all attacked squares
ei.attackedBy[Us][0] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
// evaluate_king<>() assigns bonuses and penalties to a king of a given color
template<Color Us, bool HasPopCnt>
- Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) {
+ Score evaluate_king(const Position& pos, EvalInfo& ei, Value& margin) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
// be very big, and so capturing a single attacking piece can therefore
// result in a score change far bigger than the value of the captured piece.
bonus -= KingDangerTable[Us][attackUnits];
- margins[Us] += mg_value(KingDangerTable[Us][attackUnits]);
+ if (pos.side_to_move() == Us)
+ margin += mg_value(KingDangerTable[Us][attackUnits]);
}
return bonus;
}
// scale_by_game_phase() interpolates between a middle game and an endgame score,
// based on game phase. It also scales the return value by a ScaleFactor array.
- Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]) {
+ Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf) {
assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
Value eg = eg_value(v);
- ScaleFactor f = sf[eg > VALUE_ZERO ? WHITE : BLACK];
- Value ev = Value((eg * int(f)) / SCALE_FACTOR_NORMAL);
+ Value ev = Value((eg * int(sf)) / SCALE_FACTOR_NORMAL);
int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
return Value(result & ~(GrainSize - 1));
projects / stockfish / blobdiff