Renaming, cleanu up, etc.
No functional change.
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
int kingAdjacentZoneAttacksCount[2];
};
int kingAdjacentZoneAttacksCount[2];
};
- const int Sign[2] = { 1, -1 };
-
// Evaluation grain size, must be a power of 2
const int GrainSize = 8;
// Evaluation grain size, must be a power of 2
const int GrainSize = 8;
// by 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.
// by 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] = {
+ const Bitboard SpaceMask[] = {
(1ULL << SQ_C2) | (1ULL << SQ_D2) | (1ULL << SQ_E2) | (1ULL << SQ_F2) |
(1ULL << SQ_C3) | (1ULL << SQ_D3) | (1ULL << SQ_E3) | (1ULL << SQ_F3) |
(1ULL << SQ_C4) | (1ULL << SQ_D4) | (1ULL << SQ_E4) | (1ULL << SQ_F4),
(1ULL << SQ_C2) | (1ULL << SQ_D2) | (1ULL << SQ_E2) | (1ULL << SQ_F2) |
(1ULL << SQ_C3) | (1ULL << SQ_D3) | (1ULL << SQ_E3) | (1ULL << SQ_F3) |
(1ULL << SQ_C4) | (1ULL << SQ_D4) | (1ULL << SQ_E4) | (1ULL << SQ_F4),
Value do_evaluate(const Position& pos, Value margins[]);
template<Color Us, bool HasPopCnt>
Value do_evaluate(const Position& pos, Value margins[]);
template<Color Us, bool HasPopCnt>
- void init_attack_tables(const Position& pos, EvalInfo& ei);
+ void init_eval_info(const Position& pos, EvalInfo& ei);
template<Color Us, bool HasPopCnt>
Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
template<Color Us, bool HasPopCnt>
Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility);
template<Color Us>
Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
template<Color Us>
Score evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
- inline Score apply_weight(Score v, Score weight);
+ Score apply_weight(Score v, Score weight);
Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]);
Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
void init_safety();
Value scale_by_game_phase(const Score& v, Phase ph, const ScaleFactor sf[]);
Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight);
void init_safety();
PawnTable[threadID]->prefetch(key);
}
PawnTable[threadID]->prefetch(key);
}
/// 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.
/// 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.
EvalInfo ei;
ScaleFactor factor[2];
EvalInfo ei;
ScaleFactor factor[2];
+ Score mobilityWhite, mobilityBlack;
assert(pos.is_ok());
assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
assert(!pos.is_check());
assert(pos.is_ok());
assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
assert(!pos.is_check());
- // Initialize by reading the incrementally updated scores included in the
- // position object (material + piece square tables).
- Score value = pos.value();
+ // Initialize value by reading the incrementally updated scores included
+ // in the position object (material + piece square tables).
+ Score bonus = pos.value();
- // margins[color] stores the uncertainty estimation of position's evaluation
+ // margins[color] is the uncertainty estimation of position's evaluation
// and typically is used by the search for pruning decisions.
margins[WHITE] = margins[BLACK] = VALUE_ZERO;
// Probe the material hash table
MaterialInfo* mi = MaterialTable[pos.thread()]->get_material_info(pos);
// and typically is used by the search for pruning decisions.
margins[WHITE] = margins[BLACK] = VALUE_ZERO;
// Probe the material hash table
MaterialInfo* mi = MaterialTable[pos.thread()]->get_material_info(pos);
- value += mi->material_value();
+ bonus += mi->material_value();
// If we have a specialized evaluation function for the current material
// configuration, call it and return.
// If we have a specialized evaluation function for the current material
// configuration, call it and return.
// Probe the pawn hash table
ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
// Probe the pawn hash table
ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
- value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
+ bonus += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
- // Initialize attack bitboards with pawns evaluation
- init_attack_tables<WHITE, HasPopCnt>(pos, ei);
- init_attack_tables<BLACK, HasPopCnt>(pos, ei);
+ // Initialize attack and king safety bitboards
+ init_eval_info<WHITE, HasPopCnt>(pos, ei);
+ init_eval_info<BLACK, HasPopCnt>(pos, ei);
// Evaluate pieces and mobility
// Evaluate pieces and mobility
- value += evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei, w_mob)
- - evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei, b_mob);
+ bonus += evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei, mobilityWhite)
+ - evaluate_pieces_of_color<BLACK, HasPopCnt>(pos, ei, mobilityBlack);
- value += apply_weight(w_mob - b_mob, Weights[Mobility]);
+ bonus += apply_weight(mobilityWhite - mobilityBlack, Weights[Mobility]);
- // Evaluate kings after all other pieces for both sides, because we
- // need complete attack information for all pieces when computing
- // the king safety evaluation.
- value += evaluate_king<WHITE, HasPopCnt>(pos, ei, margins)
+ // 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);
- evaluate_king<BLACK, HasPopCnt>(pos, ei, margins);
- // Evaluate tactical threats, we need full attack info including king
- value += evaluate_threats<WHITE>(pos, ei)
+ // Evaluate tactical threats, we need full attack information including king
+ bonus += evaluate_threats<WHITE>(pos, ei)
- evaluate_threats<BLACK>(pos, ei);
- evaluate_threats<BLACK>(pos, ei);
- // Evaluate passed pawns, we need full attack info including king
- value += evaluate_passed_pawns<WHITE>(pos, ei)
+ // Evaluate passed pawns, we need full attack information including king
+ bonus += evaluate_passed_pawns<WHITE>(pos, ei)
- evaluate_passed_pawns<BLACK>(pos, ei);
Phase phase = mi->game_phase();
- evaluate_passed_pawns<BLACK>(pos, ei);
Phase phase = mi->game_phase();
if ( square_file(pos.king_square(WHITE)) >= FILE_E
&& square_file(pos.king_square(BLACK)) <= FILE_D)
if ( square_file(pos.king_square(WHITE)) >= FILE_E
&& square_file(pos.king_square(BLACK)) <= FILE_D)
- value += make_score(ei.pi->queenside_storm_value(WHITE) - ei.pi->kingside_storm_value(BLACK), 0);
+ bonus += make_score(ei.pi->queenside_storm_value(WHITE) - ei.pi->kingside_storm_value(BLACK), 0);
else if ( square_file(pos.king_square(WHITE)) <= FILE_D
&& square_file(pos.king_square(BLACK)) >= FILE_E)
else if ( square_file(pos.king_square(WHITE)) <= FILE_D
&& square_file(pos.king_square(BLACK)) >= FILE_E)
- value += make_score(ei.pi->kingside_storm_value(WHITE) - ei.pi->queenside_storm_value(BLACK), 0);
+ bonus += make_score(ei.pi->kingside_storm_value(WHITE) - ei.pi->queenside_storm_value(BLACK), 0);
// Evaluate space for both sides
if (mi->space_weight() > 0)
{
int s = evaluate_space<WHITE, HasPopCnt>(pos, ei) - evaluate_space<BLACK, HasPopCnt>(pos, ei);
// Evaluate space for both sides
if (mi->space_weight() > 0)
{
int s = evaluate_space<WHITE, HasPopCnt>(pos, ei) - evaluate_space<BLACK, HasPopCnt>(pos, ei);
- value += apply_weight(make_score(s * mi->space_weight(), 0), Weights[Space]);
+ bonus += apply_weight(make_score(s * mi->space_weight(), 0), Weights[Space]);
// colored bishop endgames, and use a lower scale for those
if ( phase < PHASE_MIDGAME
&& pos.opposite_colored_bishops()
// 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(value) > VALUE_ZERO)
- || (factor[BLACK] == SCALE_FACTOR_NORMAL && eg_value(value) < VALUE_ZERO)))
+ && ( (factor[WHITE] == SCALE_FACTOR_NORMAL && eg_value(bonus) > VALUE_ZERO)
+ || (factor[BLACK] == SCALE_FACTOR_NORMAL && eg_value(bonus) < VALUE_ZERO)))
}
// Interpolate between the middle game and the endgame score
}
// Interpolate between the middle game and the endgame score
- return Sign[pos.side_to_move()] * scale_by_game_phase(value, phase, factor);
+ Value v = scale_by_game_phase(bonus, phase, factor);
+ return pos.side_to_move() == WHITE ? v : -v;
/// init_eval() initializes various tables used by the evaluation function
void init_eval(int threads) {
/// init_eval() initializes various tables used by the evaluation function
void init_eval(int threads) {
for (int i = 0; i < MAX_THREADS; i++)
{
for (int i = 0; i < MAX_THREADS; i++)
{
- if (i >= threads)
- {
- delete PawnTable[i];
- delete MaterialTable[i];
- PawnTable[i] = NULL;
- MaterialTable[i] = NULL;
- continue;
- }
- if (!PawnTable[i])
- PawnTable[i] = new PawnInfoTable();
- if (!MaterialTable[i])
- MaterialTable[i] = new MaterialInfoTable();
+ if (i >= threads)
+ {
+ delete PawnTable[i];
+ delete MaterialTable[i];
+ PawnTable[i] = NULL;
+ MaterialTable[i] = NULL;
+ continue;
+ }
+ if (!PawnTable[i])
+ PawnTable[i] = new PawnInfoTable();
+
+ if (!MaterialTable[i])
+ MaterialTable[i] = new MaterialInfoTable();
- for (int i = 0; i < MAX_THREADS; i++)
- {
- delete PawnTable[i];
- delete MaterialTable[i];
- PawnTable[i] = NULL;
- MaterialTable[i] = NULL;
- }
- // init_attack_tables() initializes king bitboards for both sides adding
- // pawn attacks. To be done before other evaluations.
+ // init_eval_info() initializes king bitboards for given color adding
+ // pawn attacks. To be done at the beginning of the evaluation.
template<Color Us, bool HasPopCnt>
template<Color Us, bool HasPopCnt>
- void init_attack_tables(const Position& pos, EvalInfo& ei) {
+ void init_eval_info(const Position& pos, EvalInfo& ei) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
const Color Them = (Us == WHITE ? BLACK : WHITE);
ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
b &= ei.attackedBy[Us][PAWN];
ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
b &= ei.attackedBy[Us][PAWN];
- ei.kingAttackersCount[Us] = b ? count_1s_max_15<HasPopCnt>(b) / 2 : 0;
- ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
+ ei.kingAttackersCount[Us] = b ? count_1s_max_15<HasPopCnt>(b) / 2 : EmptyBoardBB;
+ ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = EmptyBoardBB;
Value bonus = OutpostBonus[Piece == BISHOP][relative_square(Us, s)];
// Increase bonus if supported by pawn, especially if the opponent has
Value bonus = OutpostBonus[Piece == BISHOP][relative_square(Us, s)];
// Increase bonus if supported by pawn, especially if the opponent has
- // no minor piece which can exchange the outpost piece
+ // no minor piece which can exchange the outpost piece.
if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
{
if ( pos.pieces(KNIGHT, Them) == EmptyBoardBB
if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
{
if ( pos.pieces(KNIGHT, Them) == EmptyBoardBB
const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square* ptr = pos.piece_list_begin(Us, Piece);
const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square* ptr = pos.piece_list_begin(Us, Piece);
- ei.attackedBy[Us][Piece] = 0;
+ ei.attackedBy[Us][Piece] = EmptyBoardBB;
while ((s = *ptr++) != SQ_NONE)
{
while ((s = *ptr++) != SQ_NONE)
{
if (!weakEnemies)
return SCORE_ZERO;
if (!weakEnemies)
return SCORE_ZERO;
- // Add bonus according to type of attacked enemy pieces and to the
+ // Add bonus according to type of attacked enemy piece and to the
// type of attacking piece, from knights to queens. Kings are not
// type of attacking piece, from knights to queens. Kings are not
- // considered because are already special handled in king evaluation.
+ // considered because are already handled in king evaluation.
for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
{
b = ei.attackedBy[Us][pt1] & weakEnemies;
for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
{
b = ei.attackedBy[Us][pt1] & weakEnemies;
const Color Them = (Us == WHITE ? BLACK : WHITE);
const Color Them = (Us == WHITE ? BLACK : WHITE);
- Score bonus = SCORE_ZERO;
-
- mobility = SCORE_ZERO;
+ 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));
// 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 Color Them = (Us == WHITE ? BLACK : WHITE);
Bitboard undefended, b, b1, b2, safe;
const Color Them = (Us == WHITE ? BLACK : WHITE);
Bitboard undefended, b, b1, b2, safe;
int attackUnits;
const Square ksq = pos.king_square(Us);
int attackUnits;
const Square ksq = pos.king_square(Us);
// King safety. This is quite complicated, and is almost certainly far
// from optimally tuned.
// King safety. This is quite complicated, and is almost certainly far
// from optimally tuned.
- if ( pos.piece_count(Them, QUEEN) >= 1
- && ei.kingAttackersCount[Them] >= 2
+ if ( ei.kingAttackersCount[Them] >= 2
&& pos.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
&& pos.non_pawn_material(Them) >= QueenValueMidgame + RookValueMidgame
+ && pos.piece_count(Them, QUEEN) >= 1
&& ei.kingAdjacentZoneAttacksCount[Them])
{
&& ei.kingAdjacentZoneAttacksCount[Them])
{
- // Is it the attackers turn to move?
- sente = (Them == pos.side_to_move());
-
// Find the attacked squares around the king which has no defenders
// apart from the king itself
undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
// Find the attacked squares around the king which has no defenders
// apart from the king itself
undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
| ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
if (b)
b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
| ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
if (b)
- attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
+ attackUnits += QueenContactCheckBonus
+ * count_1s_max_15<HasPopCnt>(b)
+ * (Them == pos.side_to_move() ? 2 : 1);
}
// Analyse enemy's safe distance checks for sliders and knights
}
// Analyse enemy's safe distance checks for sliders and knights
assert(pos.pawn_is_passed(Us, s));
int r = int(relative_rank(Us, s) - RANK_2);
assert(pos.pawn_is_passed(Us, s));
int r = int(relative_rank(Us, s) - RANK_2);
// Base bonus based on rank
// Base bonus based on rank
- Value mbonus = Value(20 * tr);
- Value ebonus = Value(10 + r * r * 10);
+ Value mbonus = Value(20 * rr);
+ Value ebonus = Value(10 * (rr + r + 1));
{
Square blockSq = s + pawn_push(Us);
// Adjust bonus based on kings proximity
{
Square blockSq = s + pawn_push(Us);
// Adjust bonus based on kings proximity
- ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * tr);
- ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * 1 * tr);
- ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * tr);
+ ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * rr);
+ ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
+ ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * rr);
// If the pawn is free to advance, increase bonus
if (pos.square_is_empty(blockSq))
// If the pawn is free to advance, increase bonus
if (pos.square_is_empty(blockSq))
// If there aren't enemy attacks or pieces along the path to queen give
// huge bonus. Even bigger if we protect the pawn's path.
if (!unsafeSquares)
// If there aren't enemy attacks or pieces along the path to queen give
// huge bonus. Even bigger if we protect the pawn's path.
if (!unsafeSquares)
- ebonus += Value(tr * (squaresToQueen == defendedSquares ? 17 : 15));
+ ebonus += Value(rr * (squaresToQueen == defendedSquares ? 17 : 15));
else
// OK, there are enemy attacks or pieces (but not pawns). Are those
// squares which are attacked by the enemy also attacked by us ?
// If yes, big bonus (but smaller than when there are no enemy attacks),
// if no, somewhat smaller bonus.
else
// OK, there are enemy attacks or pieces (but not pawns). Are those
// squares which are attacked by the enemy also attacked by us ?
// If yes, big bonus (but smaller than when there are no enemy attacks),
// if no, somewhat smaller bonus.
- ebonus += Value(tr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
+ ebonus += Value(rr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
// At last, add a small bonus when there are no *friendly* pieces
// in the pawn's path.
if (!(squaresToQueen & pos.pieces_of_color(Us)))
// At last, add a small bonus when there are no *friendly* pieces
// in the pawn's path.
if (!(squaresToQueen & pos.pieces_of_color(Us)))
// Increase the bonus if the passed pawn is supported by a friendly pawn
// on the same rank and a bit smaller if it's on the previous rank.
// Increase the bonus if the passed pawn is supported by a friendly pawn
// on the same rank and a bit smaller if it's on the previous rank.
// available for minor pieces on the central four files on ranks 2--4. Safe
// squares one, two or three squares behind a friendly pawn are counted
// twice. Finally, the space bonus is scaled by a weight taken from the
// available for minor pieces on the central four files on ranks 2--4. Safe
// squares one, two or three squares behind a friendly pawn are counted
// twice. Finally, the space bonus is scaled by a weight taken from the
- // material hash table.
+ // material hash table. The aim is to improve play on game opening.
template<Color Us, bool HasPopCnt>
int evaluate_space(const Position& pos, EvalInfo& ei) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
// Find the safe squares for our pieces inside the area defined by
template<Color Us, bool HasPopCnt>
int evaluate_space(const Position& pos, EvalInfo& ei) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
// Find the safe squares for our pieces inside the area defined by
- // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
+ // SpaceMask[]. A square is unsafe if it is attacked by an enemy
// pawn, or if it is undefended and attacked by an enemy piece.
Bitboard safe = SpaceMask[Us]
& ~pos.pieces(PAWN, Us)
// pawn, or if it is undefended and attacked by an enemy piece.
Bitboard safe = SpaceMask[Us]
& ~pos.pieces(PAWN, Us)
// apply_weight() applies an evaluation weight to a value trying to prevent overflow
inline Score apply_weight(Score v, Score w) {
// apply_weight() applies an evaluation weight to a value trying to prevent overflow
inline Score apply_weight(Score v, Score w) {
- return make_score((int(mg_value(v)) * mg_value(w)) / 0x100, (int(eg_value(v)) * eg_value(w)) / 0x100);
+ return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
+ (int(eg_value(v)) * eg_value(w)) / 0x100);
return apply_weight(make_score(mg, eg), internalWeight);
}
return apply_weight(make_score(mg, eg), internalWeight);
}
// init_safety() initizes the king safety evaluation, based on UCI
// parameters. It is called from read_weights().
// init_safety() initizes the king safety evaluation, based on UCI
// parameters. It is called from read_weights().