kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-02 09:39:36 +00:00
Code Issues Releases Wiki Activity

Improve readability of evaluation functions

Browse source 
This patch puts the evaluation helper functions inside EvalInfo struct, which simplifies a bit their signature and (most importantly, IMHO) makes their C++ code much cleaner and simpler to read (by removing the "ei." qualifiers all around in evaluate.cpp).

Also rename the EvalInfo struct into Evaluation class to get a natural invocation v = Evaluation(p).value() to evaluation position p.

The downside is an increase of 20 lines in evaluate.cpp (for the prototypes of the helper functions). The upsides are better readability and a speed-up of 0.6% (by generating all the helpers for the NO_TRACE case together, which helps the instruction cache).

No functional change

Closes #1135
This commit is contained in:
snicolet 2017-06-21 14:01:59 -07:00 • committed by Joona Kiiski
parent 0149a4c3d6
commit 612d93234b
2 changed files with 211 additions and 192 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

324
src/evaluate.cpp
View file

@ -33,6 +33,8 @@ namespace {
namespace Trace { namespace Trace {
enum Tracing {NO_TRACE, TRACE};
enum Term { // The first 8 entries are for PieceType enum Term { // The first 8 entries are for PieceType
MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB
}; };
@ -69,13 +71,35 @@ namespace {
using namespace Trace; using namespace Trace;
// Struct EvalInfo contains various information computed and collected // Evaluation class contains various information computed and collected
// by the evaluation functions. // by the evaluation functions.
struct EvalInfo { template<Tracing T = NO_TRACE>
class Evaluation {
public:
Evaluation() = delete;
Evaluation(const Position& p) : pos(p) {};
Evaluation& operator=(const Evaluation&) = delete;
Value value();
private:
// Evaluation helpers (used when calling value())
template<Color Us> void initialize();
template<Color Us> Score evaluate_king();
template<Color Us> Score evaluate_threats();
template<Color Us> Score evaluate_passer_pawns();
template<Color Us> Score evaluate_space();
template<Color Us, PieceType Pt> Score evaluate_pieces();
ScaleFactor evaluate_scale_factor(Value eg);
Score evaluate_initiative(Value eg);
// Data members
const Position& pos;
Material::Entry* me; Material::Entry* me;
Pawns::Entry* pe; Pawns::Entry* pe;
Bitboard mobilityArea[COLOR_NB]; Bitboard mobilityArea[COLOR_NB];
Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
// attackedBy[color][piece type] is a bitboard representing all squares // attackedBy[color][piece type] is a bitboard representing all squares
// attacked by a given color and piece type (can be also ALL_PIECES). // attacked by a given color and piece type (can be also ALL_PIECES).
@ -214,11 +238,12 @@ namespace {
const Value LazyThreshold = Value(1500); const Value LazyThreshold = Value(1500);
const Value SpaceThreshold = Value(12222); const Value SpaceThreshold = Value(12222);
// eval_init() initializes king and attack bitboards for a given color
// adding pawn attacks. To be done at the beginning of the evaluation.
template<Color Us> // initialize() computes king and pawn attacks, and the king ring bitboard
void eval_init(const Position& pos, EvalInfo& ei) { // for a given color. This is done at the beginning of the evaluation.
template<Tracing T> template<Color Us>
void Evaluation<T>::initialize() {
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square Up = (Us == WHITE ? NORTH : SOUTH); const Square Up = (Us == WHITE ? NORTH : SOUTH);
@ -230,38 +255,37 @@ namespace {
// Squares occupied by those pawns, by our king, or controlled by enemy pawns // Squares occupied by those pawns, by our king, or controlled by enemy pawns
// are excluded from the mobility area. // are excluded from the mobility area.
ei.mobilityArea[Us] = ~(b | pos.square<KING>(Us) | ei.pe->pawn_attacks(Them)); mobilityArea[Us] = ~(b | pos.square<KING>(Us) | pe->pawn_attacks(Them));
// Initialise the attack bitboards with the king and pawn information // Initialise the attack bitboards with the king and pawn information
b = ei.attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us)); b = attackedBy[Us][KING] = pos.attacks_from<KING>(pos.square<KING>(Us));
ei.attackedBy[Us][PAWN] = ei.pe->pawn_attacks(Us); attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
ei.attackedBy2[Us] = b & ei.attackedBy[Us][PAWN]; attackedBy2[Us] = b & attackedBy[Us][PAWN];
ei.attackedBy[Us][ALL_PIECES] = b | ei.attackedBy[Us][PAWN]; attackedBy[Us][ALL_PIECES] = b | attackedBy[Us][PAWN];
// Init our king safety tables only if we are going to use them // Init our king safety tables only if we are going to use them
if (pos.non_pawn_material(Them) >= RookValueMg + KnightValueMg) if (pos.non_pawn_material(Them) >= RookValueMg + KnightValueMg)
{ {
ei.kingRing[Us] = b; kingRing[Us] = b;
if (relative_rank(Us, pos.square<KING>(Us)) == RANK_1) if (relative_rank(Us, pos.square<KING>(Us)) == RANK_1)
ei.kingRing[Us] |= shift<Up>(b); kingRing[Us] |= shift<Up>(b);
ei.kingAttackersCount[Them] = popcount(b & ei.pe->pawn_attacks(Them)); kingAttackersCount[Them] = popcount(b & pe->pawn_attacks(Them));
ei.kingAdjacentZoneAttacksCount[Them] = ei.kingAttackersWeight[Them] = 0; kingAdjacentZoneAttacksCount[Them] = kingAttackersWeight[Them] = 0;
} }
else else
ei.kingRing[Us] = ei.kingAttackersCount[Them] = 0; kingRing[Us] = kingAttackersCount[Them] = 0;
} }
// evaluate_pieces() assigns bonuses and penalties to the pieces of a given // evaluate_pieces() assigns bonuses and penalties to the pieces of a given
// color and type. // color and type.
template<bool DoTrace, Color Us = WHITE, PieceType Pt = KNIGHT> template<Tracing T> template<Color Us, PieceType Pt>
Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility) { Score Evaluation<T>::evaluate_pieces() {
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);
const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));
const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB const Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
: Rank5BB | Rank4BB | Rank3BB); : Rank5BB | Rank4BB | Rank3BB);
const Square* pl = pos.squares<Pt>(Us); const Square* pl = pos.squares<Pt>(Us);
@ -270,7 +294,7 @@ namespace {
Square s; Square s;
Score score = SCORE_ZERO; Score score = SCORE_ZERO;
ei.attackedBy[Us][Pt] = 0; attackedBy[Us][Pt] = 0;
while ((s = *pl++) != SQ_NONE) while ((s = *pl++) != SQ_NONE)
{ {
@ -282,17 +306,17 @@ namespace {
if (pos.pinned_pieces(Us) & s) if (pos.pinned_pieces(Us) & s)
b &= LineBB[pos.square<KING>(Us)][s]; b &= LineBB[pos.square<KING>(Us)][s];
ei.attackedBy2[Us] |= ei.attackedBy[Us][ALL_PIECES] & b; attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b; attackedBy[Us][ALL_PIECES] |= attackedBy[Us][Pt] |= b;
if (b & ei.kingRing[Them]) if (b & kingRing[Them])
{ {
ei.kingAttackersCount[Us]++; kingAttackersCount[Us]++;
ei.kingAttackersWeight[Us] += KingAttackWeights[Pt]; kingAttackersWeight[Us] += KingAttackWeights[Pt];
ei.kingAdjacentZoneAttacksCount[Us] += popcount(b & ei.attackedBy[Them][KING]); kingAdjacentZoneAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
} }
int mob = popcount(b & ei.mobilityArea[Us]); int mob = popcount(b & mobilityArea[Us]);
mobility[Us] += MobilityBonus[Pt - 2][mob]; mobility[Us] += MobilityBonus[Pt - 2][mob];
@ -302,14 +326,14 @@ namespace {
if (Pt == BISHOP || Pt == KNIGHT) if (Pt == BISHOP || Pt == KNIGHT)
{ {
// Bonus for outpost squares // Bonus for outpost squares
bb = OutpostRanks & ~ei.pe->pawn_attacks_span(Them); bb = OutpostRanks & ~pe->pawn_attacks_span(Them);
if (bb & s) if (bb & s)
score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)] * 2; score += Outpost[Pt == BISHOP][!!(attackedBy[Us][PAWN] & s)] * 2;
else else
{ {
bb &= b & ~pos.pieces(Us); bb &= b & ~pos.pieces(Us);
if (bb) if (bb)
score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & bb)]; score += Outpost[Pt == BISHOP][!!(attackedBy[Us][PAWN] & bb)];
} }
// Bonus when behind a pawn // Bonus when behind a pawn
@ -319,7 +343,7 @@ namespace {
// Penalty for pawns on the same color square as the bishop // Penalty for pawns on the same color square as the bishop
if (Pt == BISHOP) if (Pt == BISHOP)
score -= BishopPawns * ei.pe->pawns_on_same_color_squares(Us, s); score -= BishopPawns * pe->pawns_on_same_color_squares(Us, s);
// An important Chess960 pattern: A cornered bishop blocked by a friendly // An important Chess960 pattern: A cornered bishop blocked by a friendly
// pawn diagonally in front of it is a very serious problem, especially // pawn diagonally in front of it is a very serious problem, especially
@ -343,8 +367,8 @@ namespace {
score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]); score += RookOnPawn * popcount(pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s]);
// Bonus when on an open or semi-open file // Bonus when on an open or semi-open file
if (ei.pe->semiopen_file(Us, file_of(s))) if (pe->semiopen_file(Us, file_of(s)))
score += RookOnFile[!!ei.pe->semiopen_file(Them, file_of(s))]; score += RookOnFile[!!pe->semiopen_file(Them, file_of(s))];
// Penalty when trapped by the king, even more if the king cannot castle // Penalty when trapped by the king, even more if the king cannot castle
else if (mob <= 3) else if (mob <= 3)
@ -352,7 +376,7 @@ namespace {
Square ksq = pos.square<KING>(Us); Square ksq = pos.square<KING>(Us);
if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq))) if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
&& !ei.pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq))) && !pe->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))
score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us)); score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));
} }
} }
@ -366,18 +390,12 @@ namespace {
} }
} }
if (DoTrace) if (T)
Trace::add(Pt, Us, score); Trace::add(Pt, Us, score);
// Recursively call evaluate_pieces() of next piece type until KING is excluded return score;
return score - evaluate_pieces<DoTrace, Them, NextPt>(pos, ei, mobility);
} }
template<>
Score evaluate_pieces<false, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
template<>
Score evaluate_pieces< true, WHITE, KING>(const Position&, EvalInfo&, Score*) { return SCORE_ZERO; }
// evaluate_king() assigns bonuses and penalties to a king of a given color // evaluate_king() assigns bonuses and penalties to a king of a given color
@ -389,8 +407,8 @@ namespace {
QueenSide, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide QueenSide, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide
}; };
template<Color Us, bool DoTrace> template<Tracing T> template<Color Us>
Score evaluate_king(const Position& pos, const EvalInfo& ei) { Score Evaluation<T>::evaluate_king() {
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square Up = (Us == WHITE ? NORTH : SOUTH); const Square Up = (Us == WHITE ? NORTH : SOUTH);
@ -402,27 +420,27 @@ namespace {
int kingDanger; int kingDanger;
// King shelter and enemy pawns storm // King shelter and enemy pawns storm
Score score = ei.pe->king_safety<Us>(pos, ksq); Score score = pe->king_safety<Us>(pos, ksq);
// Main king safety evaluation // Main king safety evaluation
if (ei.kingAttackersCount[Them] > (1 - pos.count<QUEEN>(Them))) if (kingAttackersCount[Them] > (1 - pos.count<QUEEN>(Them)))
{ {
// Find the attacked squares which are defended only by our king... // Find the attacked squares which are defended only by our king...
undefended = ei.attackedBy[Them][ALL_PIECES] undefended = attackedBy[Them][ALL_PIECES]
& ei.attackedBy[Us][KING] & attackedBy[Us][KING]
& ~ei.attackedBy2[Us]; & ~attackedBy2[Us];
// ... and those which are not defended at all in the larger king ring // ... and those which are not defended at all in the larger king ring
b = ei.attackedBy[Them][ALL_PIECES] & ~ei.attackedBy[Us][ALL_PIECES] b = attackedBy[Them][ALL_PIECES] & ~attackedBy[Us][ALL_PIECES]
& ei.kingRing[Us] & ~pos.pieces(Them); & kingRing[Us] & ~pos.pieces(Them);
// Initialize the 'kingDanger' variable, which will be transformed // Initialize the 'kingDanger' variable, which will be transformed
// later into a king danger score. The initial value is based on the // later into a king danger score. The initial value is based on the
// number and types of the enemy's attacking pieces, the number of // number and types of the enemy's attacking pieces, the number of
// attacked and undefended squares around our king and the quality of // attacked and undefended squares around our king and the quality of
// the pawn shelter (current 'score' value). // the pawn shelter (current 'score' value).
kingDanger = ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them] kingDanger = kingAttackersCount[Them] * kingAttackersWeight[Them]
+ 102 * ei.kingAdjacentZoneAttacksCount[Them] + 102 * kingAdjacentZoneAttacksCount[Them]
+ 201 * popcount(undefended) + 201 * popcount(undefended)
+ 143 * (popcount(b) + !!pos.pinned_pieces(Us)) + 143 * (popcount(b) + !!pos.pinned_pieces(Us))
- 848 * !pos.count<QUEEN>(Them) - 848 * !pos.count<QUEEN>(Them)
@ -431,43 +449,43 @@ namespace {
// Analyse the safe enemy's checks which are possible on next move // Analyse the safe enemy's checks which are possible on next move
safe = ~pos.pieces(Them); safe = ~pos.pieces(Them);
safe &= ~ei.attackedBy[Us][ALL_PIECES] | (undefended & ei.attackedBy2[Them]); safe &= ~attackedBy[Us][ALL_PIECES] | (undefended & attackedBy2[Them]);
b1 = pos.attacks_from< ROOK>(ksq); b1 = pos.attacks_from< ROOK>(ksq);
b2 = pos.attacks_from<BISHOP>(ksq); b2 = pos.attacks_from<BISHOP>(ksq);
// Enemy queen safe checks // Enemy queen safe checks
if ((b1 | b2) & ei.attackedBy[Them][QUEEN] & safe) if ((b1 | b2) & attackedBy[Them][QUEEN] & safe)
kingDanger += QueenCheck; kingDanger += QueenCheck;
// For minors and rooks, also consider the square safe if attacked twice, // For minors and rooks, also consider the square safe if attacked twice,
// and only defended by our queen. // and only defended by our queen.
safe |= ei.attackedBy2[Them] safe |= attackedBy2[Them]
& ~(ei.attackedBy2[Us] | pos.pieces(Them)) & ~(attackedBy2[Us] | pos.pieces(Them))
& ei.attackedBy[Us][QUEEN]; & attackedBy[Us][QUEEN];
// Some other potential checks are also analysed, even from squares // Some other potential checks are also analysed, even from squares
// currently occupied by the opponent own pieces, as long as the square // currently occupied by the opponent own pieces, as long as the square
// is not attacked by our pawns, and is not occupied by a blocked pawn. // is not attacked by our pawns, and is not occupied by a blocked pawn.
other = ~( ei.attackedBy[Us][PAWN] other = ~( attackedBy[Us][PAWN]
| (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN)))); | (pos.pieces(Them, PAWN) & shift<Up>(pos.pieces(PAWN))));
// Enemy rooks safe and other checks // Enemy rooks safe and other checks
if (b1 & ei.attackedBy[Them][ROOK] & safe) if (b1 & attackedBy[Them][ROOK] & safe)
kingDanger += RookCheck; kingDanger += RookCheck;
else if (b1 & ei.attackedBy[Them][ROOK] & other) else if (b1 & attackedBy[Them][ROOK] & other)
score -= OtherCheck; score -= OtherCheck;
// Enemy bishops safe and other checks // Enemy bishops safe and other checks
if (b2 & ei.attackedBy[Them][BISHOP] & safe) if (b2 & attackedBy[Them][BISHOP] & safe)
kingDanger += BishopCheck; kingDanger += BishopCheck;
else if (b2 & ei.attackedBy[Them][BISHOP] & other) else if (b2 & attackedBy[Them][BISHOP] & other)
score -= OtherCheck; score -= OtherCheck;
// Enemy knights safe and other checks // Enemy knights safe and other checks
b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT]; b = pos.attacks_from<KNIGHT>(ksq) & attackedBy[Them][KNIGHT];
if (b & safe) if (b & safe)
kingDanger += KnightCheck; kingDanger += KnightCheck;
@ -481,7 +499,7 @@ namespace {
// King tropism: firstly, find squares that opponent attacks in our king flank // King tropism: firstly, find squares that opponent attacks in our king flank
File kf = file_of(ksq); File kf = file_of(ksq);
b = ei.attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp; b = attackedBy[Them][ALL_PIECES] & KingFlank[kf] & Camp;
assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0); assert(((Us == WHITE ? b << 4 : b >> 4) & b) == 0);
assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b)); assert(popcount(Us == WHITE ? b << 4 : b >> 4) == popcount(b));
@ -489,7 +507,7 @@ namespace {
// Secondly, add the squares which are attacked twice in that flank and // Secondly, add the squares which are attacked twice in that flank and
// which are not defended by our pawns. // which are not defended by our pawns.
b = (Us == WHITE ? b << 4 : b >> 4) b = (Us == WHITE ? b << 4 : b >> 4)
| (b & ei.attackedBy2[Them] & ~ei.attackedBy[Us][PAWN]); | (b & attackedBy2[Them] & ~attackedBy[Us][PAWN]);
score -= CloseEnemies * popcount(b); score -= CloseEnemies * popcount(b);
@ -497,7 +515,7 @@ namespace {
if (!(pos.pieces(PAWN) & KingFlank[kf])) if (!(pos.pieces(PAWN) & KingFlank[kf]))
score -= PawnlessFlank; score -= PawnlessFlank;
if (DoTrace) if (T)
Trace::add(KING, Us, score); Trace::add(KING, Us, score);
return score; return score;
@ -507,8 +525,8 @@ namespace {
// evaluate_threats() assigns bonuses according to the types of the attacking // evaluate_threats() assigns bonuses according to the types of the attacking
// and the attacked pieces. // and the attacked pieces.
template<Color Us, bool DoTrace> template<Tracing T> template<Color Us>
Score evaluate_threats(const Position& pos, const EvalInfo& ei) { Score Evaluation<T>::evaluate_threats() {
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square Up = (Us == WHITE ? NORTH : SOUTH); const Square Up = (Us == WHITE ? NORTH : SOUTH);
@ -521,12 +539,12 @@ namespace {
Score score = SCORE_ZERO; Score score = SCORE_ZERO;
// Non-pawn enemies attacked by a pawn // Non-pawn enemies attacked by a pawn
weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN]; weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & attackedBy[Us][PAWN];
if (weak) if (weak)
{ {
b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES] b = pos.pieces(Us, PAWN) & ( ~attackedBy[Them][ALL_PIECES]
| ei.attackedBy[Us][ALL_PIECES]); | attackedBy[Us][ALL_PIECES]);
safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak; safeThreats = (shift<Right>(b) | shift<Left>(b)) & weak;
@ -538,8 +556,8 @@ namespace {
// Squares strongly protected by the opponent, either because they attack the // Squares strongly protected by the opponent, either because they attack the
// square with a pawn, or because they attack the square twice and we don't. // square with a pawn, or because they attack the square twice and we don't.
stronglyProtected = ei.attackedBy[Them][PAWN] stronglyProtected = attackedBy[Them][PAWN]
| (ei.attackedBy2[Them] & ~ei.attackedBy2[Us]); | (attackedBy2[Them] & ~attackedBy2[Us]);
// Non-pawn enemies, strongly protected // Non-pawn enemies, strongly protected
defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN))
@ -548,12 +566,12 @@ namespace {
// Enemies not strongly protected and under our attack // Enemies not strongly protected and under our attack
weak = pos.pieces(Them) weak = pos.pieces(Them)
& ~stronglyProtected & ~stronglyProtected
& ei.attackedBy[Us][ALL_PIECES]; & attackedBy[Us][ALL_PIECES];
// Add a bonus according to the kind of attacking pieces // Add a bonus according to the kind of attacking pieces
if (defended | weak) if (defended | weak)
{ {
b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]); b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
while (b) while (b)
{ {
Square s = pop_lsb(&b); Square s = pop_lsb(&b);
@ -562,7 +580,7 @@ namespace {
score += ThreatByRank * (int)relative_rank(Them, s); score += ThreatByRank * (int)relative_rank(Them, s);
} }
b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK]; b = (pos.pieces(Them, QUEEN) | weak) & attackedBy[Us][ROOK];
while (b) while (b)
{ {
Square s = pop_lsb(&b); Square s = pop_lsb(&b);
@ -571,9 +589,9 @@ namespace {
score += ThreatByRank * (int)relative_rank(Them, s); score += ThreatByRank * (int)relative_rank(Them, s);
} }
score += Hanging * popcount(weak & ~ei.attackedBy[Them][ALL_PIECES]); score += Hanging * popcount(weak & ~attackedBy[Them][ALL_PIECES]);
b = weak & ei.attackedBy[Us][KING]; b = weak & attackedBy[Us][KING];
if (b) if (b)
score += ThreatByKing[more_than_one(b)]; score += ThreatByKing[more_than_one(b)];
} }
@ -583,16 +601,16 @@ namespace {
b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces())); b = shift<Up>(b | (shift<Up>(b & TRank2BB) & ~pos.pieces()));
b &= ~pos.pieces() b &= ~pos.pieces()
& ~ei.attackedBy[Them][PAWN] & ~attackedBy[Them][PAWN]
& (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]); & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
b = (shift<Left>(b) | shift<Right>(b)) b = (shift<Left>(b) | shift<Right>(b))
& pos.pieces(Them) & pos.pieces(Them)
& ~ei.attackedBy[Us][PAWN]; & ~attackedBy[Us][PAWN];
score += ThreatByPawnPush * popcount(b); score += ThreatByPawnPush * popcount(b);
if (DoTrace) if (T)
Trace::add(THREAT, Us, score); Trace::add(THREAT, Us, score);
return score; return score;
@ -602,15 +620,15 @@ namespace {
// evaluate_passer_pawns() evaluates the passed pawns and candidate passed // evaluate_passer_pawns() evaluates the passed pawns and candidate passed
// pawns of the given color. // pawns of the given color.
template<Color Us, bool DoTrace> template<Tracing T> template<Color Us>
Score evaluate_passer_pawns(const Position& pos, const EvalInfo& ei) { Score Evaluation<T>::evaluate_passer_pawns() {
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);
Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares; Bitboard b, bb, squaresToQueen, defendedSquares, unsafeSquares;
Score score = SCORE_ZERO; Score score = SCORE_ZERO;
b = ei.pe->passed_pawns(Us); b = pe->passed_pawns(Us);
while (b) while (b)
{ {
@ -618,7 +636,7 @@ namespace {
assert(!(pos.pieces(Them, PAWN) & forward_bb(Us, s + pawn_push(Us)))); assert(!(pos.pieces(Them, PAWN) & forward_bb(Us, s + pawn_push(Us))));
bb = forward_bb(Us, s) & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them)); bb = forward_bb(Us, s) & (attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
score -= HinderPassedPawn * popcount(bb); score -= HinderPassedPawn * popcount(bb);
int r = relative_rank(Us, s) - RANK_2; int r = relative_rank(Us, s) - RANK_2;
@ -649,10 +667,10 @@ namespace {
bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s); bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);
if (!(pos.pieces(Us) & bb)) if (!(pos.pieces(Us) & bb))
defendedSquares &= ei.attackedBy[Us][ALL_PIECES]; defendedSquares &= attackedBy[Us][ALL_PIECES];
if (!(pos.pieces(Them) & bb)) if (!(pos.pieces(Them) & bb))
unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them); unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
// If there aren't any enemy attacks, assign a big bonus. Otherwise // If there aren't any enemy attacks, assign a big bonus. Otherwise
// assign a smaller bonus if the block square isn't attacked. // assign a smaller bonus if the block square isn't attacked.
@ -680,7 +698,7 @@ namespace {
score += make_score(mbonus, ebonus) + PassedFile[file_of(s)]; score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];
} }
if (DoTrace) if (T)
Trace::add(PASSED, Us, score); Trace::add(PASSED, Us, score);
return score; return score;
@ -693,8 +711,9 @@ namespace {
// squares one, two or three squares behind a friendly pawn are counted // squares one, two or three squares behind a friendly pawn are counted
// twice. Finally, the space bonus is multiplied by a weight. The aim is to // twice. Finally, the space bonus is multiplied by a weight. The aim is to
// improve play on game opening. // improve play on game opening.
template<Color Us>
Score evaluate_space(const Position& pos, const EvalInfo& ei) { template<Tracing T> template<Color Us>
Score Evaluation<T>::evaluate_space() {
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);
const Bitboard SpaceMask = const Bitboard SpaceMask =
@ -706,8 +725,8 @@ namespace {
// pawn, or if it is undefended and attacked by an enemy piece. // pawn, or if it is undefended and attacked by an enemy piece.
Bitboard safe = SpaceMask Bitboard safe = SpaceMask
& ~pos.pieces(Us, PAWN) & ~pos.pieces(Us, PAWN)
& ~ei.attackedBy[Them][PAWN] & ~attackedBy[Them][PAWN]
& (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]); & (attackedBy[Us][ALL_PIECES] | ~attackedBy[Them][ALL_PIECES]);
// Find all squares which are at most three squares behind some friendly pawn // Find all squares which are at most three squares behind some friendly pawn
Bitboard behind = pos.pieces(Us, PAWN); Bitboard behind = pos.pieces(Us, PAWN);
@ -719,7 +738,7 @@ namespace {
// ...count safe + (behind & safe) with a single popcount. // ...count safe + (behind & safe) with a single popcount.
int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe)); int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
int weight = pos.count<ALL_PIECES>(Us) - 2 * ei.pe->open_files(); int weight = pos.count<ALL_PIECES>(Us) - 2 * pe->open_files();
return make_score(bonus * weight * weight / 16, 0); return make_score(bonus * weight * weight / 16, 0);
} }
@ -728,29 +747,33 @@ namespace {
// evaluate_initiative() computes the initiative correction value for the // evaluate_initiative() computes the initiative correction value for the
// position, i.e., second order bonus/malus based on the known attacking/defending // position, i.e., second order bonus/malus based on the known attacking/defending
// status of the players. // status of the players.
Score evaluate_initiative(const Position& pos, int asymmetry, Value eg) {
template<Tracing T>
Score Evaluation<T>::evaluate_initiative(Value eg) {
int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK)) int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
- distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK)); - distance<Rank>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));
bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide); bool bothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide);
// Compute the initiative bonus for the attacking side // Compute the initiative bonus for the attacking side
int initiative = 8 * (asymmetry + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks; int initiative = 8 * (pe->pawn_asymmetry() + kingDistance - 17) + 12 * pos.count<PAWN>() + 16 * bothFlanks;
// Now apply the bonus: note that we find the attacking side by extracting // Now apply the bonus: note that we find the attacking side by extracting
// the sign of the endgame value, and that we carefully cap the bonus so // the sign of the endgame value, and that we carefully cap the bonus so
// that the endgame score will never change sign after the bonus. // that the endgame score will never change sign after the bonus.
int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg)); int v = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg));
return make_score(0, value); return make_score(0, v);
} }
// evaluate_scale_factor() computes the scale factor for the winning side // evaluate_scale_factor() computes the scale factor for the winning side
ScaleFactor evaluate_scale_factor(const Position& pos, const EvalInfo& ei, Value eg) {
template<Tracing T>
ScaleFactor Evaluation<T>::evaluate_scale_factor(Value eg) {
Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK; Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
ScaleFactor sf = ei.me->scale_factor(pos, strongSide); ScaleFactor sf = me->scale_factor(pos, strongSide);
// If we don't already have an unusual scale factor, check for certain // If we don't already have an unusual scale factor, check for certain
// types of endgames, and use a lower scale for those. // types of endgames, and use a lower scale for those.
@ -779,102 +802,99 @@ namespace {
return sf; return sf;
} }
} // namespace
// value() is the main function of the class. It computes the various parts of
// the evaluation and returns the value of the position from the point of view
// of the side to move.
/// evaluate() is the main evaluation function. It returns a static evaluation template<Tracing T>
/// of the position from the point of view of the side to move. Value Evaluation<T>::value() {
template<bool DoTrace>
Value Eval::evaluate(const Position& pos) {
assert(!pos.checkers()); assert(!pos.checkers());
Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
Value v;
EvalInfo ei;
// Probe the material hash table // Probe the material hash table
ei.me = Material::probe(pos); me = Material::probe(pos);
// If we have a specialized evaluation function for the current material // If we have a specialized evaluation function for the current material
// configuration, call it and return. // configuration, call it and return.
if (ei.me->specialized_eval_exists()) if (me->specialized_eval_exists())
return ei.me->evaluate(pos); return me->evaluate(pos);
// Initialize score by reading the incrementally updated scores included in // Initialize score by reading the incrementally updated scores included in
// the position object (material + piece square tables) and the material // the position object (material + piece square tables) and the material
// imbalance. Score is computed internally from the white point of view. // imbalance. Score is computed internally from the white point of view.
Score score = pos.psq_score() + ei.me->imbalance(); Score score = pos.psq_score() + me->imbalance();
// Probe the pawn hash table // Probe the pawn hash table
ei.pe = Pawns::probe(pos); pe = Pawns::probe(pos);
score += ei.pe->pawns_score(); score += pe->pawns_score();
// Early exit if score is high // Early exit if score is high
v = (mg_value(score) + eg_value(score)) / 2; Value v = (mg_value(score) + eg_value(score)) / 2;
if (abs(v) > LazyThreshold) if (abs(v) > LazyThreshold)
return pos.side_to_move() == WHITE ? v : -v; return pos.side_to_move() == WHITE ? v : -v;
// Initialize attack and king safety bitboards // Main evaluation begins here
eval_init<WHITE>(pos, ei);
eval_init<BLACK>(pos, ei); initialize<WHITE>();
initialize<BLACK>();
score += evaluate_pieces<WHITE, KNIGHT>() - evaluate_pieces<BLACK, KNIGHT>();
score += evaluate_pieces<WHITE, BISHOP>() - evaluate_pieces<BLACK, BISHOP>();
score += evaluate_pieces<WHITE, ROOK >() - evaluate_pieces<BLACK, ROOK >();
score += evaluate_pieces<WHITE, QUEEN >() - evaluate_pieces<BLACK, QUEEN >();
// Evaluate all pieces but king and pawns
score += evaluate_pieces<DoTrace>(pos, ei, mobility);
score += mobility[WHITE] - mobility[BLACK]; score += mobility[WHITE] - mobility[BLACK];
// Evaluate kings after all other pieces because we need full attack score += evaluate_king<WHITE>()
// information when computing the king safety evaluation. - evaluate_king<BLACK>();
score += evaluate_king<WHITE, DoTrace>(pos, ei)
- evaluate_king<BLACK, DoTrace>(pos, ei);
// Evaluate tactical threats, we need full attack information including king score += evaluate_threats<WHITE>()
score += evaluate_threats<WHITE, DoTrace>(pos, ei) - evaluate_threats<BLACK>();
- evaluate_threats<BLACK, DoTrace>(pos, ei);
// Evaluate passed pawns, we need full attack information including king score += evaluate_passer_pawns<WHITE>()
score += evaluate_passer_pawns<WHITE, DoTrace>(pos, ei) - evaluate_passer_pawns<BLACK>();
- evaluate_passer_pawns<BLACK, DoTrace>(pos, ei);
// Evaluate space for both sides, only during opening
if (pos.non_pawn_material() >= SpaceThreshold) if (pos.non_pawn_material() >= SpaceThreshold)
score += evaluate_space<WHITE>(pos, ei) score += evaluate_space<WHITE>()
- evaluate_space<BLACK>(pos, ei); - evaluate_space<BLACK>();
// Evaluate position potential for the winning side score += evaluate_initiative(eg_value(score));
score += evaluate_initiative(pos, ei.pe->pawn_asymmetry(), eg_value(score));
// Evaluate scale factor for the winning side
ScaleFactor sf = evaluate_scale_factor(pos, ei, eg_value(score));
// Interpolate between a middlegame and a (scaled by 'sf') endgame score // Interpolate between a middlegame and a (scaled by 'sf') endgame score
v = mg_value(score) * int(ei.me->game_phase()) ScaleFactor sf = evaluate_scale_factor(eg_value(score));
+ eg_value(score) * int(PHASE_MIDGAME - ei.me->game_phase()) * sf / SCALE_FACTOR_NORMAL; v = mg_value(score) * int(me->game_phase())
+ eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;
v /= int(PHASE_MIDGAME); v /= int(PHASE_MIDGAME);
// In case of tracing add all remaining individual evaluation terms // In case of tracing add all remaining individual evaluation terms
if (DoTrace) if (T)
{ {
Trace::add(MATERIAL, pos.psq_score()); Trace::add(MATERIAL, pos.psq_score());
Trace::add(IMBALANCE, ei.me->imbalance()); Trace::add(IMBALANCE, me->imbalance());
Trace::add(PAWN, ei.pe->pawns_score()); Trace::add(PAWN, pe->pawns_score());
Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]); Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
if (pos.non_pawn_material() >= SpaceThreshold) if (pos.non_pawn_material() >= SpaceThreshold)
Trace::add(SPACE, evaluate_space<WHITE>(pos, ei) Trace::add(SPACE, evaluate_space<WHITE>()
, evaluate_space<BLACK>(pos, ei)); , evaluate_space<BLACK>());
Trace::add(TOTAL, score); Trace::add(TOTAL, score);
} }
return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view
} }
// Explicit template instantiations } // namespace
template Value Eval::evaluate<true >(const Position&);
template Value Eval::evaluate<false>(const Position&);
/// evaluate() is the evaluator for the outer world. It returns a static evaluation
/// of the position from the point of view of the side to move.
Value Eval::evaluate(const Position& pos)
{
return Evaluation<>(pos).value();
}
/// trace() is like evaluate(), but instead of returning a value, it returns /// trace() is like evaluate(), but instead of returning a value, it returns
/// a string (suitable for outputting to stdout) that contains the detailed /// a string (suitable for outputting to stdout) that contains the detailed
/// descriptions and values of each evaluation term. Useful for debugging. /// descriptions and values of each evaluation term. Useful for debugging.
@ -883,7 +903,7 @@ std::string Eval::trace(const Position& pos) {
std::memset(scores, 0, sizeof(scores)); std::memset(scores, 0, sizeof(scores));
Value v = evaluate<true>(pos); Value v = Evaluation<TRACE>(pos).value();
v = pos.side_to_move() == WHITE ? v : -v; // White's point of view v = pos.side_to_move() == WHITE ? v : -v; // White's point of view
std::stringstream ss; std::stringstream ss;

1
src/evaluate.h
View file

@ -33,7 +33,6 @@ const Value Tempo = Value(20); // Must be visible to search
std::string trace(const Position& pos); std::string trace(const Position& pos);
template<bool DoTrace = false>
Value evaluate(const Position& pos); Value evaluate(const Position& pos);
} }