// Polynomial material balance parameters
- // pair pawn knight bishop rook queen
- const int LinearCoefficients[6] = { 1852, -162, -1122, -183, 249, -154 };
+ // pair pawn knight bishop rook queen
+ const int Linear[6] = { 1852, -162, -1122, -183, 249, -154 };
- const int QuadraticCoefficientsSameSide[][PIECE_TYPE_NB] = {
+ const int QuadraticSameSide[][PIECE_TYPE_NB] = {
// OUR PIECES
// pair pawn knight bishop rook queen
{ 0 }, // Bishop pair
{-177, 25, 129, 142, -137, 0 } // Queen
};
- const int QuadraticCoefficientsOppositeSide[][PIECE_TYPE_NB] = {
+ const int QuadraticOppositeSide[][PIECE_TYPE_NB] = {
// THEIR PIECES
// pair pawn knight bishop rook queen
{ 0 }, // Bishop pair
// Helper templates used to detect a given material distribution
template<Color Us> bool is_KXK(const Position& pos) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
- return !pos.count<PAWN>(Them)
- && pos.non_pawn_material(Them) == VALUE_ZERO
+ return !more_than_one(pos.pieces(Them))
&& pos.non_pawn_material(Us) >= RookValueMg;
}
const Color Them = (Us == WHITE ? BLACK : WHITE);
- int pt1, pt2, pc, v;
- int value = 0;
+ int bonus = 0;
// Second-degree polynomial material imbalance by Tord Romstad
- for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1)
+ for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1)
{
- pc = pieceCount[Us][pt1];
- if (!pc)
+ if (!pieceCount[Us][pt1])
continue;
- v = LinearCoefficients[pt1];
+ int v = Linear[pt1];
- for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2)
- v += QuadraticCoefficientsSameSide[pt1][pt2] * pieceCount[Us][pt2]
- + QuadraticCoefficientsOppositeSide[pt1][pt2] * pieceCount[Them][pt2];
+ for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2)
+ v += QuadraticSameSide[pt1][pt2] * pieceCount[Us][pt2]
+ + QuadraticOppositeSide[pt1][pt2] * pieceCount[Them][pt2];
- value += pc * v;
+ bonus += pieceCount[Us][pt1] * v;
}
- return value;
+ return bonus;
}
} // namespace
std::memset(e, 0, sizeof(Entry));
e->key = key;
e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
- e->gamePhase = game_phase(pos);
+ e->gamePhase = pos.game_phase();
// Let's look if we have a specialized evaluation function for this particular
// material configuration. Firstly we look for a fixed configuration one, then
return e;
}
-
-/// Material::game_phase() calculates the phase given the current
-/// position. Because the phase is strictly a function of the material, it
-/// is stored in MaterialEntry.
-
-Phase game_phase(const Position& pos) {
-
- Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
-
- return npm >= MidgameLimit ? PHASE_MIDGAME
- : npm <= EndgameLimit ? PHASE_ENDGAME
- : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
-}
-
} // namespace Material
S( 0, 0), S( 6, 13), S(6,13), S(14,29),
S(34,68), S(83,166), S(0, 0), S( 0, 0) };
- // Levers bonus by rank
+ // Levers 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) };
// Danger of enemy pawns moving toward our king indexed by
// [no friendly pawn | pawn unblocked | pawn blocked][rank of enemy pawn]
- const Value StormDanger[3][RANK_NB] = {
+ const Value StormDanger[][RANK_NB] = {
{ V( 0), V(64), V(128), V(51), V(26) },
{ V(26), V(32), V( 96), V(38), V(20) },
{ V( 0), V( 0), V(160), V(25), V(13) } };
void init() {
- const int bonusesByFile[8] = { 1, 3, 3, 4, 4, 3, 3, 1 };
- int bonus;
+ const int bonusByFile[] = { 1, 3, 3, 4, 4, 3, 3, 1 };
for (Rank r = RANK_1; r < RANK_8; ++r)
for (File f = FILE_A; f <= FILE_H; ++f)
{
- bonus = r * (r-1) * (r-2) + bonusesByFile[f] * (r/2 + 1);
+ int bonus = r * (r - 1) * (r - 2) + bonusByFile[f] * (r / 2 + 1);
Connected[f][r] = make_score(bonus, bonus);
}
}
-/// probe() takes a position object as input, computes a Entry object, and returns
-/// a pointer to it. The result is also stored in a hash table, so we don't have
+/// probe() takes a position as input, computes a Entry object, and returns a
+/// pointer to it. The result is also stored in a hash table, so we don't have
/// to recompute everything when the same pawn structure occurs again.
Entry* probe(const Position& pos, Table& entries) {
Value Entry::shelter_storm(const Position& pos, Square ksq) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
- static const Bitboard MiddleEdges = (FileABB | FileHBB) & (Rank2BB | Rank3BB);
+ const Bitboard Edges = (FileABB | FileHBB) & (Rank2BB | Rank3BB);
- Value safety = MaxSafetyBonus;
Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, rank_of(ksq)) | rank_bb(ksq));
Bitboard ourPawns = b & pos.pieces(Us);
Bitboard theirPawns = b & pos.pieces(Them);
- Rank rkUs, rkThem;
+ Value safety = MaxSafetyBonus;
File kf = std::max(FILE_B, std::min(FILE_G, file_of(ksq)));
for (File f = kf - File(1); f <= kf + File(1); ++f)
{
b = ourPawns & file_bb(f);
- rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1;
+ Rank rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1;
b = theirPawns & file_bb(f);
- rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1;
+ Rank rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1;
- if ( (MiddleEdges & make_square(f, rkThem))
+ if ( (Edges & make_square(f, rkThem))
&& file_of(ksq) == f
&& relative_rank(Us, ksq) == rkThem - 1)
safety += 200;
else
- safety -= ShelterWeakness[rkUs]
- + StormDanger[rkUs == RANK_1 ? 0 : rkThem == rkUs + 1 ? 2 : 1][rkThem];
+ safety -= ShelterWeakness[rkUs]
+ + StormDanger[rkUs == RANK_1 ? 0 :
+ rkThem != rkUs + 1 ? 1 : 2][rkThem];
}
return safety;