150 lines
4.1 KiB
C
150 lines
4.1 KiB
C
#include "bitboard.h"
|
|
#include <stdio.h>
|
|
|
|
uint64_t PAWN_ATTACKS[2][64];
|
|
uint64_t KNIGHT_ATTACKS[64];
|
|
uint64_t KING_ATTACKS[64];
|
|
|
|
void create_knight_attack_cache(void) {
|
|
for (int sq = 0; sq < 64; sq++) {
|
|
uint64_t b = 1ULL << sq;
|
|
uint64_t mask = 0ULL;
|
|
|
|
mask |= (b & ~FILE_A) << 15;
|
|
mask |= (b & ~FILE_H) << 17;
|
|
mask |= (b & ~(FILE_A | FILE_B)) << 6;
|
|
mask |= (b & ~(FILE_G | FILE_H)) << 10;
|
|
mask |= (b & ~FILE_A) >> 17;
|
|
mask |= (b & ~FILE_H) >> 15;
|
|
mask |= (b & ~(FILE_A | FILE_B)) >> 10;
|
|
mask |= (b & ~(FILE_G | FILE_H)) >> 6;
|
|
|
|
KNIGHT_ATTACKS[sq] = mask;
|
|
}
|
|
}
|
|
|
|
void create_pawn_attack_cache(void) {
|
|
for (int sq = 0; sq < 64; sq++) {
|
|
uint64_t b = 1ULL << sq;
|
|
|
|
// White: NE (+9), NW (+7), but never from rank 8
|
|
uint64_t w = ((b & ~FILE_H & ~RANK_8) << 9) | ((b & ~FILE_A & ~RANK_8) << 7);
|
|
|
|
// Black: SE (-7), SW (-9), but never from rank 1
|
|
uint64_t bl = ((b & ~FILE_H & ~RANK_1) >> 7) | ((b & ~FILE_A & ~RANK_1) >> 9);
|
|
|
|
PAWN_ATTACKS[WHITE][sq] = w;
|
|
PAWN_ATTACKS[BLACK][sq] = bl;
|
|
}
|
|
}
|
|
|
|
void create_king_attack_cache(void) {
|
|
for (int sq = 0; sq < 64; sq++) {
|
|
uint64_t b = 1ULL << sq;
|
|
uint64_t mask = 0ULL;
|
|
|
|
// North / South
|
|
mask |= (b & ~RANK_8) << 8;
|
|
mask |= (b & ~RANK_1) >> 8;
|
|
|
|
// East / West
|
|
mask |= (b & ~FILE_H) << 1;
|
|
mask |= (b & ~FILE_A) >> 1;
|
|
|
|
// Diagonals
|
|
mask |= (b & ~FILE_A & ~RANK_8) << 7;
|
|
mask |= (b & ~FILE_H & ~RANK_8) << 9;
|
|
mask |= (b & ~FILE_A & ~RANK_1) >> 9;
|
|
mask |= (b & ~FILE_H & ~RANK_1) >> 7;
|
|
|
|
KING_ATTACKS[sq] = mask;
|
|
}
|
|
}
|
|
|
|
static int first_set_index(uint64_t bb) {
|
|
for (int i = 0; i < 64; ++i) {
|
|
if ((bb >> i) & 1ULL) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int pop_lsb_index(uint64_t *bb) {
|
|
if (*bb == 0) return -1;
|
|
int idx = first_set_index(*bb);
|
|
// Clears bit.
|
|
*bb &= ~(1ULL << idx);
|
|
return idx;
|
|
}
|
|
|
|
static inline uint64_t ray_attacks(int start_square, int delta_file, int delta_rank, uint64_t occupied)
|
|
{
|
|
uint64_t attacks = 0;
|
|
|
|
int start_file = start_square % 8;
|
|
int start_rank = start_square / 8;
|
|
|
|
int next_file = start_file + delta_file;
|
|
int next_rank = start_rank + delta_rank;
|
|
|
|
while (next_file >= 0 && next_file < 8 && next_rank >= 0 && next_rank < 8) {
|
|
int next_square = next_rank * 8 + next_file;
|
|
uint64_t next_bit = 1ULL << next_square;
|
|
|
|
// can attack this square
|
|
attacks |= next_bit;
|
|
|
|
// blocker: include it, then stop
|
|
if (occupied & next_bit)
|
|
break;
|
|
|
|
next_file += delta_file;
|
|
next_rank += delta_rank;
|
|
}
|
|
|
|
return attacks;
|
|
}
|
|
|
|
static inline uint64_t rook_attacks(int square, uint64_t occupied) {
|
|
return ray_attacks(square, +1, 0, occupied) // east
|
|
| ray_attacks(square, -1, 0, occupied) // west
|
|
| ray_attacks(square, 0, +1, occupied) // north
|
|
| ray_attacks(square, 0, -1, occupied); // south
|
|
}
|
|
|
|
static inline uint64_t bishop_attacks(int square, uint64_t occupied) {
|
|
return ray_attacks(square, +1, +1, occupied) // NE
|
|
| ray_attacks(square, -1, +1, occupied) // NW
|
|
| ray_attacks(square, +1, -1, occupied) // SE
|
|
| ray_attacks(square, -1, -1, occupied); // SW
|
|
}
|
|
|
|
static inline uint64_t queen_attacks(int square, uint64_t occupied) {
|
|
// Simply combine both types of attacks
|
|
return rook_attacks(square, occupied) | bishop_attacks(square, occupied);
|
|
}
|
|
|
|
void print_board(const struct Board *b) {
|
|
static const char PIECE_CH[12] = {
|
|
'P','N','B','R','Q','K',
|
|
'p','n','b','r','q','k'
|
|
};
|
|
|
|
char grid[64];
|
|
for (int i = 0; i < 64; ++i) grid[i] = '.';
|
|
|
|
for (int p = 0; p < 12; ++p) {
|
|
uint64_t bb = b->pieces[p];
|
|
while (bb) {
|
|
int sq = pop_lsb_index(&bb);
|
|
grid[sq] = PIECE_CH[p];
|
|
}
|
|
}
|
|
|
|
for (int r = 7; r >= 0; --r) {
|
|
for (int f = 0; f < 8; ++f) {
|
|
putchar(grid[r * 8 + f]);
|
|
if (f < 7) putchar(' ');
|
|
}
|
|
putchar('\n');
|
|
}
|
|
} |