I checked CPW to see whether there is anything similar. Apparently, this would be a modification of the Dumb7fill method. The difference is that I do attacks in all directions in parallel, including the queen (with a little trick).

The method assume that we have a table

**uint64_t reach [MAXPIECES] [MAXSQUARES];**

where each bitboard there represents the attacks of a given slider from a given square in an empty board. I generate the table at start up with a 0x88 procedure , but it is small enough to hardwire it into the program.

You can replace this with

**uint64_t reach_bishop [64];**

uint64_t reach_queen [64];

uint64_t reach_rook [64];

uint64_t reach_queen [64];

uint64_t reach_rook [64];

That is about ~1.5 k

The code below is optimized for (my) readability, so I am sure that it could be improved. At least in my engine, unrolling the loops slow things down.

Miguel

PS: I hope that the code is self-explanatory.

Code: Select all

```
/* not_A is a bitboard with all bits turned on except on column A */
/* not_H is a bitboard with all bits turned on except on column H */
/* grow in all directions */
static uint64_t
grow (uint64_t x)
{
x |= (x << 1) & not_A;
x |= (x >> 1) & not_H;
x |= x >> 8;
x |= x << 8;
return x;
}
/* grow laterally like a rook */
static uint64_t
growlat (uint64_t x)
{
uint64_t y = x;
x |= (x << 1) & not_A;
x |= (x >> 1) & not_H;
y |= y >> 8;
y |= y << 8;
return x | y;
}
extern uint64_t
B_attacks (SQUARE from, uint64_t occ)
{
uint64_t g, corral, prev, r, ini;
r = reach[BISHOP][from];
corral = r & ~occ;
ini = U64(1) << from;
g = ini;
do {
prev = g;
g = grow (prev) & corral;
} while (prev != g);
g |= ini;
return (grow(g) & r) & ~ini;
}
extern uint64_t
R_attacks (SQUARE from, uint64_t occ)
{
uint64_t g, corral, prev, r, ini;
r = reach[ROOK][from];
corral = r & ~occ;
ini = U64(1) << from;
g = ini;
do {
prev = g;
g = grow (prev) & corral;
} while (prev != g);
g |= ini;
return (grow(g) & r) & ~ini;
}
extern uint64_t
Q_attacks (SQUARE from, uint64_t occ)
{
uint64_t g, corral, prev, r, ini, h;
r = reach[QUEEN][from];
ini = U64(1) << from;
g = grow (ini) & ~ini;
h = growlat (g & occ);
h &= ~g;
corral = r & ~occ;
corral &= ~h;
g &= ~occ;
do {
prev = g;
g = grow (prev) & corral;
} while (prev != g);
g |= ini;
return (grow(g) & r) & ~ini & ~h ;
}
```