331 lines
9.8 KiB
C
331 lines
9.8 KiB
C
/* bitboard.c - bitboard functions.
|
|
*
|
|
* Copyright (C) 2024 Bruno Raoult ("br")
|
|
* Licensed under the GNU General Public License v3.0 or later.
|
|
* Some rights reserved. See COPYING.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with this
|
|
* program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
|
|
*
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "brlib.h"
|
|
|
|
#include "chessdefs.h"
|
|
#include "piece.h"
|
|
#include "board.h"
|
|
#include "bitboard.h"
|
|
|
|
bitboard_t bb_sq[64];
|
|
bitboard_t bb_sqrank[64], bb_sqfile[64], bb_sqdiag[64], bb_sqanti[64];
|
|
bitboard_t bb_between_excl[64][64];
|
|
bitboard_t bb_between[64][64];
|
|
bitboard_t bb_line[64][64];
|
|
|
|
bitboard_t bb_knight[64], bb_king[64], bb_pawn_attacks[2][64];
|
|
|
|
/* vectors are clockwise from N */
|
|
static int knight_vector[] = {
|
|
NORTH_EAST + NORTH, NORTH_EAST + EAST,
|
|
SOUTH_EAST + EAST, SOUTH_EAST + SOUTH,
|
|
SOUTH_WEST + SOUTH, SOUTH_WEST + WEST,
|
|
NORTH_WEST + WEST, NORTH_WEST + NORTH
|
|
};
|
|
static int king_vector[8] = {
|
|
NORTH, NORTH_EAST, EAST, SOUTH_EAST,
|
|
SOUTH, SOUTH_WEST, WEST, NORTH_WEST
|
|
};
|
|
|
|
/**
|
|
* bitboard_between_excl() - get bitboard of squares between two squares.
|
|
* @sq1, @sq2: The two square_t squares
|
|
*
|
|
* From: http://www.talkchess.com/forum3/viewtopic.php?f=7&t=12499&start=14
|
|
* This function may be used instead of bb_XXX arrays if cache pressure is high.
|
|
*
|
|
* @Return: bitboard_t, squares between @sq1 and @sq2 (excl. @sq1 and @sq2).
|
|
*/
|
|
bitboard_t bitboard_between_excl(square_t sq1, square_t sq2)
|
|
{
|
|
const bitboard_t m1 = -1;
|
|
const bitboard_t a2a7 = C64(0x0001010101010100);
|
|
const bitboard_t b7h1 = C64(0x0002040810204080);
|
|
bitboard_t btwn_bits, ray_bits;
|
|
u32 rank_diff, file_diff, anti_diff, diag_diff;
|
|
|
|
btwn_bits = (m1 << sq1) ^ (m1 << sq2); /* includes sq1 and sq2 */
|
|
rank_diff = ((sq2 | 7) - sq1) >> 3, /* signed */
|
|
file_diff = (sq2 & 7) - (sq1 & 7); /* signed */
|
|
|
|
anti_diff = rank_diff + file_diff;
|
|
rank_diff = rank_diff & 15;
|
|
file_diff = file_diff & 15;
|
|
anti_diff = anti_diff & 15;
|
|
diag_diff = rank_diff ^ file_diff;
|
|
ray_bits = 2 * ((rank_diff - 1) >> 26);
|
|
|
|
ray_bits |= bswap64((m1 + diag_diff) & b7h1);
|
|
ray_bits |= (m1 + anti_diff) & b7h1;
|
|
ray_bits |= (m1 + file_diff) & a2a7;
|
|
ray_bits *= btwn_bits & -btwn_bits;
|
|
return ray_bits & btwn_bits;
|
|
}
|
|
|
|
/**
|
|
* bitboard_init() - initialize general bitboards
|
|
*
|
|
* Generate the following bitboards :
|
|
* bb_sq[64]: square to bitboard
|
|
* bb_sqrank[64]: square to rank
|
|
* bb_sqfile[64]: square to file
|
|
* bb_sqdiag[64]: square to diagonal
|
|
* bb_sqanti[64]: square to antidiagonal
|
|
*
|
|
* bb_between_excl[64][64]: strict squares between two squares
|
|
* bb_between[64][64]: squares between two squares including second square
|
|
*
|
|
* And the following pseudo move masks:
|
|
* bb_knight[64]: knight moves
|
|
* bb_king[64]: king moves
|
|
*
|
|
*/
|
|
void bitboard_init(void)
|
|
{
|
|
/* for each square, the 4 masks: file, rank, diagonal, antidiagonal */
|
|
struct { int df, dr; } vecs[4] = {
|
|
{ 0, 1 }, /* vertical/file */
|
|
{ 1, 0 }, /* horizontal/rank */
|
|
{ 1, 1 }, /* diagonal */
|
|
{ 1, -1 }, /* antidiagonal */
|
|
} ;
|
|
bitboard_t tmpbb[64][4] = { 0 };
|
|
|
|
/* 1) square to bitboard
|
|
* in-between, sq2 excluded
|
|
*/
|
|
for (square_t sq1 = A1; sq1 <= H8; ++sq1) {
|
|
bb_sq[sq1] = mask(sq1);
|
|
for (square_t sq2 = A1; sq2 <= H8; ++sq2)
|
|
bb_between_excl[sq1][sq2] = bitboard_between_excl(sq1, sq2);
|
|
}
|
|
|
|
/* 2) sq1-to-sq2 mask, sq2 included
|
|
* square to file/rank/dia/anti bitmaps
|
|
*/
|
|
for (square_t sq = 0; sq < 64; ++sq) {
|
|
file_t f = sq_file(sq);
|
|
rank_t r = sq_rank(sq);
|
|
for (int vec = 0; vec < 4; ++vec) {
|
|
tmpbb[sq][vec] |= mask(sq_make(f, r));
|
|
for (int dir = -1; dir <= 1; dir += 2) {
|
|
file_t df = dir * vecs[vec].df, f2 = f + df;
|
|
rank_t dr = dir * vecs[vec].dr, r2 = r + dr;
|
|
bitboard_t mask_between = 0;
|
|
while (sq_coord_ok(f2) && sq_coord_ok(r2)) {
|
|
square_t dest = sq_make(f2, r2);
|
|
tmpbb[sq][vec] |= mask(dest);
|
|
mask_between |= mask(dest);
|
|
bb_between[sq][dest] = mask_between;
|
|
f2 += df, r2 += dr;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (square_t sq = 0; sq < 64; ++sq) {
|
|
bb_sqfile[sq] = tmpbb[sq][0];
|
|
bb_sqrank[sq] = tmpbb[sq][1];
|
|
bb_sqdiag[sq] = tmpbb[sq][2];
|
|
bb_sqanti[sq] = tmpbb[sq][3];
|
|
}
|
|
for (square_t sq1 = 0; sq1 < 64; ++sq1) {
|
|
for (square_t sq2 = 0; sq2 < 64; ++sq2) {
|
|
if (sq1 != sq2) {
|
|
if (bb_sqfile[sq1] == bb_sqfile[sq2])
|
|
bb_line[sq1][sq2] = bb_sqfile[sq1];
|
|
else if (bb_sqrank[sq1] == bb_sqrank[sq2])
|
|
bb_line[sq1][sq2] = bb_sqrank[sq1];
|
|
else if (bb_sqdiag[sq1] == bb_sqdiag[sq2])
|
|
bb_line[sq1][sq2] = bb_sqdiag[sq1];
|
|
else if (bb_sqanti[sq1] == bb_sqanti[sq2])
|
|
bb_line[sq1][sq2] = bb_sqanti[sq1];
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 3) pawn, knight and king attacks
|
|
*/
|
|
for (square_t sq = A1; sq <= H8; ++sq) {
|
|
if (sq >= A2 && sq <= H7) {
|
|
bb_pawn_attacks[WHITE][sq] = pawn_attacks_bb(mask(sq), WHITE);
|
|
bb_pawn_attacks[BLACK][sq] = pawn_attacks_bb(mask(sq), BLACK);
|
|
}
|
|
|
|
for (int vec = 0; vec < 8; ++vec) {
|
|
int dst = sq + knight_vector[vec];
|
|
if (sq_ok(dst)) {
|
|
if (sq_dist(dst, sq) == 2) {
|
|
bb_knight[sq] |= bb_sq[dst];
|
|
}
|
|
}
|
|
dst = sq + king_vector[vec];
|
|
if (sq_ok(dst)) {
|
|
if (sq_dist(dst, sq) == 1) {
|
|
bb_king[sq] |= bb_sq[dst];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* bb_knight_moves() - get bitboard of knight pseudo-moves
|
|
* @notmine: bitboard_t of squares not occupied by own pieces
|
|
* @sq: knight square
|
|
*
|
|
* @Return: bitboard of available moves.
|
|
*/
|
|
bitboard_t bb_knight_moves(bitboard_t notmine, square_t sq)
|
|
{
|
|
return bb_knight[sq] & notmine;
|
|
}
|
|
|
|
/**
|
|
* bb_king_moves() - get bitboard of king pseudo-moves
|
|
* @notmine: bitboard_t of squares not occupied by own pieces
|
|
* @sq: king square
|
|
*
|
|
* @Return: bitboard of available moves.
|
|
*/
|
|
bitboard_t bb_king_moves(bitboard_t notmine, square_t sq)
|
|
{
|
|
return bb_king[sq] & notmine;
|
|
}
|
|
|
|
/**
|
|
* bb_print() - print simple bitboard representation
|
|
* @title: a string or NULL
|
|
* @bitboard: the bitboard
|
|
*/
|
|
void bb_print(const char *title, const bitboard_t bitboard)
|
|
{
|
|
//char c = p? p: 'X';
|
|
if (title)
|
|
printf("%s\n", title);
|
|
for (rank_t r = RANK_8; r >= RANK_1; --r) {
|
|
printf("%d ", r + 1);
|
|
for (file_t f = FILE_A; f <= FILE_H; ++f) {
|
|
printf(" %c", bitboard & bb_sq[sq_make(f, r)] ? 'X': '.');
|
|
}
|
|
printf("\n");
|
|
}
|
|
printf(" a b c d e f g h\n");
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* bb_print_multi() - print multiple bitboards horizontally
|
|
* @title: a string or NULL
|
|
* @n: number of bitboards
|
|
* @bb_ptr...: pointers to bitboards
|
|
*
|
|
* @n is the number of bitboards to print. If @n > 10, it is reduced to 10
|
|
*/
|
|
void bb_print_multi(const char *title, int n, ...)
|
|
{
|
|
bitboard_t bb[8];
|
|
va_list ap;
|
|
|
|
n = min(n, 10);
|
|
|
|
va_start(ap, n);
|
|
for (int i = 0; i < n; ++i) { /* save all bitboards */
|
|
bb[i] = va_arg(ap, bitboard_t);
|
|
}
|
|
va_end(ap);
|
|
|
|
if (title)
|
|
printf("%s\n", title);
|
|
|
|
for (rank_t r = RANK_8; r >= RANK_1; --r) {
|
|
for (int i = 0; i < n; ++i) {
|
|
printf("%d ", r + 1);
|
|
for (file_t f = FILE_A; f <= FILE_H; ++f) {
|
|
printf(" %c", bb[i] & bb_sq[sq_make(f, r)] ? 'X': '.');
|
|
}
|
|
printf(" ");
|
|
}
|
|
printf("\n");
|
|
}
|
|
for (int i = 0; i < n; ++i) {
|
|
printf(" a b c d e f g h");
|
|
printf(" ");
|
|
}
|
|
printf("\n");
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* bb_rank_sprint() - print an u8 rank binary representation
|
|
* @str: the destination string
|
|
* @bb8: the uchar to print
|
|
*
|
|
* @return: @str, filled with ascii representation
|
|
*/
|
|
char *bb_rank_sprint(char *str, const uchar bb8)
|
|
{
|
|
file_t f;
|
|
for (f = FILE_A; f <= FILE_H; ++f) {
|
|
*(str + f) = bb8 & mask(f) ? '1': '.';
|
|
}
|
|
*(str + f) = 0;
|
|
//printf(" 0 1 2 3 4 5 6 7\n");
|
|
//printf("\n");
|
|
return str;
|
|
}
|
|
|
|
/**
|
|
* bb_sq2str() - convert bitboard to a string with a list of squares.
|
|
* @bb: bitboard
|
|
* @str: destination string
|
|
* @len: max @str length
|
|
*
|
|
* @str will be filled with the list of string representation of @bb, up to @len
|
|
* characters.
|
|
* 3 characters are used per square, so, for example, @str len should be :
|
|
* - For a valid position checkers (two checkers max): 2*3 + 1 = 7.
|
|
* - For a valid position pinners (8 pinners): 8*3 + 1 = 25.
|
|
* - for a full bitboard: 64*3 + 1 = 193.
|
|
*
|
|
* If @len is not enough to fill all moves, the last fitting move is replaced by "...".
|
|
*
|
|
* @return: The string.
|
|
*/
|
|
char *bb_sq2str(const bitboard_t bb, char *str, const int len)
|
|
{
|
|
bitboard_t tmp, sq;
|
|
int nocc = popcount64(bb);
|
|
int needed = 3 * nocc + 1;
|
|
int willdo = (int) len >= needed ? nocc: (len - 1) / 3 - 1;
|
|
int current = 0;
|
|
|
|
//printf("sq2str bb=%lx len=%d willdo=%d\n", bb, len, willdo);
|
|
bit_for_each64(sq, tmp, bb) {
|
|
if (current == willdo) {
|
|
strcpy(str + current * 3, "...");
|
|
} else {
|
|
strcpy(str + current * 3, sq_to_string(sq));
|
|
str[current * 3 + 2] = ' ';
|
|
}
|
|
if (++current > willdo)
|
|
break;
|
|
}
|
|
str[current * 3] = 0;
|
|
return str;
|
|
}
|