Key Position::zobMaterial[2][8][16];
Key Position::zobSideToMove;
-Value Position::MgPieceSquareTable[16][64];
-Value Position::EgPieceSquareTable[16][64];
+Score Position::PieceSquareTable[16][64];
static bool RequestPending = false;
st->key = compute_key();
st->pawnKey = compute_pawn_key();
st->materialKey = compute_material_key();
- st->value = Score(compute_value<MidGame>(), compute_value<EndGame>());
+ st->value = compute_value();
st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
}
}
// Update incremental scores
- st->value += Score(pst_delta<MidGame>(piece, from, to), pst_delta<EndGame>(piece, from, to));
+ st->value += pst_delta(piece, from, to);
if (pm) // promotion ?
{
st->pawnKey ^= zobrist[us][PAWN][to];
// Partially revert and update incremental scores
- st->value -= Score(pst<MidGame>(us, PAWN, to), pst<EndGame>(us, PAWN, to));
- st->value += Score(pst<MidGame>(us, promotion, to), pst<EndGame>(us, promotion, to));
+ st->value -= pst(us, PAWN, to);
+ st->value += pst(us, promotion, to);
// Update material
st->npMaterial[us] += piece_value_midgame(promotion);
key ^= zobrist[them][capture][capsq];
// Update incremental scores
- st->value -= Score(pst<MidGame>(them, capture, capsq), pst<EndGame>(them, capture, capsq));
+ st->value -= pst(them, capture, capsq);
// If the captured piece was a pawn, update pawn hash key,
// otherwise update non-pawn material.
index[rto] = tmp;
// Update incremental scores
- st->value += Score(pst_delta<MidGame>(king, kfrom, kto), pst_delta<EndGame>(king, kfrom, kto));
- st->value += Score(pst_delta<MidGame>(rook, rfrom, rto), pst_delta<EndGame>(rook, rfrom, rto));
+ st->value += pst_delta(king, kfrom, kto);
+ st->value += pst_delta(rook, rfrom, rto);
// Update hash key
st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
/// game and the endgame. These functions are used to initialize the incremental
/// scores when a new position is set up, and to verify that the scores are correctly
/// updated by do_move and undo_move when the program is running in debug mode.
-template<Position::GamePhase Phase>
-Value Position::compute_value() const {
+Score Position::compute_value() const {
- Value result = Value(0);
+ Score result(0, 0);
Bitboard b;
Square s;
{
s = pop_1st_bit(&b);
assert(piece_on(s) == piece_of_color_and_type(c, pt));
- result += pst<Phase>(c, pt, s);
+ result += pst(c, pt, s);
}
}
- const Value tv = (Phase == MidGame ? TempoValue.mg() : TempoValue.eg());
- result += (side_to_move() == WHITE)? tv / 2 : -tv / 2;
+ result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2;
return result;
}
for (Piece p = WP; p <= WK; p++)
{
i = (r == 0)? 0 : (genrand_int32() % (r*2) - r);
- MgPieceSquareTable[p][s] = Value(MgPST[p][s] + i);
- EgPieceSquareTable[p][s] = Value(EgPST[p][s] + i);
+ PieceSquareTable[p][s] = Score(MgPST[p][s] + i, EgPST[p][s] + i);
}
for (Square s = SQ_A1; s <= SQ_H8; s++)
for (Piece p = BP; p <= BK; p++)
- {
- MgPieceSquareTable[p][s] = -MgPieceSquareTable[p-8][flip_square(s)];
- EgPieceSquareTable[p][s] = -EgPieceSquareTable[p-8][flip_square(s)];
- }
+ PieceSquareTable[p][s] = -PieceSquareTable[p-8][flip_square(s)];
}
st->materialKey = compute_material_key();
// Incremental scores
- st->value = Score(compute_value<MidGame>(), compute_value<EndGame>());
+ st->value = compute_value();
// Material
st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
// Incremental eval OK?
if (failedStep) (*failedStep)++;
- if (debugIncrementalEval)
- {
- if (st->value.mg() != compute_value<MidGame>())
- return false;
-
- if (st->value.eg() != compute_value<EndGame>())
- return false;
- }
+ if (debugIncrementalEval && st->value != compute_value())
+ return false;
// Non-pawn material OK?
if (failedStep) (*failedStep)++;
Score value() const;
Value non_pawn_material(Color c) const;
Phase game_phase() const;
- template<GamePhase> Value pst_delta(Piece piece, Square from, Square to) const;
+ Score pst_delta(Piece piece, Square from, Square to) const;
// Game termination checks
bool is_mate() const;
Key compute_material_key() const;
// Computing incremental evaluation scores and material counts
- template<GamePhase> Value pst(Color c, PieceType pt, Square s) const;
- template<GamePhase> Value compute_value() const;
+ Score pst(Color c, PieceType pt, Square s) const;
+ Score compute_value() const;
Value compute_non_pawn_material(Color c) const;
// Board
static Key zobCastle[16];
static Key zobMaterial[2][8][16];
static Key zobSideToMove;
- static Value MgPieceSquareTable[16][64];
- static Value EgPieceSquareTable[16][64];
+ static Score PieceSquareTable[16][64];
};
return st->materialKey;
}
-template<Position::GamePhase Ph>
-inline Value Position::pst(Color c, PieceType pt, Square s) const {
- return (Ph == MidGame ? MgPieceSquareTable[piece_of_color_and_type(c, pt)][s]
- : EgPieceSquareTable[piece_of_color_and_type(c, pt)][s]);
+inline Score Position::pst(Color c, PieceType pt, Square s) const {
+ return PieceSquareTable[piece_of_color_and_type(c, pt)][s];
}
-template<Position::GamePhase Ph>
-inline Value Position::pst_delta(Piece piece, Square from, Square to) const {
- return (Ph == MidGame ? MgPieceSquareTable[piece][to] - MgPieceSquareTable[piece][from]
- : EgPieceSquareTable[piece][to] - EgPieceSquareTable[piece][from]);
+inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
+ return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
}
inline Score Position::value() const {
Score& operator+=(const Score& s) { v.v32.mgv += s.v.v32.mgv; v.v32.egv += s.v.v32.egv; return *this; }
Score& operator-=(const Score& s) { v.v32.mgv -= s.v.v32.mgv; v.v32.egv -= s.v.v32.egv; return *this; }
+ bool operator==(const Score& s) { return v.v64 == s.v.v64; }
+ bool operator!=(const Score& s) { return v.v64 != s.v.v64; }
+
Value mg() const { return Value(v.v32.mgv); }
Value eg() const { return Value(v.v32.egv); }
ScoreValue v;
};
+inline Score operator-(Score s1, Score s2) { return Score(s1.mg() - s2.mg(), s1.eg() - s2.eg()); }
inline Score operator*(int i, Score s) { return Score(i * s.mg(), i * s.eg()); }
inline Score operator*(Score s, int i) { return s * i; }
+inline Score operator/(Score s, int i) { return Score(s.mg() / i, s.eg() / i); }
inline Score operator-(Score s) { return Score(-s.mg(), -s.eg()); }
extern std::ostream& operator<<(std::ostream& os, Score s);