Bitboard ClearMaskBB[65];
Bitboard StepAttackBB[16][64];
-Bitboard RayBB[64][8];
Bitboard BetweenBB[64][64];
Bitboard SquaresInFrontMask[2][64];
namespace {
void init_masks();
- void init_ray_bitboards();
void init_attacks();
void init_between_bitboards();
void init_pseudo_attacks();
int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
init_masks();
- init_ray_bitboards();
init_attacks();
init_between_bitboards();
init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
}
- int remove_bit_8(int i) { return ((i & ~15) >> 1) | (i & 7); }
-
- void init_ray_bitboards() {
-
- int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
-
- for (int i = 0; i < 128; i = (i + 9) & ~8)
- for (int j = 0; j < 8; j++)
- {
- RayBB[remove_bit_8(i)][j] = EmptyBoardBB;
- for (int k = i + d[j]; (k & 0x88) == 0; k += d[j])
- set_bit(&(RayBB[remove_bit_8(i)][j]), Square(remove_bit_8(k)));
- }
- }
-
void init_attacks() {
const int step[16][8] = {
void init_between_bitboards() {
- const SquareDelta step[8] = { DELTA_E, DELTA_W, DELTA_N, DELTA_S,
- DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE };
+ const SquareDelta directionToDelta[] = {
+ DELTA_E, DELTA_N, DELTA_NE, DELTA_NW, DELTA_W, DELTA_S, DELTA_SW, DELTA_SE
+ };
+
+ Square s1, s2, s3;
+ Direction d;
- for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
- for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+ for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
+ for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
{
BetweenBB[s1][s2] = EmptyBoardBB;
- SignedDirection d = SignedDirection(SignedDirectionTable[s1][s2]);
+ d = direction_between_squares(s1, s2);
- if (d != SIGNED_DIR_NONE)
- {
- for (Square s3 = s1 + step[d]; s3 != s2; s3 += step[d])
- set_bit(&(BetweenBB[s1][s2]), s3);
- }
+ if (d == DIR_NONE)
+ continue;
+
+ SquareDelta sd = directionToDelta[s2 > s1 ? d : d + 4];
+
+ for (s3 = s1 + sd; s3 != s2; s3 += sd)
+ set_bit(&(BetweenBB[s1][s2]), s3);
}
}
extern Bitboard ClearMaskBB[65];
extern Bitboard StepAttackBB[16][64];
-extern Bitboard RayBB[64][8];
extern Bitboard BetweenBB[64][64];
extern Bitboard SquaresInFrontMask[2][64];
}
-/// ray_bb() gives a bitboard representing all squares along the ray in a
-/// given direction from a given square.
-
-inline Bitboard ray_bb(Square s, SignedDirection d) {
- return RayBB[s][d];
-}
-
-
/// Functions for computing sliding attack bitboards. rook_attacks_bb(),
/// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
/// bitboard of occupied squares as input, and return a bitboard representing
#include "square.h"
+uint8_t DirectionTable[64][64];
-////
-//// Local definitions
-////
-namespace {
+static bool reachable(Square orig, Square dest, Direction d) {
const SquareDelta directionToDelta[] = {
- DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
+ DELTA_E, DELTA_N, DELTA_NE, DELTA_NW, DELTA_W, DELTA_S, DELTA_SW, DELTA_SE
};
- bool reachable(Square orig, Square dest, SignedDirection dir) {
-
- SquareDelta delta = directionToDelta[dir];
- Square from = orig;
- Square to = from + delta;
- while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
- {
- from = to;
- to += delta;
- }
- return (to == dest && square_distance(from, to) == 1);
- }
+ SquareDelta delta = directionToDelta[dest > orig ? d : d + 4];
+ Square from = orig;
+ Square to = from + delta;
+ while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
+ {
+ from = to;
+ to += delta;
+ }
+ return to == dest && square_distance(from, to) == 1;
}
-
-////
-//// Variables
-////
-
-uint8_t DirectionTable[64][64];
-uint8_t SignedDirectionTable[64][64];
-
-
-////
-//// Functions
-////
-
void init_direction_table() {
for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
{
DirectionTable[s1][s2] = uint8_t(DIR_NONE);
- SignedDirectionTable[s1][s2] = uint8_t(SIGNED_DIR_NONE);
+
if (s1 == s2)
continue;
- for (SignedDirection d = SIGNED_DIR_E; d != SIGNED_DIR_NONE; d++)
+ for (Direction d = DIR_E; d != DIR_NONE; d++)
{
if (reachable(s1, s2, d))
{
- SignedDirectionTable[s1][s2] = uint8_t(d);
- DirectionTable[s1][s2] = uint8_t(d / 2);
+ DirectionTable[s1][s2] = uint8_t(d);
break;
}
}
return SCALE_FACTOR_ZERO;
else
{
- Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S);
- if (ray & pos.pieces(KING, weakerSide))
+ Bitboard path = squares_in_front_of(strongerSide, pawnSq);
+
+ if (path & pos.pieces(KING, weakerSide))
return SCALE_FACTOR_ZERO;
- if ( (pos.attacks_from<BISHOP>(weakerBishopSq) & ray)
+ if ( (pos.attacks_from<BISHOP>(weakerBishopSq) & path)
&& square_distance(weakerBishopSq, pawnSq) >= 3)
return SCALE_FACTOR_ZERO;
}
DIR_E = 0, DIR_N = 1, DIR_NE = 2, DIR_NW = 3, DIR_NONE = 4
};
-enum SignedDirection {
- SIGNED_DIR_E = 0, SIGNED_DIR_W = 1,
- SIGNED_DIR_N = 2, SIGNED_DIR_S = 3,
- SIGNED_DIR_NE = 4, SIGNED_DIR_SW = 5,
- SIGNED_DIR_NW = 6, SIGNED_DIR_SE = 7,
- SIGNED_DIR_NONE = 8
-};
ENABLE_OPERATORS_ON(Square);
ENABLE_OPERATORS_ON(File);
ENABLE_OPERATORS_ON(Rank);
ENABLE_OPERATORS_ON(SquareDelta);
-ENABLE_OPERATORS_ON(SignedDirection);
+ENABLE_OPERATORS_ON(Direction);
////
const int FlopMask = 7;
extern uint8_t DirectionTable[64][64];
-extern uint8_t SignedDirectionTable[64][64];
////