bruno/brchess
1
0
Fork 0
Code Issues 10 Projects Releases Wiki Activity

add hyperbola-quintessence.[ch]}, rank move gen, + file/rook/queen

Browse Source
This commit is contained in:
Bruno Raoult
2024-02-15 10:15:13 +01:00
parent bc28a900be
commit 403e625cbe
8 changed files with 297 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
src/bitboard.c
View File

@@ -17,6 +17,7 @@
#include "brlib.h" #include "brlib.h"
#include "chessdefs.h" #include "chessdefs.h"
#include "piece.h"
#include "board.h" #include "board.h"
#include "bitboard.h" #include "bitboard.h"
@@ -31,90 +32,78 @@ static int king_vector[8] = {
NORTH, NORTH_EAST, EAST, SOUTH_EAST, NORTH, NORTH_EAST, EAST, SOUTH_EAST,
SOUTH, SOUTH_WEST, WEST, NORTH_WEST SOUTH, SOUTH_WEST, WEST, NORTH_WEST
}; };
static int bishop_vector[4] = {
NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST
};
static int rook_vector[4] = {
NORTH, EAST, SOUTH, WEST
};
bitboard_t sq_bb[SQUARE_MAX]; bitboard_t bb_sq[SQUARE_MAX];
bitboard_t sq_bbrank[64], sq_bbfile[64], sq_bbdiag[64], sq_bbanti[64]; bitboard_t bb_rank[64], bb_file[64], bb_diagonal[64], bb_antidiagonal[64];
bitboard_t knight_attacks[64], king_attacks[64]; bitboard_t bb_knight[64], bb_king[64];
bitboard_t pawn_attacks[2]; bitboard_t bb_pawn_push[2][64], bb_bpawn_attack[2][64], bb_pawn_ep[2][64];
/* we will create only dest squares for A1-D4 square, then flip
*/
/** /**
* raw_bitboard_print() - print simple bitboard representation * bitboard_init() - initialize general bitboards
* @bb: the bitboard *
* @tit: a string or NULL * Generate the following bitboards :
* bb_sq[64]: square to bitboard
* bb_rank[64]: square to rank
* bb_file[64]: square to file
* bb_diagonal[64]: square to diagonal
* bb_antidiagonal[64]: square to antidiagonal
*
* And the following pseudo move masks:
* bb_knight[64]: knight moves
* bb_king[64]: king moves
* bb_pawn[2][64]: white pawn moves (not attacks)
* bb_pawn_att[2][64]: white pawn attacks
*/ */
void bitboard_init(void) void bitboard_init(void)
{ {
struct { /* for each square, the 4 masks: file, rank, diagonal, antidiagonal */
union { struct { int df, dr; } dirs[4] = {
struct {
bitboard_t diag;
bitboard_t anti;
bitboard_t vert;
bitboard_t hori;
};
bitboard_t all[4];
};
} tmpmasks[64] = {0};
struct {
int df, dr;
} dirs[4] = {
{ 0, 1 }, /* vertical/file */ { 0, 1 }, /* vertical/file */
{ 1, 0 }, /* horizontal/rank */ { 1, 0 }, /* horizontal/rank */
{ 1, 1 }, /* diagonal */ { 1, 1 }, /* diagonal */
{ 1, -1 }, /* antidiagonal */ { 1, -1 }, /* antidiagonal */
} ; } ;
bitboard_t tmpbb[64][4] = { 0 };
square_t sq; /* 1) square to bitboard */
int dst, dst_f, dst_r; for (square_t sq = A1; sq <= H8; ++sq)
bb_sq[sq] = mask(sq);
/* square to bitboard */ /* 2) square to rank/file/diagonal/antidiagonal */
for (sq = A1; sq <= H8; ++sq) for (square_t sq = 0; sq < 64; ++sq) {
sq_bb[sq] = mask(sq);
/* square to rank/file/diagonal/antidiagonal */
for (sq = 0; sq < 64; ++sq) {
int r = sq_rank(sq), f = sq_file(sq); int r = sq_rank(sq), f = sq_file(sq);
for (int mult = -7; mult < 8; ++mult) { for (int mult = -7; mult < 8; ++mult) {
for (int dir = 0; dir < 4; ++dir) { for (int dir = 0; dir < 4; ++dir) {
dst_f = f + mult * dirs[dir].df; int dst_f = f + mult * dirs[dir].df;
dst_r = r + mult * dirs[dir].dr; int dst_r = r + mult * dirs[dir].dr;
if (sq_coord_ok(dst_f) && sq_coord_ok(dst_r)) { if (sq_coord_ok(dst_f) && sq_coord_ok(dst_r)) {
dst = sq_make(dst_f, dst_r); int dst = sq_make(dst_f, dst_r);
tmpmasks[sq].all[dir] |= mask(dst); tmpbb[sq][dir] |= mask(dst);
} }
} }
} }
} }
for (sq = 0; sq < 64; ++sq) { for (square_t sq = 0; sq < 64; ++sq) {
sq_bbfile[sq] = tmpmasks[sq].all[0]; bb_file[sq] = tmpbb[sq][0];
sq_bbrank[sq] = tmpmasks[sq].all[1]; bb_rank[sq] = tmpbb[sq][1];
sq_bbdiag[sq] = tmpmasks[sq].all[2]; bb_diagonal[sq] = tmpbb[sq][2];
sq_bbanti[sq] = tmpmasks[sq].all[3]; bb_antidiagonal[sq] = tmpbb[sq][3];
} }
/* knight and king attacks */ /* 3) knight and king moves */
for (sq = A1; sq <= H8; ++sq) { for (square_t sq = A1; sq <= H8; ++sq) {
for (int vec = 0; vec < 8; ++vec) { for (int vec = 0; vec < 8; ++vec) {
dst = sq + knight_vector[vec]; int dst = sq + knight_vector[vec];
if (sq_ok(dst)) { if (sq_ok(dst)) {
if (sq_dist(dst, sq) == 2) { if (sq_dist(dst, sq) == 2) {
knight_attacks[sq] |= sq_bb[dst]; bb_knight[sq] |= bb_sq[dst];
} }
} }
dst = sq + king_vector[vec]; dst = sq + king_vector[vec];
if (sq_ok(dst)) { if (sq_ok(dst)) {
if (sq_dist(dst, sq) == 1) { if (sq_dist(dst, sq) == 1) {
king_attacks[sq] |= sq_bb[dst]; bb_king[sq] |= bb_sq[dst];
} }
} }
} }
@@ -134,7 +123,7 @@ void bitboard_print(const char *title, const bitboard_t bitboard)
for (rank_t r = RANK_8; r >= RANK_1; --r) { for (rank_t r = RANK_8; r >= RANK_1; --r) {
printf("%d ", r + 1); printf("%d ", r + 1);
for (file_t f = FILE_A; f <= FILE_H; ++f) { for (file_t f = FILE_A; f <= FILE_H; ++f) {
printf(" %c", bitboard & sq_bb[sq_make(f, r)] ? 'X': '.'); printf(" %c", bitboard & bb_sq[sq_make(f, r)] ? 'X': '.');
} }
printf("\n"); printf("\n");
} }
@@ -150,35 +139,51 @@ void bitboard_print(const char *title, const bitboard_t bitboard)
* *
* @n is the number of bitboards to print. If @n -s > 8, it is reduced to 8; * @n is the number of bitboards to print. If @n -s > 8, it is reduced to 8;
*/ */
void bitboard_print_multi(const char *title, const int n, ...) void bitboard_print_multi(const char *title, int n, ...)
{ {
bitboard_t bb[16]; bitboard_t bb[8];
int i;
va_list ap; va_list ap;
n = min(n, 8);
va_start(ap, n); va_start(ap, n);
for (i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) { /* save all bitboards */
bb[i] = va_arg(ap, bitboard_t); bb[i] = va_arg(ap, bitboard_t);
} }
va_end(ap); va_end(ap);
//char c = p? p: 'X';
if (title) if (title)
printf("%s\n", title); printf("%s\n", title);
for (rank_t r = RANK_8; r >= RANK_1; --r) { for (rank_t r = RANK_8; r >= RANK_1; --r) {
for (i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
printf("%d ", r + 1); printf("%d ", r + 1);
for (file_t f = FILE_A; f <= FILE_H; ++f) { for (file_t f = FILE_A; f <= FILE_H; ++f) {
printf(" %c", bb[i] & sq_bb[sq_make(f, r)] ? 'X': '.'); printf(" %c", bb[i] & bb_sq[sq_make(f, r)] ? 'X': '.');
} }
printf(" "); printf(" ");
} }
printf("\n"); printf("\n");
} }
for (i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
printf(" a b c d e f g h"); printf(" a b c d e f g h");
printf(" "); printf(" ");
} }
printf("\n"); printf("\n");
return; return;
} }
/**
* bitboard_rank_sprint() - print an u8 rank binary representation
* @str: the destination string
* @bb8: the uchar to print
*/
char *bitboard_rank_sprint(char *str, const uchar bb8)
{
for (file_t f = FILE_A; f <= FILE_H; ++f) {
*(str+f) = bb8 & mask(f) ? '1': '.';
}
//printf(" 0 1 2 3 4 5 6 7\n");
//printf("\n");
return str;
}

50
src/bitboard.h
View File

@@ -23,16 +23,15 @@
typedef u64 bitboard_t; typedef u64 bitboard_t;
/* mapping square -> bitboard */ /* mapping square -> bitboard */
extern bitboard_t sq_bb[64]; extern bitboard_t bb_sq[64];
/* mapping square -> rank/file/diagonal/antidiagonal */ /* mapping square -> rank/file/diagonal/antidiagonal */
extern bitboard_t sq_bbrank[64], sq_bbfile[64], sq_bbdiag[64], sq_bbanti[64]; extern bitboard_t bb_rank[64], bb_file[64], bb_diagonal[64], bb_antidiagonal[64];
extern bitboard_t bb_knight[64], bb_king[64];
extern bitboard_t knight_attacks[64], king_attacks[64];
#define mask(i) ( 1ULL << (i) ) #define mask(i) ( 1ULL << (i) )
typedef enum { enum {
FILE_Abb = 0x0101010101010101ULL, FILE_Abb = 0x0101010101010101ULL,
FILE_Bbb = 0x0202020202020202ULL, FILE_Bbb = 0x0202020202020202ULL,
FILE_Cbb = 0x0404040404040404ULL, FILE_Cbb = 0x0404040404040404ULL,
@@ -41,9 +40,9 @@ typedef enum {
FILE_Fbb = 0x2020202020202020ULL, FILE_Fbb = 0x2020202020202020ULL,
FILE_Gbb = 0x4040404040404040ULL, FILE_Gbb = 0x4040404040404040ULL,
FILE_Hbb = 0x8080808080808080ULL, FILE_Hbb = 0x8080808080808080ULL,
} file_bb; };
typedef enum { enum {
RANK_1bb = 0x00000000000000ffULL, RANK_1bb = 0x00000000000000ffULL,
RANK_2bb = 0x000000000000ff00ULL, RANK_2bb = 0x000000000000ff00ULL,
RANK_3bb = 0x0000000000ff0000ULL, RANK_3bb = 0x0000000000ff0000ULL,
@@ -52,7 +51,7 @@ typedef enum {
RANK_6bb = 0x0000ff0000000000ULL, RANK_6bb = 0x0000ff0000000000ULL,
RANK_7bb = 0x00ff000000000000ULL, RANK_7bb = 0x00ff000000000000ULL,
RANK_8bb = 0xff00000000000000ULL RANK_8bb = 0xff00000000000000ULL
} rank_bb; };
/* https://www.chessprogramming.org/Flipping_Mirroring_and_Rotating#Rotation /* https://www.chessprogramming.org/Flipping_Mirroring_and_Rotating#Rotation
*/ */
@@ -61,8 +60,43 @@ static __always_inline bitboard_t bb_rotate_90(bitboard_t b)
return b; return b;
} }
/* TODO: when OK, replace with macros */
static __always_inline bitboard_t shift_n(const bitboard_t bb)
{
return bb << NORTH;
}
static __always_inline bitboard_t shift_ne(const bitboard_t bb)
{
return (bb & ~FILE_Hbb) << NORTH_EAST;
}
static __always_inline bitboard_t shift_e(const bitboard_t bb)
{
return (bb & ~FILE_Hbb) << EAST;
}
static __always_inline bitboard_t shift_se(const bitboard_t bb)
{
return (bb & ~FILE_Hbb) >> -SOUTH_EAST;
}
static __always_inline bitboard_t shift_s(const bitboard_t bb)
{
return bb >> -SOUTH;
}
static __always_inline bitboard_t shift_sw(const bitboard_t bb)
{
return (bb & ~FILE_Abb) >> -SOUTH_WEST;
}
static __always_inline bitboard_t shift_w(const bitboard_t bb)
{
return (bb & ~FILE_Abb) >> -WEST;
}
static __always_inline bitboard_t shift_nw(const bitboard_t bb)
{
return (bb & ~FILE_Abb) << NORTH_WEST;
}
extern void bitboard_init(void); extern void bitboard_init(void);
extern void bitboard_print(const char *title, const bitboard_t bitboard); extern void bitboard_print(const char *title, const bitboard_t bitboard);
extern void bitboard_print_multi(const char *title, const int n, ...); extern void bitboard_print_multi(const char *title, const int n, ...);
extern char *bitboard8_sprint(char *str, const uchar bb8);
#endif /* _BITBOARD_H */ #endif /* _BITBOARD_H */

73
src/board.h
View File

@@ -18,16 +18,22 @@
#include "chessdefs.h" #include "chessdefs.h"
/* a square is defined as
* rrrfff
*/
#define SQ_FILEMASK (007) /* warning, octal */
#define SQ_RANKMASK (070)
typedef enum { typedef enum {
_SSQUARE_ = -1, /* force signed enum */ _SSQUARE_ = -1, /* force signed enum */
A1 = 0, B1, C1, D1, E1, F1, G1, H1, A1 = 0, B1, C1, D1, E1, F1, G1, H1,
A2, B2, C2, D2, E2, F2, G2, H2, A2, B2, C2, D2, E2, F2, G2, H2,
A3, B3, C3, D3, E3, F3, G3, H3, A3, B3, C3, D3, E3, F3, G3, H3,
A4, B4, C4, D4, E4, F4, G4, H4, A4, B4, C4, D4, E4, F4, G4, H4,
A5, B5, C5, D5, E5, F5, G5, H5, A5, B5, C5, D5, E5, F5, G5, H5,
A6, B6, C6, D6, E6, F6, G6, H6, A6, B6, C6, D6, E6, F6, G6, H6,
A7, B7, C7, D7, E7, F7, G7, H7, A7, B7, C7, D7, E7, F7, G7, H7,
A8, B8, C8, D8, E8, F8, G8, H8, A8, B8, C8, D8, E8, F8, G8, H8,
SQUARE_MAX = 64, SQUARE_MAX = 64,
SQUARE_NONE = 64 SQUARE_NONE = 64
} square_t; } square_t;
@@ -71,65 +77,26 @@ static __always_inline square_t sq_make(file_t file, rank_t rank)
} }
static __always_inline file_t sq_file(square_t square) static __always_inline file_t sq_file(square_t square)
{ {
return square & 7; return square & SQ_FILEMASK;
} }
static __always_inline rank_t sq_rank(square_t square) static __always_inline rank_t sq_rank(square_t square)
{ {
return square >> 3; return square >> 3;
} }
#define sq_ok(sq) ((sq) >= A1 && (sq) <= H8) #define sq_ok(sq) ((sq) >= A1 && (sq) <= H8)
#define sq_coord_ok(c) ((c) >= 0 && (c) < 8) #define sq_coord_ok(c) ((c) >= 0 && (c) < 8)
/* Chebyshev distance: https://www.chessprogramming.org/Distance */ /* Chebyshev distance: max( |r2 - r1|, |f2 - f1| )
* See: https://www.chessprogramming.org/Distance
*/
#define sq_dist(sq1, sq2) (max(abs(sq_file(sq2) - sq_file(sq1)), \ #define sq_dist(sq1, sq2) (max(abs(sq_file(sq2) - sq_file(sq1)), \
abs(sq_rank(sq2) - sq_rank(sq1)))) abs(sq_rank(sq2) - sq_rank(sq1))))
/* Manhattan distance */ /* Manhattan distance: |r2 - r1| + |f2 - f1|
*/
#define sq_manh(sq1, sq2) (abs(sq_file(sq2) - sq_file(sq1)) + \ #define sq_manh(sq1, sq2) (abs(sq_file(sq2) - sq_file(sq1)) + \
abs(sq_rank(sq2) - sq_rank(sq1))) abs(sq_rank(sq2) - sq_rank(sq1)))
// while the orthogonal Manhattan-Distance is the sum of both absolute rank- and file-distance distances. extern const char *sq_string(const square_t sq);
//Dtaxi = |r2 - r1| + |f2 - f1|
// Chebyshev Distance
//#include "piece.h"
/* definitions for 0x88 representation
*/
//#define SQ88(f, r) (((r) << 4) | (f)) /* from rank,file to sq88 */
//#define F88(s) ((s) & 0x0f) /* from sq88 to file */
//#define R88(s) ((s) >> 4) /* from sq88 to rank */
//#define SETF88(s, r) ((s) &= 0xf0, (s) |= (r))
//#define SETR88(s, f) ((s) &= 0x0f, (s) |= (f)<<4)
//#define SQ88_NOK(s) ((s) & 0x88) /* invalid square */
//#define SQ88_OK(s) (!SQ88_NOK(s))
/* definitions for bitboard representation
*/
//#define BB(f, r) (1ULL << (8 * (r) + (f))) /* from rank,file to bitboard */
//#define SQ88_2_BB(s) (BB(F88(s), R88(s))) /* from sq88 to bitboard */
//#define FILEBB(b) ((b) % 8) /* from sq88 to file */
//#define RANKBB(b) ((b) / 8) /* from sq88 to rank */
//#define SQ88_NOK(s) ((s) & 0x88) /* invalid square */
//#define SQ88_OK(s) (!SQ88_NOK(s))
/* from human to machine
*/
/*
* #define C2FILE(c) (tolower(c) - 'a')
* #define C2RANK(c) (tolower(c) - '1')
* /\* from machine to human
* *\/
* #define FILE2C(f) ((f) + 'a')
* #define RANK2C(r) ((r) + '1')
*/
#endif /* BOARD_H */ #endif /* BOARD_H */

2
src/brchess.c
View File

@@ -18,7 +18,7 @@
#include <readline/readline.h> #include <readline/readline.h>
#include <readline/history.h> #include <readline/history.h>
#include <br.h> #include <brlib.h>
#include <list.h> #include <list.h>
#include <debug.h> #include <debug.h>

126
src/hyperbola-quintessence.c Normal file
View File

@@ -0,0 +1,126 @@
/* hyperbola-quintessence.c - hyperbola quintessence 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 "board.h"
#include "bitboard.h"
#include "hyperbola-quintessence.h"
uchar bb_rank_attacks[64 * 8];
/**
* hyperbola_init() - init hyperbola quintessence attack bitboards
*
* See: https://www.chessprogramming.org/Kindergarten_Bitboards
* and https://www.chessprogramming.org/Hyperbola_Quintessence
*
* Generate the rank attacks bitboard:
* bb_rank_hyperbola[64 * 8], where:
* - 64 = 2^6 = the occupation of inner 6 bits on rank
* - 8 = file of sliding piece
*
*/
void hyperbola_init()
{
/* generate rank attacks
*/
for (int occ = 0; occ < 64; ++occ) {
for (int file = 0; file < 8; ++file) {
uchar attacks = 0;
/* set f left attacks */
for (int slide = file - 1; slide >= 0; --slide) {
int b = bb_sq[slide]; /* bit to consider */
attacks |= b; /* add to attack mask */
if ((occ << 1) & b) /* piece on b, we stop */
break;
}
/* set f right attacks */
for (int slide = file + 1; slide < 8; ++slide) {
int b = bb_sq[slide];
attacks |= b;
if ((occ << 1) & b)
break;
}
bb_rank_attacks[occ * 8 + file] = attacks;
}
}
}
/**
* hyperbola_moves() - generate hyperbola moves mask for a given sliding piece
* @pieces: occupation bitboard
* @sq: piece square
* @mask: mask considered
*
* See https://www.chessprogramming.org/Hyperbola_Quintessence
*
* @Return: The moves mask for piece
*/
static bitboard_t hyperbola_moves(const bitboard_t pieces, const square_t sq,
const bitboard_t mask)
{
bitboard_t o = pieces & mask;
bitboard_t r = bswap64(o);
square_t r_sq = FLIP_V(sq);
return ( (o - mask(sq) )
^ bswap64(r - mask(r_sq)))
& mask;
}
static bitboard_t hyperbola_rank_moves(bitboard_t occ, square_t sq)
{
uint32_t rank = sq & SQ_FILEMASK;
uint32_t file = sq & SQ_RANKMASK;
uint64_t o = (occ >> rank) & 126; /* removes bits 0 & 7 */
return ((bitboard_t)bb_rank_attacks[o * 4 + file]) << rank;
}
static bitboard_t hyperbola_file_moves(bitboard_t occ, square_t sq)
{
return hyperbola_moves(occ, bb_file[sq], sq);
}
static bitboard_t hyperbola_diagonal_moves(bitboard_t occ, square_t sq)
{
return hyperbola_moves(occ, bb_diagonal[sq], sq);
}
static bitboard_t hyperbola_antidiagonal_moves(bitboard_t occ, square_t sq)
{
return hyperbola_moves(occ, bb_antidiagonal[sq], sq);
}
bitboard_t hyperbola_bishop_moves(bitboard_t occ, square_t sq)
{
return hyperbola_diagonal_moves(occ, sq) + hyperbola_antidiagonal_moves(occ, sq);
}
bitboard_t hyperbola_rook_moves(bitboard_t occ, square_t sq)
{
return hyperbola_file_moves(occ, sq) + hyperbola_rank_moves(occ, sq);
}
bitboard_t hyperbola_queen_moves(bitboard_t occ, square_t sq)
{
return hyperbola_bishop_moves(occ, sq) + hyperbola_rook_moves(occ, sq);
}

19
src/hyperbola-quintessence.h Normal file
View File

@@ -0,0 +1,19 @@
/* hyperbola-quintessence.h - hyperbola-quintessence definitions.
*
* 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>
*
*/
#ifndef _HYPERBOLA_QUINTESSENCE_H
#define _HYPERBOLA_QUINTESSENCE_H
void hyperbola_init(void);
#endif /* _HYPERBOLA_QUINTESSENCE_H */

37
test/bitboard-test.c
View File

@@ -4,28 +4,35 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "../src/bitboard.h"
#include "../src/position.h" #include "../src/position.h"
#include "../src/piece.h" #include "../src/piece.h"
//#include "../src/fen.h" #include "../src/bitboard.h"
#include "../src/hyperbola-quintessence.h"
int main(int __unused ac, __unused char**av) int main(int __unused ac, __unused char**av)
{ {
char str[128]; char str[256];
bitboard_init(); bitboard_init();
hyperbola_init();
for (int i = 0; i < 64; ++i) { for (int i = 0; i < 64; ++i) {
char str[128]; sprintf(str, "\n%#x:\n %-22s%-22s%-22s%-22s%-22s%-22s%-22s", i,
sprintf(str, "\ndiag/antidiag/vert %d", i); "sliding", "diagonal", "antidiagonal", "file", "rank", "knight",
bitboard_print_multi(str, 5, "king"
sq_bbfile[i] | sq_bbrank[i] | sq_bbdiag[i] | sq_bbanti[i], );
sq_bbfile[i], sq_bbrank[i], bitboard_print_multi(str, 7,
sq_bbdiag[i], sq_bbanti[i]); bb_file[i] | bb_rank[i] |
} bb_diagonal[i] | bb_antidiagonal[i],
for (square_t sq = 0; sq < 64; ++sq) { bb_diagonal[i], bb_antidiagonal[i],
sprintf(str, "%2d %#lx %#lx knight", sq, sq_bb[sq], knight_attacks[sq]); bb_file[i], bb_rank[i],
bitboard_print(str, knight_attacks[sq]); bb_knight[i], bb_king[i]);
sprintf(str, "%2d %#lx %#lx knight", sq, sq_bb[sq], king_attacks[sq]);
bitboard_print(str, king_attacks[sq]);
} }
/*
* for (square_t sq = 0; sq < 64; ++sq) {
* sprintf(str, "%2d %#lx %#lx knight", sq, bb_sq[sq], bb_knight[sq]);
* bitboard_print(str, bb_knight[sq]);
* sprintf(str, "%2d %#lx %#lx knight", sq, bb_sq[sq], bb_king[sq]);
* bitboard_print(str, bb_king[sq]);
* }
*/
return 0; return 0;
} }

2
test/fen-test.c
View File

@@ -12,7 +12,7 @@ int main(int ac, char**av)
char revfen[128]; char revfen[128];
int comp; int comp;
debug_init(5, stderr, true); //debug_init(5, stderr, true);
//pos_pool_init(); //pos_pool_init();
pos = pos_new(); pos = pos_new();
if (ac == 1) { if (ac == 1) {