/// Entry::do_king_safety() calculates a bonus for king safety. It is called only
/// when king square changes, which is about 20% of total king_safety() calls.
public Score do_king_safety(Position pos, Square ksq, Color Us)
{
kingSquares[Us] = ksq;
castlingRights[Us] = pos.can_castle_color(Us);
minKPdistance[Us] = 0;
Bitboard pawns = pos.pieces_color_piecetype(Us, PieceTypeS.PAWN);
if (pawns != 0)
{
while (0 == (BitBoard.DistanceRingsBB[ksq][minKPdistance[Us]++] & pawns))
{
}
}
if (Types.relative_rank_square(Us, ksq) > RankS.RANK_4)
{
return(Types.make_score(0, -16 * minKPdistance[Us]));
}
Value bonus = shelter_storm(pos, ksq, Us);
// If we can castle use the bonus after the castle if is bigger
if (pos.can_castle_castleright((new MakeCastlingS(Us, CastlingSideS.KING_SIDE)).right) != 0)
{
bonus = Math.Max(bonus, shelter_storm(pos, Types.relative_square(Us, SquareS.SQ_G1), Us));
}
if (pos.can_castle_castleright((new MakeCastlingS(Us, CastlingSideS.QUEEN_SIDE)).right) != 0)
{
bonus = Math.Max(bonus, shelter_storm(pos, Types.relative_square(Us, SquareS.SQ_C1), Us));
}
return(Types.make_score(bonus, -16 * minKPdistance[Us]));
}
// evaluate_outposts() evaluates bishop and knight outpost squares
public static Score evaluate_outposts(Position pos, EvalInfo ei, Square s, PieceType Pt, Color Us)
{
Color Them = (Us == ColorS.WHITE ? ColorS.BLACK : ColorS.WHITE);
Debug.Assert(Pt == PieceTypeS.BISHOP || Pt == PieceTypeS.KNIGHT);
// Initial bonus based on square
Value bonus = Outpost[Pt == PieceTypeS.BISHOP ? 1 : 0][Types.relative_square(Us, s)];
// Increase bonus if supported by pawn, especially if the opponent has
// no minor piece which can trade with the outpost piece.
if (bonus != 0 && (ei.attackedBy[Us][PieceTypeS.PAWN] & BitBoard.SquareBB[s]) != 0)
{
if (0 == pos.pieces_color_piecetype(Them, PieceTypeS.KNIGHT) &&
0 == (BitBoard.squares_of_color(s) & pos.pieces_color_piecetype(Them, PieceTypeS.BISHOP)))
{
bonus += bonus + bonus / 2;
}
else
{
bonus += bonus / 2;
}
}
return(Types.make_score(bonus, bonus));
}
public static int generate_castling(Position pos, ExtMove[] mlist, int mPos, Color us, CheckInfo ci, CastlingRight Cr, bool Checks, bool Chess960)
{
bool KingSide = (Cr == CastlingRightS.WHITE_OO || Cr == CastlingRightS.BLACK_OO);
if (pos.castling_impeded(Cr) || 0 == pos.can_castle_castleright(Cr))
{
return(mPos);
}
// After castling, the rook and king final positions are the same in Chess960
// as they would be in standard chess.
Square kfrom = pos.king_square(us);
Square rfrom = pos.castling_rook_square(Cr);
Square kto = Types.relative_square(us, KingSide ? SquareS.SQ_G1 : SquareS.SQ_C1);
Bitboard enemies = pos.pieces_color(Types.notColor(us));
Debug.Assert(0 == pos.checkers());
Square K = Chess960 ? kto > kfrom ? SquareS.DELTA_W : SquareS.DELTA_E
: KingSide ? SquareS.DELTA_W : SquareS.DELTA_E;
for (Square s = kto; s != kfrom; s += K)
{
if ((pos.attackers_to(s) & enemies) != 0)
{
return(mPos);
}
}
// Because we generate only legal castling moves we need to verify that
// when moving the castling rook we do not discover some hidden checker.
// For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
if (Chess960 && (BitBoard.attacks_bb_SBBPT(kto, pos.pieces() ^ BitBoard.SquareBB[rfrom], PieceTypeS.ROOK) & pos.pieces_color_piecetype(Types.notColor(us), PieceTypeS.ROOK, PieceTypeS.QUEEN)) != 0)
{
return(mPos);
}
Move m = Types.make(kfrom, rfrom, MoveTypeS.CASTLING);
if (Checks && !pos.gives_check(m, ci))
{
return(mPos);
}
mlist[mPos++].move = m;
return(mPos);
}
/// KR vs KP. This is a somewhat tricky endgame to evaluate precisely without
/// a bitbase. The function below returns drawish scores when the pawn is
/// far advanced with support of the king, while the attacking king is far
/// away.
public Value KRKP(Position pos)
{
Debug.Assert(verify_material(pos, strongSide, ValueS.RookValueMg, 0));
Debug.Assert(verify_material(pos, weakSide, ValueS.VALUE_ZERO, 1));
Square wksq = Types.relative_square(strongSide, pos.king_square(strongSide));
Square bksq = Types.relative_square(strongSide, pos.king_square(weakSide));
Square rsq = Types.relative_square(strongSide, pos.list(strongSide, PieceTypeS.ROOK)[0]);
Square psq = Types.relative_square(strongSide, pos.list(weakSide, PieceTypeS.PAWN)[0]);
Square queeningSq = Types.make_square(Types.file_of(psq), RankS.RANK_1);
Value result;
// If the stronger side's king is in front of the pawn, it's a win
if (wksq < psq && Types.file_of(wksq) == Types.file_of(psq))
{
result = ValueS.RookValueEg - (BitBoard.square_distance(wksq, psq));
}
// If the weaker side's king is too far from the pawn and the rook,
// it's a win
else if (BitBoard.square_distance(bksq, psq) >= 3 + ((pos.side_to_move() == weakSide)?1:0) &&
BitBoard.square_distance(bksq, rsq) >= 3)
{
result = ValueS.RookValueEg - (BitBoard.square_distance(wksq, psq));
}
// If the pawn is far advanced and supported by the defending king,
// the position is drawish
else if (Types.rank_of(bksq) <= RankS.RANK_3 &&
BitBoard.square_distance(bksq, psq) == 1 &&
Types.rank_of(wksq) >= RankS.RANK_4 &&
BitBoard.square_distance(wksq, psq) > 2 + ((pos.side_to_move() == strongSide)?1:0))
{
result = 80 - 8 * BitBoard.square_distance(wksq, psq);
}
else
{
result = (Value)(200) - 8 * (BitBoard.square_distance(wksq, psq + SquareS.DELTA_S)
- BitBoard.square_distance(bksq, psq + SquareS.DELTA_S)
- BitBoard.square_distance(psq, queeningSq));
}
return(strongSide == pos.side_to_move() ? result : -result);
}
/// KB and one or more pawns vs K. It checks for draws with rook pawns and
/// a bishop of the wrong color. If such a draw is detected, SCALE_FACTOR_DRAW
/// is returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
/// will be used.
public ScaleFactor KBPsK(Position pos)
{
Debug.Assert(pos.non_pawn_material(strongSide) == ValueS.BishopValueMg);
Debug.Assert(pos.count(strongSide, PieceTypeS.PAWN) >= 1);
// No assertions about the material of weakSide, because we want draws to
// be detected even when the weaker side has some pawns.
Bitboard pawns = pos.pieces_color_piecetype(strongSide, PieceTypeS.PAWN);
File pawnFile = Types.file_of(pos.list(strongSide, PieceTypeS.PAWN)[0]);
// All pawns are on a single rook file ?
if ((pawnFile == FileS.FILE_A || pawnFile == FileS.FILE_H) &&
0 == (pawns & ~BitBoard.file_bb_file(pawnFile)))
{
Square bishopSq = pos.list(strongSide, PieceTypeS.BISHOP)[0];
Square queeningSq = Types.relative_square(strongSide, Types.make_square(pawnFile, RankS.RANK_8));
Square kingSq = pos.king_square(weakSide);
if (Types.opposite_colors(queeningSq, bishopSq) &&
BitBoard.square_distance(queeningSq, kingSq) <= 1)
{
return(ScaleFactorS.SCALE_FACTOR_DRAW);
}
}
// If all the pawns are on the same B or G file, then it's potentially a draw
if ((pawnFile == FileS.FILE_B || pawnFile == FileS.FILE_G) &&
0 == (pos.pieces_piecetype(PieceTypeS.PAWN) & ~BitBoard.file_bb_file(pawnFile)) &&
pos.non_pawn_material(weakSide) == 0 &&
pos.count(weakSide, PieceTypeS.PAWN) >= 1)
{
// Get weakSide pawn that is closest to the home rank
Square weakPawnSq = BitBoard.backmost_sq(weakSide, pos.pieces_color_piecetype(weakSide, PieceTypeS.PAWN));
Square strongKingSq = pos.king_square(strongSide);
Square weakKingSq = pos.king_square(weakSide);
Square bishopSq = pos.list(strongSide, PieceTypeS.BISHOP)[0];
// There's potential for a draw if our pawn is blocked on the 7th rank,
// the bishop cannot attack it or they only have one pawn left
if (Types.relative_rank_square(strongSide, weakPawnSq) == RankS.RANK_7 &&
(pos.pieces_color_piecetype(strongSide, PieceTypeS.PAWN) & BitBoard.SquareBB[(weakPawnSq + Types.pawn_push(weakSide))]) != 0 &&
(Types.opposite_colors(bishopSq, weakPawnSq) || pos.count(strongSide, PieceTypeS.PAWN) == 1))
{
int strongKingDist = BitBoard.square_distance(weakPawnSq, strongKingSq);
int weakKingDist = BitBoard.square_distance(weakPawnSq, weakKingSq);
// It's a draw if the weak king is on its back two ranks, within 2
// squares of the blocking pawn and the strong king is not
// closer. (I think this rule only fails in practically
// unreachable positions such as 5k1K/6p1/6P1/8/8/3B4/8/8 w
// and positions where qsearch will immediately correct the
// problem such as 8/4k1p1/6P1/1K6/3B4/8/8/8 w)
if (Types.relative_rank_square(strongSide, weakKingSq) >= RankS.RANK_7 &&
weakKingDist <= 2 &&
weakKingDist <= strongKingDist)
{
return(ScaleFactorS.SCALE_FACTOR_DRAW);
}
}
}
return(ScaleFactorS.SCALE_FACTOR_NONE);
}
// evaluate_pieces() assigns bonuses and penalties to the pieces of a given color
public static Score evaluate_pieces(Position pos, EvalInfo ei, Score[] mobility, Bitboard[] mobilityArea, PieceType Pt, Color Us, bool Trace)
{
if (Us == ColorS.WHITE && Pt == PieceTypeS.KING)
{
return(ScoreS.SCORE_ZERO);
}
Bitboard b;
Square s;
Score score = ScoreS.SCORE_ZERO;
PieceType NextPt = (Us == ColorS.WHITE ? Pt : (Pt + 1));
Color Them = (Us == ColorS.WHITE ? ColorS.BLACK : ColorS.WHITE);
Square[] pl = pos.list(Us, Pt);
int plPos = 0;
ei.attackedBy[Us][Pt] = 0;
while ((s = pl[plPos++]) != SquareS.SQ_NONE)
{
// Find attacked squares, including x-ray attacks for bishops and rooks
b = Pt == PieceTypeS.BISHOP ? BitBoard.attacks_bb_SBBPT(s, pos.pieces() ^ pos.pieces_color_piecetype(Us, PieceTypeS.QUEEN), PieceTypeS.BISHOP)
: Pt == PieceTypeS.ROOK ? BitBoard.attacks_bb_SBBPT(s, pos.pieces() ^ pos.pieces_color_piecetype(Us, PieceTypeS.ROOK, PieceTypeS.QUEEN), PieceTypeS.ROOK)
: pos.attacks_from_square_piecetype(s, Pt);
if ((ei.pinnedPieces[Us] & BitBoard.SquareBB[s]) != 0)
{
b &= BitBoard.LineBB[pos.king_square(Us)][s];
}
ei.attackedBy[Us][PieceTypeS.ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;
if ((b & ei.kingRing[Them]) != 0)
{
ei.kingAttackersCount[Us]++;
ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];
Bitboard bb = (b & ei.attackedBy[Them][PieceTypeS.KING]);
if (bb != 0)
{
ei.kingAdjacentZoneAttacksCount[Us] += Bitcount.popcount_Max15(bb);
}
}
if (Pt == PieceTypeS.QUEEN)
{
b &= ~(ei.attackedBy[Them][PieceTypeS.KNIGHT]
| ei.attackedBy[Them][PieceTypeS.BISHOP]
| ei.attackedBy[Them][PieceTypeS.ROOK]);
}
int mob = (Pt != PieceTypeS.QUEEN ? Bitcount.popcount_Max15(b & mobilityArea[Us])
: Bitcount.popcount(b & mobilityArea[Us]));
mobility[Us] += MobilityBonus[Pt][mob];
// Decrease score if we are attacked by an enemy pawn. The remaining part
// of threat evaluation must be done later when we have full attack info.
if ((ei.attackedBy[Them][PieceTypeS.PAWN] & BitBoard.SquareBB[s]) != 0)
{
score -= ThreatenedByPawn[Pt];
}
if (Pt == PieceTypeS.BISHOP || Pt == PieceTypeS.KNIGHT)
{
// Penalty for bishop with same coloured pawns
if (Pt == PieceTypeS.BISHOP)
{
score -= BishopPawns * ei.pi.pawns_on_same_color_squares(Us, s);
}
// Bishop and knight outposts squares
if (0 == (pos.pieces_color_piecetype(Them, PieceTypeS.PAWN) & BitBoard.pawn_attack_span(Us, s)))
{
score += evaluate_outposts(pos, ei, s, Pt, Us);
}
// Bishop or knight behind a pawn
if (Types.relative_rank_square(Us, s) < RankS.RANK_5 &&
(pos.pieces_piecetype(PieceTypeS.PAWN) & BitBoard.SquareBB[(s + Types.pawn_push(Us))]) != 0)
{
score += MinorBehindPawn;
}
}
if (Pt == PieceTypeS.ROOK)
{
// Rook piece attacking enemy pawns on the same rank/file
if (Types.relative_rank_square(Us, s) >= RankS.RANK_5)
{
Bitboard pawns = pos.pieces_color_piecetype(Them, PieceTypeS.PAWN) & BitBoard.PseudoAttacks[PieceTypeS.ROOK][s];
if (pawns != 0)
{
score += Bitcount.popcount_Max15(pawns) * RookOnPawn;
}
}
// Give a bonus for a rook on a open or semi-open file
if (ei.pi.semiopen_file(Us, Types.file_of(s)) != 0)
{
score += ei.pi.semiopen_file(Them, Types.file_of(s)) != 0 ? RookOpenFile : RookSemiopenFile;
}
if (mob > 3 || ei.pi.semiopen_file(Us, Types.file_of(s)) != 0)
{
continue;
}
Square ksq = pos.king_square(Us);
// Penalize rooks which are trapped by a king. Penalize more if the
// king has lost its castling capability.
if (((Types.file_of(ksq) < FileS.FILE_E) == (Types.file_of(s) < Types.file_of(ksq))) &&
(Types.rank_of(ksq) == Types.rank_of(s) || Types.relative_rank_square(Us, ksq) == RankS.RANK_1) &&
0 == ei.pi.semiopen_side(Us, Types.file_of(ksq), Types.file_of(s) < Types.file_of(ksq)))
{
score -= (TrappedRook - Types.make_score(mob * 8, 0)) * (1 + (pos.can_castle_color(Us) == 0 ? 1 : 0));
}
}
// An important Chess960 pattern: A cornered bishop blocked by a friendly
// pawn diagonally in front of it is a very serious problem, especially
// when that pawn is also blocked.
if (Pt == PieceTypeS.BISHOP &&
pos.is_chess960() != 0 &&
(s == Types.relative_square(Us, SquareS.SQ_A1) || s == Types.relative_square(Us, SquareS.SQ_H1)))
{
Square d = Types.pawn_push(Us) + (Types.file_of(s) == FileS.FILE_A ? SquareS.DELTA_E : SquareS.DELTA_W);
if (pos.piece_on(s + d) == Types.make_piece(Us, PieceTypeS.PAWN))
{
score -= !pos.empty(s + d + Types.pawn_push(Us)) ? TrappedBishopA1H1 * 4
: pos.piece_on(s + d + d) == Types.make_piece(Us, PieceTypeS.PAWN) ? TrappedBishopA1H1 * 2
: TrappedBishopA1H1;
}
}
}
if (Trace)
{
Tracing.terms[Us][Pt] = score;
}
return(score - evaluate_pieces(pos, ei, mobility, mobilityArea, NextPt, Them, Trace));
}
