Value KXKEvaluationFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(weakerSide) == Value(0));
- assert(pos.pawn_count(weakerSide) == Value(0));
+ assert(pos.piece_count(weakerSide, PAWN) == Value(0));
Square winnerKSq = pos.king_square(strongerSide);
Square loserKSq = pos.king_square(weakerSide);
Value result =
pos.non_pawn_material(strongerSide) +
- pos.pawn_count(strongerSide) * PawnValueEndgame +
+ pos.piece_count(strongerSide, PAWN) * PawnValueEndgame +
mate_table(loserKSq) +
distance_bonus(square_distance(winnerKSq, loserKSq));
- if(pos.queen_count(strongerSide) > 0 || pos.rook_count(strongerSide) > 0 ||
- pos.bishop_count(strongerSide) > 1)
+ if(pos.piece_count(strongerSide, QUEEN) > 0 || pos.piece_count(strongerSide, ROOK) > 0 ||
+ pos.piece_count(strongerSide, BISHOP) > 1)
// TODO: check for two equal-colored bishops!
result += VALUE_KNOWN_WIN;
Value KBNKEvaluationFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(weakerSide) == Value(0));
- assert(pos.pawn_count(weakerSide) == Value(0));
+ assert(pos.piece_count(weakerSide, PAWN) == Value(0));
assert(pos.non_pawn_material(strongerSide) ==
KnightValueMidgame + BishopValueMidgame);
- assert(pos.bishop_count(strongerSide) == 1);
- assert(pos.knight_count(strongerSide) == 1);
- assert(pos.pawn_count(strongerSide) == 0);
+ assert(pos.piece_count(strongerSide, BISHOP) == 1);
+ assert(pos.piece_count(strongerSide, KNIGHT) == 1);
+ assert(pos.piece_count(strongerSide, PAWN) == 0);
Square winnerKSq = pos.king_square(strongerSide);
Square loserKSq = pos.king_square(weakerSide);
assert(pos.non_pawn_material(strongerSide) == Value(0));
assert(pos.non_pawn_material(weakerSide) == Value(0));
- assert(pos.pawn_count(strongerSide) == 1);
- assert(pos.pawn_count(weakerSide) == 0);
+ assert(pos.piece_count(strongerSide, PAWN) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
Square wksq, bksq, wpsq;
Color stm;
Value KRKPEvaluationFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
- assert(pos.pawn_count(strongerSide) == 0);
+ assert(pos.piece_count(strongerSide, PAWN) == 0);
assert(pos.non_pawn_material(weakerSide) == 0);
- assert(pos.pawn_count(weakerSide) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) == 1);
Square wksq, wrsq, bksq, bpsq;
int tempo = (pos.side_to_move() == strongerSide);
Value KRKBEvaluationFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
- assert(pos.pawn_count(strongerSide) == 0);
+ assert(pos.piece_count(strongerSide, PAWN) == 0);
assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame);
- assert(pos.pawn_count(weakerSide) == 0);
- assert(pos.bishop_count(weakerSide) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
+ assert(pos.piece_count(weakerSide, BISHOP) == 1);
Value result = mate_table(pos.king_square(weakerSide));
return (pos.side_to_move() == strongerSide)? result : -result;
Value KRKNEvaluationFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
- assert(pos.pawn_count(strongerSide) == 0);
+ assert(pos.piece_count(strongerSide, PAWN) == 0);
assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame);
- assert(pos.pawn_count(weakerSide) == 0);
- assert(pos.knight_count(weakerSide) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
+ assert(pos.piece_count(weakerSide, KNIGHT) == 1);
Square defendingKSq = pos.king_square(weakerSide);
Square nSq = pos.piece_list(weakerSide, KNIGHT, 0);
Value KQKREvaluationFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
- assert(pos.pawn_count(strongerSide) == 0);
+ assert(pos.piece_count(strongerSide, PAWN) == 0);
assert(pos.non_pawn_material(weakerSide) == RookValueMidgame);
- assert(pos.pawn_count(weakerSide) == 0);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
Square winnerKSq = pos.king_square(strongerSide);
Square loserKSq = pos.king_square(weakerSide);
ScaleFactor KBPKScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
- assert(pos.bishop_count(strongerSide) == 1);
- assert(pos.pawn_count(strongerSide) >= 1);
+ assert(pos.piece_count(strongerSide, BISHOP) == 1);
+ assert(pos.piece_count(strongerSide, PAWN) >= 1);
// No assertions about the material of weakerSide, because we want draws to
// be detected even when the weaker side has some pawns.
ScaleFactor KQKRPScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
- assert(pos.queen_count(strongerSide) == 1);
- assert(pos.pawn_count(strongerSide) == 0);
- assert(pos.rook_count(weakerSide) == 1);
- assert(pos.pawn_count(weakerSide) >= 1);
+ assert(pos.piece_count(strongerSide, QUEEN) == 1);
+ assert(pos.piece_count(strongerSide, PAWN) == 0);
+ assert(pos.piece_count(weakerSide, ROOK) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) >= 1);
Square kingSq = pos.king_square(weakerSide);
if(relative_rank(weakerSide, kingSq) <= RANK_2 &&
ScaleFactor KRPKRScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
- assert(pos.pawn_count(strongerSide) == 1);
+ assert(pos.piece_count(strongerSide, PAWN) == 1);
assert(pos.non_pawn_material(weakerSide) == RookValueMidgame);
- assert(pos.pawn_count(weakerSide) == 0);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
Square wksq = pos.king_square(strongerSide);
Square wrsq = pos.piece_list(strongerSide, ROOK, 0);
ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
- assert(pos.pawn_count(strongerSide) == 2);
+ assert(pos.piece_count(strongerSide, PAWN) == 2);
assert(pos.non_pawn_material(weakerSide) == RookValueMidgame);
- assert(pos.pawn_count(weakerSide) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) == 1);
Square wpsq1 = pos.piece_list(strongerSide, PAWN, 0);
Square wpsq2 = pos.piece_list(strongerSide, PAWN, 1);
ScaleFactor KPsKScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == Value(0));
- assert(pos.pawn_count(strongerSide) >= 2);
+ assert(pos.piece_count(strongerSide, PAWN) >= 2);
assert(pos.non_pawn_material(weakerSide) == Value(0));
- assert(pos.pawn_count(weakerSide) == 0);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
Bitboard pawns = pos.pawns(strongerSide);
ScaleFactor KBPKBScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
- assert(pos.bishop_count(strongerSide) == 1);
- assert(pos.pawn_count(strongerSide) == 1);
+ assert(pos.piece_count(strongerSide, BISHOP) == 1);
+ assert(pos.piece_count(strongerSide, PAWN) == 1);
assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame);
- assert(pos.bishop_count(weakerSide) == 1);
- assert(pos.pawn_count(weakerSide) == 0);
+ assert(pos.piece_count(weakerSide, BISHOP) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0);
ScaleFactor KBPKNScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
- assert(pos.bishop_count(strongerSide) == 1);
- assert(pos.pawn_count(strongerSide) == 1);
+ assert(pos.piece_count(strongerSide, BISHOP) == 1);
+ assert(pos.piece_count(strongerSide, PAWN) == 1);
assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame);
- assert(pos.knight_count(weakerSide) == 1);
- assert(pos.pawn_count(weakerSide) == 0);
+ assert(pos.piece_count(weakerSide, KNIGHT) == 1);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0);
ScaleFactor KNPKScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame);
- assert(pos.knight_count(strongerSide) == 1);
- assert(pos.pawn_count(strongerSide) == 1);
+ assert(pos.piece_count(strongerSide, KNIGHT) == 1);
+ assert(pos.piece_count(strongerSide, PAWN) == 1);
assert(pos.non_pawn_material(weakerSide) == Value(0));
- assert(pos.pawn_count(weakerSide) == 0);
+ assert(pos.piece_count(weakerSide, PAWN) == 0);
Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
Square weakerKingSq = pos.king_square(weakerSide);
ScaleFactor KPKPScalingFunction::apply(const Position &pos) {
assert(pos.non_pawn_material(strongerSide) == Value(0));
assert(pos.non_pawn_material(weakerSide) == Value(0));
- assert(pos.pawn_count(WHITE) == 1);
- assert(pos.pawn_count(BLACK) == 1);
+ assert(pos.piece_count(WHITE, PAWN) == 1);
+ assert(pos.piece_count(BLACK, PAWN) == 1);
Square wksq, bksq, wpsq;
Color stm;
for (Color c = WHITE; c <= BLACK; c++)
{
// Knights
- for (int i = 0; i < pos.knight_count(c); i++)
+ for (int i = 0; i < pos.piece_count(c, KNIGHT); i++)
evaluate_knight(pos, pos.piece_list(c, KNIGHT, i), c, ei);
// Bishops
- for (int i = 0; i < pos.bishop_count(c); i++)
+ for (int i = 0; i < pos.piece_count(c, BISHOP); i++)
evaluate_bishop(pos, pos.piece_list(c, BISHOP, i), c, ei);
// Rooks
- for (int i = 0; i < pos.rook_count(c); i++)
+ for (int i = 0; i < pos.piece_count(c, ROOK); i++)
evaluate_rook(pos, pos.piece_list(c, ROOK, i), c, ei);
// Queens
- for(int i = 0; i < pos.queen_count(c); i++)
+ for(int i = 0; i < pos.piece_count(c, QUEEN); i++)
evaluate_queen(pos, pos.piece_list(c, QUEEN, i), c, ei);
// Special pattern: trapped bishops on a7/h7/a2/h2
{
// Check for KBP vs KB with only a single pawn that is almost
// certainly a draw or at least two pawns.
- bool one_pawn = (pos.pawn_count(WHITE) + pos.pawn_count(BLACK) == 1);
+ bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
}
else
if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
{
bonus += v / 2;
- if ( p.knight_count(them) == 0
+ if ( p.piece_count(them, KNIGHT) == 0
&& (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
bonus += v;
}
// from optimally tuned.
Color them = opposite_color(us);
- if ( p.queen_count(them) >= 1
+ if ( p.piece_count(them, QUEEN) >= 1
&& ei.kingAttackersCount[them] >= 2
&& p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
&& ei.kingAdjacentZoneAttacksCount[them])
{
// We have a mate, unless the queen is pinned or there
// is an X-ray attack through the queen.
- for (int i = 0; i < p.queen_count(them); i++)
+ for (int i = 0; i < p.piece_count(them, QUEEN); i++)
{
from = p.piece_list(them, QUEEN, i);
if ( bit_is_set(p.piece_attacks<QUEEN>(from), to)
// value if the other side has a rook or queen.
if(square_file(s) == FILE_A || square_file(s) == FILE_H) {
if(pos.non_pawn_material(them) == KnightValueMidgame
- && pos.knight_count(them) == 1)
+ && pos.piece_count(them, KNIGHT) == 1)
ebonus += ebonus / 4;
else if(pos.rooks_and_queens(them))
ebonus -= ebonus / 4;
return mi;
}
else if(pos.non_pawn_material(BLACK) == Value(0) &&
- pos.pawn_count(BLACK) == 0 &&
+ pos.piece_count(BLACK, PAWN) == 0 &&
pos.non_pawn_material(WHITE) >= RookValueEndgame) {
mi->evaluationFunction = &EvaluateKXK;
return mi;
}
else if(pos.non_pawn_material(WHITE) == Value(0) &&
- pos.pawn_count(WHITE) == 0 &&
+ pos.piece_count(WHITE, PAWN) == 0 &&
pos.non_pawn_material(BLACK) >= RookValueEndgame) {
mi->evaluationFunction = &EvaluateKKX;
return mi;
}
if(pos.non_pawn_material(WHITE) == BishopValueMidgame &&
- pos.bishop_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
+ pos.piece_count(WHITE, BISHOP) == 1 && pos.piece_count(WHITE, PAWN) >= 1)
mi->scalingFunction[WHITE] = &ScaleKBPK;
if(pos.non_pawn_material(BLACK) == BishopValueMidgame &&
- pos.bishop_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
+ pos.piece_count(BLACK, BISHOP) == 1 && pos.piece_count(BLACK, PAWN) >= 1)
mi->scalingFunction[BLACK] = &ScaleKKBP;
- if(pos.pawn_count(WHITE) == 0 &&
+ if(pos.piece_count(WHITE, PAWN) == 0 &&
pos.non_pawn_material(WHITE) == QueenValueMidgame &&
- pos.queen_count(WHITE) == 1 &&
- pos.rook_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
+ pos.piece_count(WHITE, QUEEN) == 1 &&
+ pos.piece_count(BLACK, ROOK) == 1 && pos.piece_count(BLACK, PAWN) >= 1)
mi->scalingFunction[WHITE] = &ScaleKQKRP;
- else if(pos.pawn_count(BLACK) == 0 &&
+ else if(pos.piece_count(BLACK, PAWN) == 0 &&
pos.non_pawn_material(BLACK) == QueenValueMidgame &&
- pos.queen_count(BLACK) == 1 &&
- pos.rook_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
+ pos.piece_count(BLACK, QUEEN) == 1 &&
+ pos.piece_count(WHITE, ROOK) == 1 && pos.piece_count(WHITE, PAWN) >= 1)
mi->scalingFunction[BLACK] = &ScaleKRPKQ;
if(pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0)) {
- if(pos.pawn_count(BLACK) == 0) {
- assert(pos.pawn_count(WHITE) >= 2);
+ if(pos.piece_count(BLACK, PAWN) == 0) {
+ assert(pos.piece_count(WHITE, PAWN) >= 2);
mi->scalingFunction[WHITE] = &ScaleKPsK;
}
- else if(pos.pawn_count(WHITE) == 0) {
- assert(pos.pawn_count(BLACK) >= 2);
+ else if(pos.piece_count(WHITE, PAWN) == 0) {
+ assert(pos.piece_count(BLACK, PAWN) >= 2);
mi->scalingFunction[BLACK] = &ScaleKKPs;
}
- else if(pos.pawn_count(WHITE) == 1 && pos.pawn_count(BLACK) == 1) {
+ else if(pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1) {
mi->scalingFunction[WHITE] = &ScaleKPKPw;
mi->scalingFunction[BLACK] = &ScaleKPKPb;
}
for(c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign) {
// No pawns makes it difficult to win, even with a material advantage:
- if(pos.pawn_count(c) == 0 &&
+ if(pos.piece_count(c, PAWN) == 0 &&
pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c))
<= BishopValueMidgame) {
if(pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c)))
else if(pos.non_pawn_material(c) < RookValueMidgame)
mi->factor[c] = 0;
else {
- switch(pos.bishop_count(c)) {
+ switch(pos.piece_count(c, BISHOP)) {
case 2:
mi->factor[c] = 32; break;
case 1:
}
// Bishop pair:
- if(pos.bishop_count(c) >= 2) {
+ if(pos.piece_count(c, BISHOP) >= 2) {
mgValue += sign * BishopPairMidgameBonus;
egValue += sign * BishopPairEndgameBonus;
}
// formula is taken from Larry Kaufman's paper "The Evaluation of Material
// Imbalances in Chess":
// http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
- mgValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
- egValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
+ mgValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
+ egValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
// Redundancy of major pieces, again based on Kaufman's paper:
- if(pos.rook_count(c) >= 1) {
- Value v = Value((pos.rook_count(c) - 1) * 32 + pos.queen_count(c) * 16);
+ if(pos.piece_count(c, ROOK) >= 1) {
+ Value v = Value((pos.piece_count(c, ROOK) - 1) * 32 + pos.piece_count(c, QUEEN) * 16);
mgValue -= sign * v;
egValue -= sign * v;
}