Value Position::MgPieceSquareTable[16][64];
Value Position::EgPieceSquareTable[16][64];
-const Piece_attacks_fn piece_attacks_fn[] =
- { 0, 0,
- &Position::knight_attacks,
- &Position::bishop_attacks,
- &Position::rook_attacks,
- &Position::queen_attacks,
- &Position::king_attacks };
////
//// Functions
sliders = rooks_and_queens(them) & ~checkers();
if(sliders & RookPseudoAttacks[ksq]) {
- b2 = rook_attacks(ksq) & pieces_of_color(c);
+ b2 = piece_attacks<ROOK>(ksq) & pieces_of_color(c);
pinners = rook_attacks_bb(ksq, b1 ^ b2) & sliders;
while(pinners) {
s = pop_1st_bit(&pinners);
sliders = bishops_and_queens(them) & ~checkers();
if(sliders & BishopPseudoAttacks[ksq]) {
- b2 = bishop_attacks(ksq) & pieces_of_color(c);
+ b2 = piece_attacks<BISHOP>(ksq) & pieces_of_color(c);
pinners = bishop_attacks_bb(ksq, b1 ^ b2) & sliders;
while(pinners) {
s = pop_1st_bit(&pinners);
sliders = rooks_and_queens(c);
if(sliders & RookPseudoAttacks[ksq]) {
- b2 = rook_attacks(ksq) & pieces_of_color(c);
+ b2 = piece_attacks<ROOK>(ksq) & pieces_of_color(c);
checkers = rook_attacks_bb(ksq, b1 ^ b2) & sliders;
while(checkers) {
s = pop_1st_bit(&checkers);
sliders = bishops_and_queens(c);
if(sliders & BishopPseudoAttacks[ksq]) {
- b2 = bishop_attacks(ksq) & pieces_of_color(c);
+ b2 = piece_attacks<BISHOP>(ksq) & pieces_of_color(c);
checkers = bishop_attacks_bb(ksq, b1 ^ b2) & sliders;
while(checkers) {
s = pop_1st_bit(&checkers);
bool Position::square_is_attacked(Square s, Color c) const {
return
(pawn_attacks(opposite_color(c), s) & pawns(c)) ||
- (knight_attacks(s) & knights(c)) ||
- (king_attacks(s) & kings(c)) ||
- (rook_attacks(s) & rooks_and_queens(c)) ||
- (bishop_attacks(s) & bishops_and_queens(c));
+ (piece_attacks<KNIGHT>(s) & knights(c)) ||
+ (piece_attacks<KING>(s) & kings(c)) ||
+ (piece_attacks<ROOK>(s) & rooks_and_queens(c)) ||
+ (piece_attacks<BISHOP>(s) & bishops_and_queens(c));
}
Bitboard Position::attacks_to(Square s) const {
return
- (black_pawn_attacks(s) & pawns(WHITE)) |
- (white_pawn_attacks(s) & pawns(BLACK)) |
- (knight_attacks(s) & pieces_of_type(KNIGHT)) |
- (rook_attacks(s) & rooks_and_queens()) |
- (bishop_attacks(s) & bishops_and_queens()) |
- (king_attacks(s) & pieces_of_type(KING));
+ (pawn_attacks(BLACK, s) & pawns(WHITE)) |
+ (pawn_attacks(WHITE, s) & pawns(BLACK)) |
+ (piece_attacks<KNIGHT>(s) & pieces_of_type(KNIGHT)) |
+ (piece_attacks<ROOK>(s) & rooks_and_queens()) |
+ (piece_attacks<BISHOP>(s) & bishops_and_queens()) |
+ (piece_attacks<KING>(s) & pieces_of_type(KING));
}
Bitboard Position::attacks_to(Square s, Color c) const {
assert(square_is_ok(t));
switch(piece_on(f)) {
- case WP: return white_pawn_attacks_square(f, t);
- case BP: return black_pawn_attacks_square(f, t);
- case WN: case BN: return knight_attacks_square(f, t);
- case WB: case BB: return bishop_attacks_square(f, t);
- case WR: case BR: return rook_attacks_square(f, t);
- case WQ: case BQ: return queen_attacks_square(f, t);
- case WK: case BK: return king_attacks_square(f, t);
+ case WP: return pawn_attacks_square(WHITE, f, t);
+ case BP: return pawn_attacks_square(BLACK, f, t);
+ case WN: case BN: return piece_attacks_square<KNIGHT>(f, t);
+ case WB: case BB: return piece_attacks_square<BISHOP>(f, t);
+ case WR: case BR: return piece_attacks_square<ROOK>(f, t);
+ case WQ: case BQ: return piece_attacks_square<QUEEN>(f, t);
+ case WK: case BK: return piece_attacks_square<KING>(f, t);
default: return false;
}
switch(move_promotion(m)) {
case KNIGHT:
- return knight_attacks_square(to, ksq);
+ return piece_attacks_square<KNIGHT>(to, ksq);
case BISHOP:
return bit_is_set(bishop_attacks_bb(to, b), ksq);
case ROOK:
return true;
// Normal check?
else
- return bit_is_set(knight_attacks(ksq), to);
+ return bit_is_set(piece_attacks<KNIGHT>(ksq), to);
case BISHOP:
// Discovered check?
return true;
// Normal check?
else
- return bit_is_set(bishop_attacks(ksq), to);
+ return bit_is_set(piece_attacks<BISHOP>(ksq), to);
case ROOK:
// Discovered check?
return true;
// Normal check?
else
- return bit_is_set(rook_attacks(ksq), to);
+ return bit_is_set(piece_attacks<ROOK>(ksq), to);
case QUEEN:
// Discovered checks are impossible!
assert(!bit_is_set(dcCandidates, from));
// Normal check?
- return bit_is_set(queen_attacks(ksq), to);
+ return bit_is_set(piece_attacks<QUEEN>(ksq), to);
case KING:
// Discovered check?
assert(square_is_occupied(f));
switch(piece_on(f)) {
- case WP: return white_pawn_attacks_square(t, s);
- case BP: return black_pawn_attacks_square(t, s);
- case WN: case BN: return knight_attacks_square(t, s);
- case WB: case BB: return bishop_attacks_square(t, s);
- case WR: case BR: return rook_attacks_square(t, s);
- case WQ: case BQ: return queen_attacks_square(t, s);
- case WK: case BK: return king_attacks_square(t, s);
+ case WP: return pawn_attacks_square(WHITE, t, s);
+ case BP: return pawn_attacks_square(BLACK, t, s);
+ case WN: case BN: return piece_attacks_square<KNIGHT>(t, s);
+ case WB: case BB: return piece_attacks_square<BISHOP>(t, s);
+ case WR: case BR: return piece_attacks_square<ROOK>(t, s);
+ case WQ: case BQ: return piece_attacks_square<QUEEN>(t, s);
+ case WK: case BK: return piece_attacks_square<KING>(t, s);
default: assert(false);
}
}
if(piece == PAWN) {
if(abs(int(to) - int(from)) == 16) {
- if((us == WHITE && (white_pawn_attacks(from + DELTA_N) &
+ if((us == WHITE && (pawn_attacks(WHITE, from + DELTA_N) &
pawns(BLACK))) ||
- (us == BLACK && (black_pawn_attacks(from + DELTA_S) &
+ (us == BLACK && (pawn_attacks(BLACK, from + DELTA_S) &
pawns(WHITE)))) {
epSquare = Square((int(from) + int(to)) / 2);
key ^= zobEp[epSquare];
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- ((rook_attacks(ksq) & rooks_and_queens(us)) |
- (bishop_attacks(ksq) & bishops_and_queens(us)));
+ ((piece_attacks<ROOK>(ksq) & rooks_and_queens(us)) |
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
break;
case KNIGHT:
- if(bit_is_set(knight_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<KNIGHT>(ksq), to))
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- ((rook_attacks(ksq) & rooks_and_queens(us)) |
- (bishop_attacks(ksq) & bishops_and_queens(us)));
+ ((piece_attacks<ROOK>(ksq) & rooks_and_queens(us)) |
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
break;
case BISHOP:
- if(bit_is_set(bishop_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<BISHOP>(ksq), to))
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- (rook_attacks(ksq) & rooks_and_queens(us));
+ (piece_attacks<ROOK>(ksq) & rooks_and_queens(us));
break;
case ROOK:
- if(bit_is_set(rook_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<ROOK>(ksq), to))
set_bit(&checkersBB, to);
if(bit_is_set(dcCandidates, from))
checkersBB |=
- (bishop_attacks(ksq) & bishops_and_queens(us));
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us));
break;
case QUEEN:
- if(bit_is_set(queen_attacks(ksq), to))
+ if(bit_is_set(piece_attacks<QUEEN>(ksq), to))
set_bit(&checkersBB, to);
break;
case KING:
if(bit_is_set(dcCandidates, from))
checkersBB |=
- ((rook_attacks(ksq) & rooks_and_queens(us)) |
- (bishop_attacks(ksq) & bishops_and_queens(us)));
+ ((piece_attacks<ROOK>(ksq) & rooks_and_queens(us)) |
+ (piece_attacks<BISHOP>(ksq) & bishops_and_queens(us)));
break;
default:
attackers =
(rook_attacks_bb(to, occ) & rooks_and_queens()) |
(bishop_attacks_bb(to, occ) & bishops_and_queens()) |
- (knight_attacks(to) & knights()) |
- (king_attacks(to) & kings()) |
- (white_pawn_attacks(to) & pawns(BLACK)) |
- (black_pawn_attacks(to) & pawns(WHITE));
+ (piece_attacks<KNIGHT>(to) & knights()) |
+ (piece_attacks<KING>(to) & kings()) |
+ (pawn_attacks(WHITE, to) & pawns(BLACK)) |
+ (pawn_attacks(BLACK, to) & pawns(WHITE));
attackers &= occ;
// If the opponent has no attackers, we are finished:
projects / stockfish / blobdiff