Pawns::Entry* pi;
};
-
- // Evaluation weights, indexed by the corresponding evaluation term
- enum { PawnStructure, PassedPawns, Space, KingSafety };
-
- const struct Weight { int mg, eg; } Weights[] = {
- {214, 203}, {193, 262}, {47, 0}, {330, 0} };
-
- Score operator*(Score s, const Weight& w) {
- return make_score(mg_value(s) * w.mg / 256, eg_value(s) * w.eg / 256);
- }
-
-
#define V(v) Value(v)
#define S(mg, eg) make_score(mg, eg)
// Passed[mg/eg][Rank] contains midgame and endgame bonuses for passed pawns.
// We don't use a Score because we process the two components independently.
const Value Passed[][RANK_NB] = {
- { V(0), V( 1), V(34), V(90), V(214), V(328) },
- { V(7), V(14), V(37), V(63), V(134), V(189) }
+ { V(0), V( 1), V(26), V(68), V(161), V(247) },
+ { V(7), V(14), V(38), V(64), V(137), V(193) }
};
// PassedFile[File] contains a bonus according to the file of a passed pawn
const Score PassedFile[FILE_NB] = {
- S( 12, 10), S( 3, 10), S( 1, -8), S(-27,-12),
- S(-27,-12), S( 1, -8), S( 3, 10), S( 12, 10)
+ S( 9, 10), S( 2, 10), S( 1, -8), S(-20,-12),
+ S(-20,-12), S( 1, -8), S( 2, 10), S( 9, 10)
};
// Assorted bonuses and penalties used by evaluation
else if (defendedSquares & blockSq)
k += 4;
- mbonus += k * rr, ebonus += k * rr;
+ mbonus += k * rr * 3 / 4, ebonus += k * rr;
}
else if (pos.pieces(Us) & blockSq)
- mbonus += rr * 3 + r * 2 + 3, ebonus += rr + r * 2;
+ mbonus += (rr * 3 + r * 2 + 3) * 3 / 4, ebonus += rr + r * 2;
} // rr != 0
if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))
}
if (DoTrace)
- Trace::add(PASSED, Us, score * Weights[PassedPawns]);
+ Trace::add(PASSED, Us, score);
// Add the scores to the middlegame and endgame eval
- return score * Weights[PassedPawns];
+ return score;
}
int weight = pos.count<KNIGHT>(Us) + pos.count<BISHOP>(Us)
+ pos.count<KNIGHT>(Them) + pos.count<BISHOP>(Them);
- return make_score(bonus * weight * weight, 0);
+ return make_score(bonus * weight * weight * 2 / 11, 0);
}
// Probe the pawn hash table
ei.pi = Pawns::probe(pos);
- score += ei.pi->pawns_score() * Weights[PawnStructure];
+ score += ei.pi->pawns_score();
// Initialize attack and king safety bitboards
ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0;
// Evaluate space for both sides, only during opening
if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)
- score += ( evaluate_space<WHITE>(pos, ei)
- - evaluate_space<BLACK>(pos, ei)) * Weights[Space];
+ score += evaluate_space<WHITE>(pos, ei)
+ - evaluate_space<BLACK>(pos, ei);
// Evaluate position potential for the winning side
score += evaluate_initiative(pos, ei.pi->pawn_asymmetry(), eg_value(score));
{
Trace::add(MATERIAL, pos.psq_score());
Trace::add(IMBALANCE, ei.me->imbalance());
- Trace::add(PAWN, ei.pi->pawns_score() * Weights[PawnStructure]);
+ Trace::add(PAWN, ei.pi->pawns_score());
Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
- Trace::add(SPACE, evaluate_space<WHITE>(pos, ei) * Weights[Space]
- , evaluate_space<BLACK>(pos, ei) * Weights[Space]);
+ Trace::add(SPACE, evaluate_space<WHITE>(pos, ei)
+ , evaluate_space<BLACK>(pos, ei));
Trace::add(TOTAL, score);
}
void Eval::init() {
- const int MaxSlope = 8700;
- const int Peak = 1280000;
+ const int MaxSlope = 322;
+ const int Peak = 47410;
int t = 0;
for (int i = 0; i < 400; ++i)
{
- t = std::min(Peak, std::min(i * i * 27, t + MaxSlope));
- KingDanger[i] = make_score(t / 1000, 0) * Weights[KingSafety];
+ t = std::min(Peak, std::min(i * i - 16, t + MaxSlope));
+ KingDanger[i] = make_score(t * 268 / 7700, 0);
}
}
// Isolated pawn penalty by opposed flag and file
const Score Isolated[2][FILE_NB] = {
- { S(37, 45), S(54, 52), S(60, 52), S(60, 52),
- S(60, 52), S(60, 52), S(54, 52), S(37, 45) },
- { S(25, 30), S(36, 35), S(40, 35), S(40, 35),
- S(40, 35), S(40, 35), S(36, 35), S(25, 30) } };
+ { S(31, 36), S(45, 41), S(50, 41), S(50, 41),
+ S(50, 41), S(50, 41), S(45, 41), S(31, 36) },
+ { S(21, 24), S(30, 28), S(33, 28), S(33, 28),
+ S(33, 28), S(33, 28), S(30, 28), S(21, 24) } };
// Backward pawn penalty by opposed flag
- const Score Backward[2] = { S(67, 42), S(49, 24) };
+ const Score Backward[2] = { S(56, 33), S(41, 19) };
// Unsupported pawn penalty for pawns which are neither isolated or backward,
// by number of pawns it supports [less than 2 / exactly 2].
- const Score Unsupported[2] = { S(20, 10), S(25, 15) };
+ const Score Unsupported[2] = { S(17, 8), S(21, 12) };
// Connected pawn bonus by opposed, phalanx, twice supported and rank
Score Connected[2][2][2][RANK_NB];
// Doubled pawn penalty by file
const Score Doubled[FILE_NB] = {
- S(13, 43), S(20, 48), S(23, 48), S(23, 48),
- S(23, 48), S(23, 48), S(20, 48), S(13, 43) };
+ S(11, 34), S(17, 38), S(19, 38), S(19, 38),
+ S(19, 38), S(19, 38), S(17, 38), S(11, 34) };
// Lever bonus by rank
const Score Lever[RANK_NB] = {
S( 0, 0), S( 0, 0), S(0, 0), S(0, 0),
- S(20, 20), S(40, 40), S(0, 0), S(0, 0) };
+ S(17, 16), S(33, 32), S(0, 0), S(0, 0) };
// Weakness of our pawn shelter in front of the king by [distance from edge][rank]
const Value ShelterWeakness[][RANK_NB] = {
void init()
{
- static const int Seed[RANK_NB] = { 0, 6, 15, 10, 57, 75, 135, 258 };
+ static const int Seed[RANK_NB] = { 0, 8, 19, 13, 71, 94, 169, 324 };
for (int opposed = 0; opposed <= 1; ++opposed)
for (int phalanx = 0; phalanx <= 1; ++phalanx)
{
int v = (Seed[r] + (phalanx ? (Seed[r + 1] - Seed[r]) / 2 : 0)) >> opposed;
v += (apex ? v / 2 : 0);
- Connected[opposed][phalanx][apex][r] = make_score(3 * v / 2, v);
+ Connected[opposed][phalanx][apex][r] = make_score(v, v * 5 / 8);
}
}