int board_opening(const board_t * board) {
int opening;
int colour;
const sq_t * ptr;
int sq, piece;
ASSERT(board!=NULL);
opening = 0;
for (colour = 0; colour < ColourNb; colour++) {
for (ptr = &board->piece[colour][0]; (sq=*ptr) != SquareNone; ptr++) {
piece = board->square[sq];
opening += PST(PIECE_TO_12(piece),SQUARE_TO_64(sq),Opening);
}
for (ptr = &board->pawn[colour][0]; (sq=*ptr) != SquareNone; ptr++) {
piece = board->square[sq];
opening += PST(PIECE_TO_12(piece),SQUARE_TO_64(sq),Opening);
}
}
return opening;
}
int board_endgame(const board_t * board) {
int endgame;
int colour;
const sq_t * ptr;
int sq, piece;
ASSERT(board!=NULL);
endgame = 0;
for (colour = 0; colour < ColourNb; colour++) {
for (ptr = &board->piece[colour][0]; (sq=*ptr) != SquareNone; ptr++) {
piece = board->square[sq];
endgame += PST(PIECE_TO_12(piece),SQUARE_TO_64(sq),Endgame);
}
for (ptr = &board->pawn[colour][0]; (sq=*ptr) != SquareNone; ptr++) {
piece = board->square[sq];
endgame += PST(PIECE_TO_12(piece),SQUARE_TO_64(sq),Endgame);
}
}
return endgame;
}
bool TEngine::Eval(board_t * Board, TFindPos * fp)
{
const sq_t * ptr;
int from;
TFindPos fp_board(0,0);
for (int colour = 0; colour < ColourNb; colour++) {
for (ptr = &Board->piece[colour][0]; (from=*ptr) != SquareNone; ptr++)
fp_board.SetBit(colour,SQUARE_TO_64(from));
for (ptr = &Board->pawn[colour][0]; (from=*ptr) != SquareNone; ptr++) {
fp_board.SetBit(colour,SQUARE_TO_64(from));
}
}
return !memcmp(fp,&fp_board,sizeof (TFindPos));
}
U64 hash_piece_key(S32 piece, S32 square) {
ASSERT(piece_is_ok(piece));
ASSERT(SQUARE_IS_OK(square));
return RANDOM_64(RandomPiece + (PIECE_TO_12(piece) ^ 1) * 64 + SQUARE_TO_64(square)); // HACK: ^1 for PolyGlot book
}
void move_eval(const board_t * board, int eval) {
int index;
int best_value, value;
int move;
ASSERT(board!=NULL);
ASSERT(value_is_ok(eval));
move = board->move;
ASSERT(move_is_ok(move));
// exceptions
if ((move & (1 << 15)) != 0) return;
if (MOVE_TO(move) == board->cap_sq) return;
if (MOVE_IS_CASTLE(move)) return;
ASSERT(!MOVE_IS_PROMOTE(move));
ASSERT(!MOVE_IS_EN_PASSANT(move));
ASSERT(board->cap_sq==Empty);
ASSERT(!board_is_check(board));
index = PIECE_TO_12(board->square[MOVE_TO(move)]) * 64 + SQUARE_TO_64(MOVE_TO(move));
ASSERT(index>=0&&index<HistorySize);
if (eval > ValueQueen) {
value = ValueQueen;
} else if (eval < -ValueQueen) {
value = -ValueQueen;
} else {
value = eval;
}
best_value = HistEval[index];
ASSERT(best_value<=HistoryEvalMax);
ASSERT(best_value>=-HistoryEvalMax);
if (value >= best_value) {
if (value == HistoryEvalValue) value++;
HistEval[index] = value;
} else {
if (HistEval[index] > -ValueQueen) {
if (best_value == HistoryEvalValue+1) {
HistEval[index] -= 2;
} else {
HistEval[index]--;
}
}
}
ASSERT(HistEval[index]!=HistoryEvalValue);
ASSERT(HistEval[index]<=HistoryEvalMax);
ASSERT(HistEval[index]>=-HistoryEvalMax);
}
static int history_index(int move, const board_t * board) {
int index;
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
ASSERT(!MOVE_IS_TACTICAL(move,board));
index = PIECE_TO_12(board->square[MOVE_FROM(move)]) * 64 + SQUARE_TO_64(MOVE_TO(move));
ASSERT(index>=0&&index<HistorySize);
return index;
}
static unsigned int history_index(int move, const board_t * board) {
unsigned int index;
int move_from = MOVE_FROM(move);
int piece_12 = PIECE_TO_12(board->square[move_from]);
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
ASSERT(!move_is_tactical(move,board));
// index = PIECE_TO_12(board->square[MOVE_FROM(move)]) * 64 + SQUARE_TO_64(MOVE_TO(move)); fruit 2.1
// index = PIECE_TO_12(board->square[MOVE_FROM(move)]) * (64*64) + SQUARE_TO_64(MOVE_FROM(move)) * 64 + SQUARE_TO_64(MOVE_TO(move)); Toga II 1.2.1 (corrected?).
index = 64 * piece_12 + SQUARE_TO_64(MOVE_TO(move)); // fruit 2.1 and Toga II 1.4beta5c
ASSERT(index >= 0 && index < HistorySize);
return index;
}
void history_very_bad(int move, const board_t * board) {
int index;
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
//if (move_is_tactical(move,board)) return;
// history
index = PIECE_TO_12(board->square[MOVE_TO(move)]) * 64 + SQUARE_TO_64(MOVE_TO(move));
HistTot[index] += 100;
if (HistTot[index] >= HistoryMax) {
HistHit[index] = (HistHit[index] + 1) / 2;
HistTot[index] = (HistTot[index] + 1) / 2;
}
ASSERT(HistHit[index]<=HistTot[index]);
ASSERT(HistTot[index]<HistoryMax);
}
static void square_move(board_t * board, int from, int to, int piece, bool update) {
int colour;
int pos;
int from_64, to_64;
int piece_12;
int piece_index;
uint64 hash_xor;
ASSERT(board!=NULL);
ASSERT(SQUARE_IS_OK(from));
ASSERT(SQUARE_IS_OK(to));
ASSERT(piece_is_ok(piece));
ASSERT(update==true||update==false);
// init
colour = PIECE_COLOUR(piece);
pos = board->pos[from];
ASSERT(pos>=0);
// from
ASSERT(board->square[from]==piece);
board->square[from] = Empty;
ASSERT(board->pos[from]==pos);
board->pos[from] = -1; // not needed
// to
ASSERT(board->square[to]==Empty);
board->square[to] = piece;
ASSERT(board->pos[to]==-1);
board->pos[to] = pos;
// piece list
if (!PIECE_IS_PAWN(piece)) {
ASSERT(board->piece[colour][pos]==from);
board->piece[colour][pos] = to;
} else {
ASSERT(board->pawn[colour][pos]==from);
board->pawn[colour][pos] = to;
// pawn "bitboard"
board->pawn_file[colour][SQUARE_FILE(from)] ^= BIT(PAWN_RANK(from,colour));
board->pawn_file[colour][SQUARE_FILE(to)] ^= BIT(PAWN_RANK(to,colour));
}
// update
if (update) {
// init
from_64 = SQUARE_TO_64(from);
to_64 = SQUARE_TO_64(to);
piece_12 = PIECE_TO_12(piece);
// PST
board->opening += PST(piece_12,to_64,Opening) - PST(piece_12,from_64,Opening);
board->endgame += PST(piece_12,to_64,Endgame) - PST(piece_12,from_64,Endgame);
// hash key
piece_index = RandomPiece + (piece_12^1) * 64; // HACK: ^1 for PolyGlot book
hash_xor = RANDOM_64(piece_index+to_64) ^ RANDOM_64(piece_index+from_64);
board->key ^= hash_xor;
if (PIECE_IS_PAWN(piece)) board->pawn_key ^= hash_xor;
}
}
static void square_set(board_t * board, int square, int piece, int pos, bool update) {
int piece_12, colour;
int sq;
int i, size;
int sq_64;
uint64 hash_xor;
ASSERT(board!=NULL);
ASSERT(SQUARE_IS_OK(square));
ASSERT(piece_is_ok(piece));
ASSERT(pos>=0);
ASSERT(update==true||update==false);
// init
piece_12 = PIECE_TO_12(piece);
colour = PIECE_COLOUR(piece);
// square
ASSERT(board->square[square]==Empty);
board->square[square] = piece;
// piece list
if (!PIECE_IS_PAWN(piece)) {
// init
size = board->piece_size[colour];
ASSERT(size>=0);
// size
size++;
board->piece[colour][size] = SquareNone;
board->piece_size[colour] = size;
// stable swap
ASSERT(pos>=0&&pos<size);
for (i = size-1; i > pos; i--) {
sq = board->piece[colour][i-1];
board->piece[colour][i] = sq;
ASSERT(board->pos[sq]==i-1);
board->pos[sq] = i;
}
board->piece[colour][pos] = square;
ASSERT(board->pos[square]==-1);
board->pos[square] = pos;
} else {
// init
size = board->pawn_size[colour];
ASSERT(size>=0);
// size
size++;
board->pawn[colour][size] = SquareNone;
board->pawn_size[colour] = size;
// stable swap
ASSERT(pos>=0&&pos<size);
for (i = size-1; i > pos; i--) {
sq = board->pawn[colour][i-1];
board->pawn[colour][i] = sq;
ASSERT(board->pos[sq]==i-1);
board->pos[sq] = i;
}
board->pawn[colour][pos] = square;
ASSERT(board->pos[square]==-1);
board->pos[square] = pos;
// pawn "bitboard"
board->pawn_file[colour][SQUARE_FILE(square)] ^= BIT(PAWN_RANK(square,colour));
}
// material
ASSERT(board->piece_nb<32);
board->piece_nb++;;
ASSERT(board->number[piece_12]<9);
board->number[piece_12]++;
// update
if (update) {
// init
sq_64 = SQUARE_TO_64(square);
// PST
board->opening += PST(piece_12,sq_64,Opening);
board->endgame += PST(piece_12,sq_64,Endgame);
// hash key
hash_xor = RANDOM_64(RandomPiece+(piece_12^1)*64+sq_64); // HACK: ^1 for PolyGlot book
board->key ^= hash_xor;
if (PIECE_IS_PAWN(piece)) board->pawn_key ^= hash_xor;
// material key
board->material_key ^= RANDOM_64(piece_12*16+(board->number[piece_12]-1));
}
}
static void pawn_comp_info(pawn_info_t * info, const board_t * board) {
int colour;
int file, rank;
int me, opp;
const sq_t * ptr;
int sq;
bool backward, candidate, doubled, isolated, open, passed;
int t1, t2;
int n;
int bits;
int opening[ColourNb], endgame[ColourNb];
int flags[ColourNb];
int file_bits[ColourNb];
int passed_bits[ColourNb];
int single_file[ColourNb];
ASSERT(info!=NULL);
ASSERT(board!=NULL);
// pawn_file[]
#if DEBUG
for (colour = 0; colour < ColourNb; colour++) {
int pawn_file[FileNb];
me = colour;
for (file = 0; file < FileNb; file++) {
pawn_file[file] = 0;
}
for (ptr = &board->pawn[me][0]; (sq=*ptr) != SquareNone; ptr++) {
file = SQUARE_FILE(sq);
rank = PAWN_RANK(sq,me);
ASSERT(file>=FileA&&file<=FileH);
ASSERT(rank>=Rank2&&rank<=Rank7);
pawn_file[file] |= BIT(rank);
}
for (file = 0; file < FileNb; file++) {
if (board->pawn_file[colour][file] != pawn_file[file]) my_fatal("board->pawn_file[][]\n");
}
}
#endif
// init
for (colour = 0; colour < ColourNb; colour++) {
opening[colour] = 0;
endgame[colour] = 0;
flags[colour] = 0;
file_bits[colour] = 0;
passed_bits[colour] = 0;
single_file[colour] = SquareNone;
}
// features and scoring
for (colour = 0; colour < ColourNb; colour++) {
me = colour;
opp = COLOUR_OPP(me);
for (ptr = &board->pawn[me][0]; (sq=*ptr) != SquareNone; ptr++) {
// init
file = SQUARE_FILE(sq);
rank = PAWN_RANK(sq,me);
ASSERT(file>=FileA&&file<=FileH);
ASSERT(rank>=Rank2&&rank<=Rank7);
// flags
file_bits[me] |= BIT(file);
if (rank == Rank2) flags[me] |= BackRankFlag;
// features
backward = false;
candidate = false;
doubled = false;
isolated = false;
open = false;
passed = false;
t1 = board->pawn_file[me][file-1] | board->pawn_file[me][file+1];
t2 = board->pawn_file[me][file] | BitRev[board->pawn_file[opp][file]];
// doubled
if ((board->pawn_file[me][file] & BitLT[rank]) != 0) {
doubled = true;
}
// isolated and backward
if (t1 == 0) {
isolated = true;
} else if ((t1 & BitLE[rank]) == 0) {
backward = true;
// really backward?
if ((t1 & BitRank1[rank]) != 0) {
ASSERT(rank+2<=Rank8);
if (((t2 & BitRank1[rank])
| ((BitRev[board->pawn_file[opp][file-1]] | BitRev[board->pawn_file[opp][file+1]]) & BitRank2[rank])) == 0) {
backward = false;
}
} else if (rank == Rank2 && ((t1 & BitEQ[rank+2]) != 0)) {
ASSERT(rank+3<=Rank8);
if (((t2 & BitRank2[rank])
| ((BitRev[board->pawn_file[opp][file-1]] | BitRev[board->pawn_file[opp][file+1]]) & BitRank3[rank])) == 0) {
backward = false;
}
}
}
// open, candidate and passed
if ((t2 & BitGT[rank]) == 0) {
open = true;
if (((BitRev[board->pawn_file[opp][file-1]] | BitRev[board->pawn_file[opp][file+1]]) & BitGT[rank]) == 0) {
passed = true;
passed_bits[me] |= BIT(file);
} else {
// candidate?
n = 0;
n += BIT_COUNT(board->pawn_file[me][file-1]&BitLE[rank]);
n += BIT_COUNT(board->pawn_file[me][file+1]&BitLE[rank]);
n -= BIT_COUNT(BitRev[board->pawn_file[opp][file-1]]&BitGT[rank]);
n -= BIT_COUNT(BitRev[board->pawn_file[opp][file+1]]&BitGT[rank]);
if (n >= 0) {
// safe?
n = 0;
n += BIT_COUNT(board->pawn_file[me][file-1]&BitEQ[rank-1]);
n += BIT_COUNT(board->pawn_file[me][file+1]&BitEQ[rank-1]);
n -= BIT_COUNT(BitRev[board->pawn_file[opp][file-1]]&BitEQ[rank+1]);
n -= BIT_COUNT(BitRev[board->pawn_file[opp][file+1]]&BitEQ[rank+1]);
if (n >= 0) candidate = true;
}
}
}
// outposts
if (me == White) {
if (SQUARE_IS_OK(sq+15)) {
if (WEAK_SQUARE_BLACK(sq+15)) opening[White] += OutpostMatrix[White][SQUARE_TO_64(sq+15)];
else opening[White] += (OutpostMatrix[White][SQUARE_TO_64(sq+15)]+1)/2;
}
if (SQUARE_IS_OK(sq+17)) {
if (WEAK_SQUARE_BLACK(sq+17)) opening[White] += OutpostMatrix[White][SQUARE_TO_64(sq+17)];
else opening[White] += (OutpostMatrix[White][SQUARE_TO_64(sq+17)]+1)/2;
}
} else {
if (SQUARE_IS_OK(sq-15)) {
if (WEAK_SQUARE_WHITE(sq-15)) opening[Black] += OutpostMatrix[Black][SQUARE_TO_64(sq-15)];
else opening[Black] += (OutpostMatrix[Black][SQUARE_TO_64(sq-15)]+1)/2;
}
if (SQUARE_IS_OK(sq-17)) {
if (WEAK_SQUARE_WHITE(sq-17)) opening[Black] += OutpostMatrix[Black][SQUARE_TO_64(sq-17)];
else opening[Black] += (OutpostMatrix[Black][SQUARE_TO_64(sq-17)]+1)/2;
}
}
// score
if (doubled) {
opening[me] -= DoubledOpening;
endgame[me] -= DoubledEndgame;
}
if (isolated) {
if (open) {
opening[me] -= IsolatedOpeningOpen;
endgame[me] -= IsolatedEndgame;
} else {
opening[me] -= IsolatedOpening;
endgame[me] -= IsolatedEndgame;
}
}
if (backward) {
if (open) {
opening[me] -= BackwardOpeningOpen;
endgame[me] -= BackwardEndgame;
} else {
opening[me] -= BackwardOpening;
endgame[me] -= BackwardEndgame;
}
}
if (candidate) {
opening[me] += quad(CandidateOpeningMin,CandidateOpeningMax,rank);
endgame[me] += quad(CandidateEndgameMin,CandidateEndgameMax,rank);
}
// this was moved to the dynamic evaluation
/*
if (passed) {
opening[me] += quad(PassedOpeningMin,PassedOpeningMax,rank);
endgame[me] += quad(PassedEndgameMin,PassedEndgameMax,rank);
}
*/
}
}
// store info
info->opening = ((opening[White] - opening[Black]) * PawnStructureWeight) / 256;
info->endgame = ((endgame[White] - endgame[Black]) * PawnStructureWeight) / 256;
for (colour = 0; colour < ColourNb; colour++) {
me = colour;
opp = COLOUR_OPP(me);
// draw flags
bits = file_bits[me];
if (bits != 0 && (bits & (bits-1)) == 0) { // one set bit
file = BIT_FIRST(bits);
rank = BIT_FIRST(board->pawn_file[me][file]);
ASSERT(rank>=Rank2);
if (((BitRev[board->pawn_file[opp][file-1]] | BitRev[board->pawn_file[opp][file+1]]) & BitGT[rank]) == 0) {
rank = BIT_LAST(board->pawn_file[me][file]);
single_file[me] = SQUARE_MAKE(file,rank);
}
}
info->flags[colour] = flags[colour];
info->passed_bits[colour] = passed_bits[colour];
info->single_file[colour] = single_file[colour];
}
}
static void square_clear(board_t * board, int square, int piece, bool update) {
int pos, piece_12, colour;
int sq;
int i, size;
int sq_64;
uint64 hash_xor;
ASSERT(board!=NULL);
ASSERT(SQUARE_IS_OK(square));
ASSERT(piece_is_ok(piece));
ASSERT(update==true||update==false);
// init
pos = board->pos[square];
ASSERT(pos>=0);
piece_12 = PIECE_TO_12(piece);
colour = PIECE_COLOUR(piece);
// square
ASSERT(board->square[square]==piece);
board->square[square] = Empty;
// piece list
if (!PIECE_IS_PAWN(piece)) {
// init
size = board->piece_size[colour];
ASSERT(size>=1);
// stable swap
ASSERT(pos>=0&&pos<size);
ASSERT(board->pos[square]==pos);
board->pos[square] = -1;
for (i = pos; i < size-1; i++) {
sq = board->piece[colour][i+1];
board->piece[colour][i] = sq;
ASSERT(board->pos[sq]==i+1);
board->pos[sq] = i;
}
// size
size--;
board->piece[colour][size] = SquareNone;
board->piece_size[colour] = size;
} else {
// init
size = board->pawn_size[colour];
ASSERT(size>=1);
// stable swap
ASSERT(pos>=0&&pos<size);
ASSERT(board->pos[square]==pos);
board->pos[square] = -1;
for (i = pos; i < size-1; i++) {
sq = board->pawn[colour][i+1];
board->pawn[colour][i] = sq;
ASSERT(board->pos[sq]==i+1);
board->pos[sq] = i;
}
// size
size--;
board->pawn[colour][size] = SquareNone;
board->pawn_size[colour] = size;
// pawn "bitboard"
board->pawn_file[colour][SQUARE_FILE(square)] ^= BIT(PAWN_RANK(square,colour));
}
// material
ASSERT(board->piece_nb>0);
board->piece_nb--;
ASSERT(board->number[piece_12]>0);
board->number[piece_12]--;
board->piece_material[colour] -= VALUE_PIECE(piece); // Thomas
// update
if (update) {
// init
sq_64 = SQUARE_TO_64(square);
// PST
board->opening -= PST(piece_12,sq_64,Opening);
board->endgame -= PST(piece_12,sq_64,Endgame);
// hash key
hash_xor = RANDOM_64(RandomPiece+(piece_12^1)*64+sq_64); // HACK: ^1 for PolyGlot book
board->key ^= hash_xor;
if (PIECE_IS_PAWN(piece)) board->pawn_key ^= hash_xor;
// material key
board->material_key ^= RANDOM_64(piece_12*16+board->number[piece_12]);
}
}
bool egbb_probe(const board_t * board, int * value) {
int i;
int sq;
int piece;
int colour, me;
const sq_t * ptr;
int counter;
int white_king, black_king;
int piece_list[4], square_list[4];
ASSERT(board!=NULL);
ASSERT(value!=NULL);
ASSERT(board_is_ok(board));
ASSERT(!board_is_check(board));
// init
if (Egbb->init == 0) return false;
if (Egbb->load == 0) return false;
ASSERT(board->piece_nb<=Egbb->piece_nb);
// init
for (i = 0; i < 4; i++) {
piece_list[i] = 0;
square_list[i] = 0;
}
Egbb->read_nb++;
// king
white_king = SQUARE_TO_64(KING_POS(board,White));
black_king = SQUARE_TO_64(KING_POS(board,Black));
counter = 0;
for (colour = 0; colour < ColourNb; colour++) {
me = colour;
// pieces
for (ptr = &board->piece[me][1]; (sq=*ptr) != SquareNone; ptr++) { // HACK: no king
piece = board->square[sq];
// index
ASSERT(counter>=0&&counter<4);
piece_list[counter] = TbPiece[PIECE_TO_12(piece)];
square_list[counter] = SQUARE_TO_64(sq);
counter++;
}
// pawns
for (ptr = &board->pawn[me][0]; (sq=*ptr) != SquareNone; ptr++) {
piece = board->square[sq];
// index
ASSERT(counter>=0&&counter<4);
piece_list[counter] = TbPiece[PIECE_TO_12(piece)];
square_list[counter] = SQUARE_TO_64(sq);
counter++;
}
}
// probe
*value = probe_egbb_ptr(board->turn,white_king,black_king,piece_list[0],square_list[0],piece_list[1],square_list[1],piece_list[2],square_list[2]);
// score
if (*value != ValueError) {
Egbb->read_hit++;
ASSERT(!value_is_mate(*value));
return true;
}
return false;
}