1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23:09 +00:00

Retire SignedDirectionTable[] and RayBB[]

Function ray_bb() was used just in one endgame where can
be used squares_in_front_of() instead.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-12-26 11:58:48 +01:00
parent 6080fecf9c
commit f08a6eed0d
5 changed files with 35 additions and 82 deletions

View file

@ -225,7 +225,6 @@ Bitboard SetMaskBB[65];
Bitboard ClearMaskBB[65]; Bitboard ClearMaskBB[65];
Bitboard StepAttackBB[16][64]; Bitboard StepAttackBB[16][64];
Bitboard RayBB[64][8];
Bitboard BetweenBB[64][64]; Bitboard BetweenBB[64][64];
Bitboard SquaresInFrontMask[2][64]; Bitboard SquaresInFrontMask[2][64];
@ -246,7 +245,6 @@ uint8_t BitCount8Bit[256];
namespace { namespace {
void init_masks(); void init_masks();
void init_ray_bitboards();
void init_attacks(); void init_attacks();
void init_between_bitboards(); void init_between_bitboards();
void init_pseudo_attacks(); void init_pseudo_attacks();
@ -288,7 +286,6 @@ void init_bitboards() {
int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}}; int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
init_masks(); init_masks();
init_ray_bitboards();
init_attacks(); init_attacks();
init_between_bitboards(); init_between_bitboards();
init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas); init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
@ -406,21 +403,6 @@ namespace {
BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b); 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() { void init_attacks() {
const int step[16][8] = { const int step[16][8] = {
@ -473,20 +455,26 @@ namespace {
void init_between_bitboards() { void init_between_bitboards() {
const SquareDelta step[8] = { DELTA_E, DELTA_W, DELTA_N, DELTA_S, const SquareDelta directionToDelta[] = {
DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE }; DELTA_E, DELTA_N, DELTA_NE, DELTA_NW, DELTA_W, DELTA_S, DELTA_SW, DELTA_SE
};
for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++) Square s1, s2, s3;
for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++) Direction d;
for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
{ {
BetweenBB[s1][s2] = EmptyBoardBB; BetweenBB[s1][s2] = EmptyBoardBB;
SignedDirection d = SignedDirection(SignedDirectionTable[s1][s2]); d = direction_between_squares(s1, s2);
if (d != SIGNED_DIR_NONE) if (d == DIR_NONE)
{ continue;
for (Square s3 = s1 + step[d]; s3 != s2; s3 += step[d])
set_bit(&(BetweenBB[s1][s2]), s3); SquareDelta sd = directionToDelta[s2 > s1 ? d : d + 4];
}
for (s3 = s1 + sd; s3 != s2; s3 += sd)
set_bit(&(BetweenBB[s1][s2]), s3);
} }
} }

View file

@ -67,7 +67,6 @@ extern Bitboard SetMaskBB[65];
extern Bitboard ClearMaskBB[65]; extern Bitboard ClearMaskBB[65];
extern Bitboard StepAttackBB[16][64]; extern Bitboard StepAttackBB[16][64];
extern Bitboard RayBB[64][8];
extern Bitboard BetweenBB[64][64]; extern Bitboard BetweenBB[64][64];
extern Bitboard SquaresInFrontMask[2][64]; extern Bitboard SquaresInFrontMask[2][64];
@ -208,14 +207,6 @@ inline Bitboard behind_bb(Color c, Square s) {
} }
/// 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(), /// Functions for computing sliding attack bitboards. rook_attacks_bb(),
/// bishop_attacks_bb() and queen_attacks_bb() all take a square and a /// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
/// bitboard of occupied squares as input, and return a bitboard representing /// bitboard of occupied squares as input, and return a bitboard representing

View file

@ -24,61 +24,42 @@
#include "square.h" #include "square.h"
uint8_t DirectionTable[64][64];
////
//// Local definitions
////
namespace { static bool reachable(Square orig, Square dest, Direction d) {
const SquareDelta directionToDelta[] = { 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[dest > orig ? d : d + 4];
Square from = orig;
Square to = from + delta;
SquareDelta delta = directionToDelta[dir]; while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
Square from = orig; {
Square to = from + delta; from = to;
while (to != dest && square_distance(to, from) == 1 && square_is_ok(to)) to += delta;
{
from = to;
to += delta;
}
return (to == dest && square_distance(from, to) == 1);
} }
return to == dest && square_distance(from, to) == 1;
} }
////
//// Variables
////
uint8_t DirectionTable[64][64];
uint8_t SignedDirectionTable[64][64];
////
//// Functions
////
void init_direction_table() { void init_direction_table() {
for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++) for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++) for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
{ {
DirectionTable[s1][s2] = uint8_t(DIR_NONE); DirectionTable[s1][s2] = uint8_t(DIR_NONE);
SignedDirectionTable[s1][s2] = uint8_t(SIGNED_DIR_NONE);
if (s1 == s2) if (s1 == s2)
continue; 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)) if (reachable(s1, s2, d))
{ {
SignedDirectionTable[s1][s2] = uint8_t(d); DirectionTable[s1][s2] = uint8_t(d);
DirectionTable[s1][s2] = uint8_t(d / 2);
break; break;
} }
} }

View file

@ -699,11 +699,12 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const {
return SCALE_FACTOR_ZERO; return SCALE_FACTOR_ZERO;
else else
{ {
Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S); Bitboard path = squares_in_front_of(strongerSide, pawnSq);
if (ray & pos.pieces(KING, weakerSide))
if (path & pos.pieces(KING, weakerSide))
return SCALE_FACTOR_ZERO; return SCALE_FACTOR_ZERO;
if ( (pos.attacks_from<BISHOP>(weakerBishopSq) & ray) if ( (pos.attacks_from<BISHOP>(weakerBishopSq) & path)
&& square_distance(weakerBishopSq, pawnSq) >= 3) && square_distance(weakerBishopSq, pawnSq) >= 3)
return SCALE_FACTOR_ZERO; return SCALE_FACTOR_ZERO;
} }

View file

@ -72,19 +72,12 @@ enum Direction {
DIR_E = 0, DIR_N = 1, DIR_NE = 2, DIR_NW = 3, DIR_NONE = 4 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(Square);
ENABLE_OPERATORS_ON(File); ENABLE_OPERATORS_ON(File);
ENABLE_OPERATORS_ON(Rank); ENABLE_OPERATORS_ON(Rank);
ENABLE_OPERATORS_ON(SquareDelta); ENABLE_OPERATORS_ON(SquareDelta);
ENABLE_OPERATORS_ON(SignedDirection); ENABLE_OPERATORS_ON(Direction);
//// ////
@ -95,7 +88,6 @@ const int FlipMask = 56;
const int FlopMask = 7; const int FlopMask = 7;
extern uint8_t DirectionTable[64][64]; extern uint8_t DirectionTable[64][64];
extern uint8_t SignedDirectionTable[64][64];
//// ////