#include <iostream>
#include <iomanip>
#include <sstream>
+#include <algorithm>
#include "bitcount.h"
#include "evaluate.h"
// all squares attacked by the given color.
Bitboard attackedBy[2][8];
- // kingZone[color] is the zone around the enemy king which is considered
+ // kingRing[color] is the zone around the king which is considered
// by the king safety evaluation. This consists of the squares directly
// adjacent to the king, and the three (or two, for a king on an edge file)
// squares two ranks in front of the king. For instance, if black's king
- // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
+ // is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,
// f7, g7, h7, f6, g6 and h6.
- Bitboard kingZone[2];
+ Bitboard kingRing[2];
// kingAttackersCount[color] is the number of pieces of the given color
- // which attack a square in the kingZone of the enemy king.
+ // which attack a square in the kingRing of the enemy king.
int kingAttackersCount[2];
// kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
- // given color which attack a square in the kingZone of the enemy king. The
+ // given color which attack a square in the kingRing of the enemy king. The
// weights of the individual piece types are given by the variables
// QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
// KnightAttackWeight in evaluate.cpp
//
// Values modified by Joona Kiiski
const Score WeightsInternal[] = {
- S(284, 229), S(252, 259), S(46, 0), S(209, 0), S(349, 0)
+ S(252, 344), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
};
// MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
Value margins[2];
Score score, mobilityWhite, mobilityBlack;
- assert(pos.is_ok());
assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
assert(!pos.in_check());
if ( pos.piece_count(Us, QUEEN)
&& pos.non_pawn_material(Us) >= QueenValueMidgame + RookValueMidgame)
{
- ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
+ ei.kingRing[Them] = (b | (Us == WHITE ? b >> 8 : b << 8));
b &= ei.attackedBy[Us][PAWN];
ei.kingAttackersCount[Us] = b ? count_1s<Max15>(b) / 2 : 0;
ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;
} else
- ei.kingZone[Us] = ei.kingAttackersCount[Us] = 0;
+ ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;
}
if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
{
if ( pos.pieces(KNIGHT, Them) == EmptyBoardBB
- && (SquaresByColorBB[square_color(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
+ && (SquaresByColorBB[color_of(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
bonus += bonus + bonus / 2;
else
bonus += bonus / 2;
ei.attackedBy[Us][Piece] |= b;
// King attacks
- if (b & ei.kingZone[Us])
+ if (b & ei.kingRing[Them])
{
ei.kingAttackersCount[Us]++;
ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
score -= ThreatenedByPawnPenalty[Piece];
// Bishop and knight outposts squares
- if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Us))
+ if ( (Piece == BISHOP || Piece == KNIGHT)
+ && !(pos.pieces(PAWN, Them) & attack_span_mask(Us, s)))
score += evaluate_outposts<Piece, Us>(pos, ei, s);
// Queen or rook on 7th rank
// problem, especially when that pawn is also blocked.
if (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1))
{
- Square d = pawn_push(Us) + (square_file(s) == FILE_A ? DELTA_E : DELTA_W);
+ Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
if (pos.piece_on(s + d) == make_piece(Us, PAWN))
{
if (!pos.square_is_empty(s + d + pawn_push(Us)))
if (Piece == ROOK)
{
// Open and half-open files
- f = square_file(s);
+ f = file_of(s);
if (ei.pi->file_is_half_open(Us, f))
{
if (ei.pi->file_is_half_open(Them, f))
ksq = pos.king_square(Us);
- if ( square_file(ksq) >= FILE_E
- && square_file(s) > square_file(ksq)
- && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
+ if ( file_of(ksq) >= FILE_E
+ && file_of(s) > file_of(ksq)
+ && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
{
// Is there a half-open file between the king and the edge of the board?
- if (!ei.pi->has_open_file_to_right(Us, square_file(ksq)))
+ if (!ei.pi->has_open_file_to_right(Us, file_of(ksq)))
score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
: (TrappedRookPenalty - mob * 16), 0);
}
- else if ( square_file(ksq) <= FILE_D
- && square_file(s) < square_file(ksq)
- && (relative_rank(Us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
+ else if ( file_of(ksq) <= FILE_D
+ && file_of(s) < file_of(ksq)
+ && (relative_rank(Us, ksq) == RANK_1 || rank_of(ksq) == rank_of(s)))
{
// Is there a half-open file between the king and the edge of the board?
- if (!ei.pi->has_open_file_to_left(Us, square_file(ksq)))
+ if (!ei.pi->has_open_file_to_left(Us, file_of(ksq)))
score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
: (TrappedRookPenalty - mob * 16), 0);
}
// the number and types of the enemy's attacking pieces, the number of
// attacked and undefended squares around our king, the square of the
// king, and the quality of the pawn shelter.
- attackUnits = Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ attackUnits = std::min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s<Max15>(undefended))
+ InitKingDanger[relative_square(Us, ksq)]
- mg_value(ei.pi->king_shelter<Us>(pos, ksq)) / 32;
attackUnits += KnightCheckBonus * count_1s<Max15>(b);
// To index KingDangerTable[] attackUnits must be in [0, 99] range
- attackUnits = Min(99, Max(0, attackUnits));
+ attackUnits = std::min(99, std::max(0, attackUnits));
// Finally, extract the king danger score from the KingDangerTable[]
// array and subtract the score from evaluation. Set also margins[]
ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * rr);
// If blockSq is not the queening square then consider also a second push
- if (square_rank(blockSq) != (Us == WHITE ? RANK_8 : RANK_1))
+ if (rank_of(blockSq) != (Us == WHITE ? RANK_8 : RANK_1))
ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr);
// If the pawn is free to advance, increase bonus
// we try the following: Increase the value for rook pawns if the
// other side has no pieces apart from a knight, and decrease the
// value if the other side has a rook or queen.
- if (square_file(s) == FILE_A || square_file(s) == FILE_H)
+ if (file_of(s) == FILE_A || file_of(s) == FILE_H)
{
if (pos.non_pawn_material(Them) <= KnightValueMidgame)
ebonus += ebonus / 4;
for (c = WHITE; c <= BLACK; c++)
{
// Skip if other side has non-pawn pieces
- if (pos.non_pawn_material(opposite_color(c)))
+ if (pos.non_pawn_material(flip(c)))
continue;
b = ei.pi->passed_pawns(c);
while (b)
{
s = pop_1st_bit(&b);
- queeningSquare = relative_square(c, make_square(square_file(s), RANK_8));
+ queeningSquare = relative_square(c, make_square(file_of(s), RANK_8));
queeningPath = squares_in_front_of(c, s);
// Compute plies to queening and check direct advancement
movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
- oppMovesToGo = square_distance(pos.king_square(opposite_color(c)), queeningSquare) - int(c != pos.side_to_move());
+ oppMovesToGo = square_distance(pos.king_square(flip(c)), queeningSquare) - int(c != pos.side_to_move());
pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
if (movesToGo >= oppMovesToGo && !pathDefended)
continue;
pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
- pliesToQueen[c] = Min(pliesToQueen[c], pliesToGo);
+ pliesToQueen[c] = std::min(pliesToQueen[c], pliesToGo);
}
}
return SCORE_ZERO;
winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
- loserSide = opposite_color(winnerSide);
+ loserSide = flip(winnerSide);
// Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
b = candidates = pos.pieces(PAWN, loserSide);
s = pop_1st_bit(&b);
// Compute plies from queening
- queeningSquare = relative_square(loserSide, make_square(square_file(s), RANK_8));
+ queeningSquare = relative_square(loserSide, make_square(file_of(s), RANK_8));
movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
minKingDist = kingptg = 256;
// Compute plies from queening
- queeningSquare = relative_square(loserSide, make_square(square_file(s), RANK_8));
+ queeningSquare = relative_square(loserSide, make_square(file_of(s), RANK_8));
movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(loserSide, s) == RANK_2);
pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
{
d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
- movesToGo = Min(movesToGo, d);
+ movesToGo = std::min(movesToGo, d);
}
}
while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
{
d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
- movesToGo = Min(movesToGo, d);
+ movesToGo = std::min(movesToGo, d);
}
// If obstacle can be destroyed with an immediate pawn exchange / sacrifice,
// Plies needed for the king to capture all the blocking pawns
d = square_distance(pos.king_square(loserSide), blockSq);
- minKingDist = Min(minKingDist, d);
+ minKingDist = std::min(minKingDist, d);
kingptg = (minKingDist + blockersCount) * 2;
}
t[i] = Value(int(0.4 * i * i));
if (i > 0)
- t[i] = Min(t[i], t[i - 1] + MaxSlope);
+ t[i] = std::min(t[i], t[i - 1] + MaxSlope);
- t[i] = Min(t[i], Peak);
+ t[i] = std::min(t[i], Peak);
}
// Then apply the weights and get the final KingDangerTable[] array