struct EvalInfo {
// Pointers to material and pawn hash table entries
- MaterialEntry* mi;
- PawnEntry* pi;
+ 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][0] contains
const int GrainSize = 8;
// Evaluation weights, initialized from UCI options
- enum { Mobility, PassedPawns, Space, KingDangerUs, KingDangerThem };
- Score Weights[6];
+ enum { Mobility, PassedPawns, Space };
+ Score Weights[3];
typedef Value V;
#define S(mg, eg) make_score(mg, eg)
//
// Values modified by Joona Kiiski
const Score WeightsInternal[] = {
- S(252, 344), S(216, 266), S(46, 0), S(247, 0), S(259, 0)
+ S(252, 344), S(216, 266), S(46, 0)
};
// MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
#undef S
+ Score BishopPinBonus = make_score(27, 12);
+
// Bonus for having the side to move (modified by Joona Kiiski)
const Score Tempo = make_score(24, 11);
// the strength of the enemy attack are added up into an integer, which
// is used as an index to KingDangerTable[].
//
+ // King safety evaluation is asymmetrical and different for us (root color)
+ // and for our opponent. These values are used to init KingDangerTable.
+ const int KingDangerWeights[] = { 259, 247 };
+
// KingAttackWeights[PieceType] contains king attack weights by piece type
const int KingAttackWeights[] = { 0, 0, 2, 2, 3, 5 };
void init() {
- Weights[Mobility] = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
- Weights[PassedPawns] = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
- Weights[Space] = weight_option("Space", "Space", WeightsInternal[Space]);
- Weights[KingDangerUs] = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
- Weights[KingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
-
- // King safety is asymmetrical. Our king danger level is weighted by
- // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
- // If running in analysis mode, make sure we use symmetrical king safety. We
- // do this by replacing both Weights[kingDangerUs] and Weights[kingDangerThem]
- // by their average.
+ Weights[Mobility] = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
+ Weights[PassedPawns] = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
+ Weights[Space] = weight_option("Space", "Space", WeightsInternal[Space]);
+
+ int KingDanger[] = { KingDangerWeights[0], KingDangerWeights[1] };
+
+ // If running in analysis mode, make sure we use symmetrical king safety.
+ // We do so by replacing both KingDanger weights by their average.
if (Options["UCI_AnalyseMode"])
- Weights[KingDangerUs] = Weights[KingDangerThem] = (Weights[KingDangerUs] + Weights[KingDangerThem]) / 2;
+ KingDanger[0] = KingDanger[1] = (KingDanger[0] + KingDanger[1]) / 2;
const int MaxSlope = 30;
const int Peak = 1280;
{
t = std::min(Peak, std::min(int(0.4 * i * i), t + MaxSlope));
- KingDangerTable[1][i] = apply_weight(make_score(t, 0), Weights[KingDangerUs]);
- KingDangerTable[0][i] = apply_weight(make_score(t, 0), Weights[KingDangerThem]);
+ KingDangerTable[0][i] = apply_weight(make_score(t, 0), make_score(KingDanger[0], 0));
+ KingDangerTable[1][i] = apply_weight(make_score(t, 0), make_score(KingDanger[1], 0));
}
+
+ BishopPinBonus = make_score(Options["pin_open"], Options["pin_end"]);
}
template<bool Trace>
Value do_evaluate(const Position& pos, Value& margin) {
- assert(!pos.in_check());
+ assert(!pos.checkers());
EvalInfo ei;
Value margins[COLOR_NB];
Score score, mobilityWhite, mobilityBlack;
+ Thread* th = pos.this_thread();
// margins[] store the uncertainty estimation of position's evaluation
// that typically is used by the search for pruning decisions.
score = pos.psq_score() + (pos.side_to_move() == WHITE ? Tempo : -Tempo);
// Probe the material hash table
- ei.mi = pos.this_thread()->materialTable.probe(pos);
+ ei.mi = Material::probe(pos, th->materialTable, th->endgames);
score += ei.mi->material_value();
// If we have a specialized evaluation function for the current material
}
// Probe the pawn hash table
- ei.pi = pos.this_thread()->pawnTable.probe(pos);
+ ei.pi = Pawns::probe(pos, th->pawnsTable);
score += ei.pi->pawns_value();
// Initialize attack and king safety bitboards
mobility += MobilityBonus[Piece][mob];
- // Add a bonus if a slider is pinning an enemy piece
- if ( (Piece == BISHOP || Piece == ROOK || Piece == QUEEN)
- && (PseudoAttacks[Piece][pos.king_square(Them)] & s))
- {
- b = BetweenBB[s][pos.king_square(Them)] & pos.pieces();
-
- assert(b);
-
- if (!more_than_one(b) && (b & pos.pieces(Them)))
- score += ThreatBonus[Piece][type_of(pos.piece_on(lsb(b)))];
- }
-
// Decrease score if we are attacked by an enemy pawn. Remaining part
// of threat evaluation must be done later when we have full attack info.
if (ei.attackedBy[Them][PAWN] & s)
score -= ThreatenedByPawnPenalty[Piece];
+ else if (Piece == BISHOP && (PseudoAttacks[Piece][pos.king_square(Them)] & s)) {
+ const Bitboard between = BetweenBB[s][pos.king_square(Them)] & pos.pieces();
+ if (!more_than_one(between))
+ score += BishopPinBonus;
+ }
// Bishop and knight outposts squares
if ( (Piece == BISHOP || Piece == KNIGHT)
& ~ei.attackedBy[Them][0];
if (undefendedMinors)
- score += more_than_one(undefendedMinors) ? UndefendedMinorPenalty * 2
- : UndefendedMinorPenalty;
+ score += UndefendedMinorPenalty;
// Enemy pieces not defended by a pawn and under our attack
weakEnemies = pos.pieces(Them)
// Opponent king cannot block because path is defended and position
// is not in check. So only friendly pieces can be blockers.
- assert(!pos.in_check());
+ assert(!pos.checkers());
assert((queeningPath & pos.pieces()) == (queeningPath & pos.pieces(c)));
// Add moves needed to free the path from friendly pieces and retest condition
behind |= (Us == WHITE ? behind >> 8 : behind << 8);
behind |= (Us == WHITE ? behind >> 16 : behind << 16);
- return popcount<Max15>(safe) + popcount<Max15>(behind & safe);
+ // Since SpaceMask[Us] is fully on our half of the board
+ assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);
+
+ // Count safe + (behind & safe) with a single popcount
+ return popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
}