/*
- Glaurung, a UCI chess playing engine.
- Copyright (C) 2004-2008 Tord Romstad
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+ Copyright (C) 2008 Marco Costalba
- Glaurung is free software: you can redistribute it and/or modify
+ Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
- Glaurung is distributed in the hope that it will be useful,
+ Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
ei.egValue += apply_weight(ei.pi->eg_value(), WeightPawnStructureEndgame);
// Initialize king attack bitboards and king attack zones for both sides
- ei.attackedBy[WHITE][KING] = pos.king_attacks(pos.king_square(WHITE));
- ei.attackedBy[BLACK][KING] = pos.king_attacks(pos.king_square(BLACK));
+ ei.attackedBy[WHITE][KING] = pos.piece_attacks<KING>(pos.king_square(WHITE));
+ ei.attackedBy[BLACK][KING] = pos.piece_attacks<KING>(pos.king_square(BLACK));
ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
for (Color c = WHITE; c <= BLACK; c++)
{
// Knights
- for (int i = 0; i < pos.knight_count(c); i++)
- evaluate_knight(pos, pos.knight_list(c, i), c, ei);
+ 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++)
- evaluate_bishop(pos, pos.bishop_list(c, i), c, ei);
+ 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++)
- evaluate_rook(pos, pos.rook_list(c, i), c, ei);
+ 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++)
- evaluate_queen(pos, pos.queen_list(c, i), c, ei);
+ 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
Bitboard b = pos.bishops(c) & MaskA7H7[c];
{
// 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;
}
void evaluate_knight(const Position &p, Square s, Color us, EvalInfo &ei) {
- Bitboard b = p.knight_attacks(s);
+ Bitboard b = p.piece_attacks<KNIGHT>(s);
ei.attackedBy[us][KNIGHT] |= b;
// King attack, mobility and outposts
void evaluate_queen(const Position &p, Square s, Color us, EvalInfo &ei) {
- Bitboard b = p.queen_attacks(s);
+ Bitboard b = p.piece_attacks<QUEEN>(s);
ei.attackedBy[us][QUEEN] |= b;
// King attack and mobility
// 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])
if (QueenContactMates && !p.is_check())
{
Bitboard escapeSquares =
- p.king_attacks(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
+ p.piece_attacks<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
while (b)
{
Square from, to = pop_1st_bit(&b);
- if (!(escapeSquares & ~queen_attacks_bb(to, occ & clear_mask_bb(s))))
+ if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
{
// 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.queen_list(them, i);
- if ( bit_is_set(p.queen_attacks(from), to)
+ from = p.piece_list(them, QUEEN, i);
+ if ( bit_is_set(p.piece_attacks<QUEEN>(from), to)
&& !bit_is_set(p.pinned_pieces(them), from)
- && !(rook_attacks_bb(to, occ & clear_mask_bb(from)) & p.rooks_and_queens(us))
- && !(rook_attacks_bb(to, occ & clear_mask_bb(from)) & p.rooks_and_queens(us)))
+ && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
+ && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us)))
ei.mateThreat[them] = make_move(from, to);
}
// Analyse safe distance checks:
if (QueenCheckBonus > 0 || RookCheckBonus > 0)
{
- b = p.rook_attacks(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
+ b = p.piece_attacks<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
}
if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
{
- b = p.bishop_attacks(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
+ b = p.piece_attacks<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
}
if (KnightCheckBonus > 0)
{
- b = p.knight_attacks(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
+ b = p.piece_attacks<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
// Knight checks
b2 = b & ei.attacked_by(them, KNIGHT);
// 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;
projects / stockfish / blobdiff