static void note_quiet_moves(list_t * list, const board_t * board, bool in_pv, int ThreadId) {
int size;
int i, move;
int move_piece;
ASSERT(list_is_ok(list));
ASSERT(board!=NULL);
size = LIST_SIZE(list);
if (size >= 2) {
for (i = 0; i < size; i++) {
move = LIST_MOVE(list,i);
list->value[i] = quiet_move_value(move,board,ThreadId);
if (TryQuietKingAttacks && in_pv) {
move_piece = MOVE_PIECE(move,board);
if (!(PIECE_IS_PAWN(move_piece) || PIECE_IS_KING(move_piece))) {
if (narrow_piece_attack_king(board,move_piece,MOVE_TO(move),KING_POS(board,COLOUR_OPP(board->turn)))) {
if (see_move(move,board) >= 0) {
// if (1 == NumberThreadsInternal) print_board(board);
list->value[i] += 16;
}
}
}
}
}
}
}
bool pseudo_is_legal(int move, board_t * board) {
int me, opp;
int from, to;
int piece;
bool legal;
int king;
undo_t undo[1];
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
// init
me = board->turn;
opp = COLOUR_OPP(me);
from = MOVE_FROM(move);
to = MOVE_TO(move);
piece = board->square[from];
ASSERT(COLOUR_IS(piece,me));
// slow test for en-passant captures
if (MOVE_IS_EN_PASSANT(move)) {
move_do(board,move,undo);
legal = !IS_IN_CHECK(board,me);
move_undo(board,move,undo);
return legal;
}
// king moves (including castle)
if (PIECE_IS_KING(piece)) {
legal = !is_attacked(board,to,opp);
if (DEBUG) {
ASSERT(board->square[from]==piece);
board->square[from] = Empty;
ASSERT(legal==!is_attacked(board,to,opp));
board->square[from] = piece;
}
return legal;
}
// pins
if (is_pinned(board,from,me)) {
king = KING_POS(board,me);
return DELTA_INC_LINE(king-to) == DELTA_INC_LINE(king-from); // does not discover the line
}
return true;
}
bool board_is_ok(const board_t * board) {
int sq, piece, colour;
int size, pos;
if (board == NULL) return false;
// optional heavy DEBUG mode
if (!UseSlowDebug) return true;
// squares
for (sq = 0; sq < SquareNb; sq++) {
piece = board->square[sq];
pos = board->pos[sq];
if (SQUARE_IS_OK(sq)) {
// inside square
if (piece == Empty) {
if (pos != -1) return false;
} else {
if (!piece_is_ok(piece)) return false;
if (!PIECE_IS_PAWN(piece)) {
colour = PIECE_COLOUR(piece);
if (pos < 0 || pos >= board->piece_size[colour]) return false;
if (board->piece[colour][pos] != sq) return false;
} else { // pawn
if (SQUARE_IS_PROMOTE(sq)) return false;
colour = PIECE_COLOUR(piece);
if (pos < 0 || pos >= board->pawn_size[colour]) return false;
if (board->pawn[colour][pos] != sq) return false;
}
}
} else {
// edge square
if (piece != Edge) return false;
if (pos != -1) return false;
}
}
// piece lists
for (colour = 0; colour < ColourNb; colour++) {
// piece list
size = board->piece_size[colour];
if (size < 1 || size > 16) return false;
for (pos = 0; pos < size; pos++) {
sq = board->piece[colour][pos];
if (!SQUARE_IS_OK(sq)) return false;
if (board->pos[sq] != pos) return false;
piece = board->square[sq];
if (!COLOUR_IS(piece,colour)) return false;
if (pos == 0 && !PIECE_IS_KING(piece)) return false;
if (pos != 0 && PIECE_IS_KING(piece)) return false;
if (pos != 0 && PIECE_ORDER(piece) > PIECE_ORDER(board->square[board->piece[colour][pos-1]])) {
return false;
}
}
sq = board->piece[colour][size];
if (sq != SquareNone) return false;
// pawn list
size = board->pawn_size[colour];
if (size < 0 || size > 8) return false;
for (pos = 0; pos < size; pos++) {
sq = board->pawn[colour][pos];
if (!SQUARE_IS_OK(sq)) return false;
if (SQUARE_IS_PROMOTE(sq)) return false;
if (board->pos[sq] != pos) return false;
piece = board->square[sq];
if (!COLOUR_IS(piece,colour)) return false;
if (!PIECE_IS_PAWN(piece)) return false;
}
sq = board->pawn[colour][size];
if (sq != SquareNone) return false;
// piece total
if (board->piece_size[colour] + board->pawn_size[colour] > 16) return false;
}
// material
if (board->piece_nb != board->piece_size[White] + board->pawn_size[White]
+ board->piece_size[Black] + board->pawn_size[Black]) {
return false;
}
if (board->number[WhitePawn12] != board->pawn_size[White]) return false;
if (board->number[BlackPawn12] != board->pawn_size[Black]) return false;
if (board->number[WhiteKing12] != 1) return false;
if (board->number[BlackKing12] != 1) return false;
// misc
if (!COLOUR_IS_OK(board->turn)) return false;
if (board->ply_nb < 0) return false;
if (board->sp < board->ply_nb) return false;
if (board->cap_sq != SquareNone && !SQUARE_IS_OK(board->cap_sq)) return false;
if (board->opening != board_opening(board)) return false;
if (board->endgame != board_endgame(board)) return false;
if (board->key != hash_key(board)) return false;
if (board->pawn_key != hash_pawn_key(board)) return false;
if (board->material_key != hash_material_key(board)) return false;
return true;
}
void board_init_list(board_t * board) {
int sq_64, sq, piece;
int colour, pos;
int i, size;
int square;
int order;
int file;
ASSERT(board!=NULL);
// init
for (sq = 0; sq < SquareNb; sq++) {
board->pos[sq] = -1;
}
board->piece_nb = 0;
for (piece = 0; piece < 12; piece++) board->number[piece] = 0;
// piece lists
for (colour = 0; colour < ColourNb; colour++) {
// piece list
pos = 0;
for (sq_64 = 0; sq_64 < 64; sq_64++) {
sq = SQUARE_FROM_64(sq_64);
piece = board->square[sq];
if (piece != Empty && !piece_is_ok(piece)) my_fatal("board_init_list(): illegal position\n");
if (COLOUR_IS(piece,colour) && !PIECE_IS_PAWN(piece)) {
if (pos >= 16) my_fatal("board_init_list(): illegal position\n");
ASSERT(pos>=0&&pos<16);
board->pos[sq] = pos;
board->piece[colour][pos] = sq;
pos++;
board->piece_nb++;
board->number[PIECE_TO_12(piece)]++;
}
}
if (board->number[COLOUR_IS_WHITE(colour)?WhiteKing12:BlackKing12] != 1) my_fatal("board_init_list(): illegal position\n");
ASSERT(pos>=1&&pos<=16);
board->piece[colour][pos] = SquareNone;
board->piece_size[colour] = pos;
// MV sort
size = board->piece_size[colour];
for (i = 1; i < size; i++) {
square = board->piece[colour][i];
piece = board->square[square];
order = PIECE_ORDER(piece);
for (pos = i; pos > 0 && order > PIECE_ORDER(board->square[(sq=board->piece[colour][pos-1])]); pos--) {
ASSERT(pos>0&&pos<size);
board->piece[colour][pos] = sq;
ASSERT(board->pos[sq]==pos-1);
board->pos[sq] = pos;
}
ASSERT(pos>=0&&pos<size);
board->piece[colour][pos] = square;
ASSERT(board->pos[square]==i);
board->pos[square] = pos;
}
// debug
if (DEBUG) {
for (i = 0; i < board->piece_size[colour]; i++) {
sq = board->piece[colour][i];
ASSERT(board->pos[sq]==i);
if (i == 0) { // king
ASSERT(PIECE_IS_KING(board->square[sq]));
} else {
ASSERT(!PIECE_IS_KING(board->square[sq]));
ASSERT(PIECE_ORDER(board->square[board->piece[colour][i]])<=PIECE_ORDER(board->square[board->piece[colour][i-1]]));
}
}
}
// pawn list
for (file = 0; file < FileNb; file++) {
board->pawn_file[colour][file] = 0;
}
pos = 0;
for (sq_64 = 0; sq_64 < 64; sq_64++) {
sq = SQUARE_FROM_64(sq_64);
piece = board->square[sq];
if (COLOUR_IS(piece,colour) && PIECE_IS_PAWN(piece)) {
if (pos >= 8 || SQUARE_IS_PROMOTE(sq)) my_fatal("board_init_list(): illegal position\n");
ASSERT(pos>=0&&pos<8);
board->pos[sq] = pos;
board->pawn[colour][pos] = sq;
pos++;
board->piece_nb++;
board->number[PIECE_TO_12(piece)]++;
board->pawn_file[colour][SQUARE_FILE(sq)] |= BIT(PAWN_RANK(sq,colour));
}
}
ASSERT(pos>=0&&pos<=8);
board->pawn[colour][pos] = SquareNone;
board->pawn_size[colour] = pos;
if (board->piece_size[colour] + board->pawn_size[colour] > 16) my_fatal("board_init_list(): illegal position\n");
}
// last square
board->cap_sq = SquareNone;
// PST
board->opening = board_opening(board);
board->endgame = board_endgame(board);
// hash key
for (i = 0; i < board->ply_nb; i++) board->stack[i] = 0; // HACK
board->sp = board->ply_nb;
board->key = hash_key(board);
board->pawn_key = hash_pawn_key(board);
board->material_key = hash_material_key(board);
// legality
if (!board_is_legal(board)) my_fatal("board_init_list(): illegal position\n");
// debug
ASSERT(board_is_ok(board));
}
void move_do(board_t * board, int move, undo_t * undo) {
int me, opp;
int from, to;
int piece, pos, capture;
int old_flags, new_flags;
int delta;
int sq;
int pawn, rook;
ASSERT(board!=NULL);
ASSERT(move_is_ok(move));
ASSERT(undo!=NULL);
ASSERT(board_is_legal(board));
// initialise undo
undo->capture = false;
undo->turn = board->turn;
undo->flags = board->flags;
undo->ep_square = board->ep_square;
undo->ply_nb = board->ply_nb;
undo->cap_sq = board->cap_sq;
undo->opening = board->opening;
undo->endgame = board->endgame;
undo->key = board->key;
undo->pawn_key = board->pawn_key;
undo->material_key = board->material_key;
// init
me = board->turn;
opp = COLOUR_OPP(me);
from = MOVE_FROM(move);
to = MOVE_TO(move);
piece = board->square[from];
ASSERT(COLOUR_IS(piece,me));
// update key stack
ASSERT(board->sp<StackSize);
board->stack[board->sp++] = board->key;
// update turn
board->turn = opp;
board->key ^= RANDOM_64(RandomTurn);
// update castling rights
old_flags = board->flags;
new_flags = old_flags & CastleMask[from] & CastleMask[to];
board->flags = new_flags;
board->key ^= Castle64[new_flags^old_flags]; // HACK
// update en-passant square
if ((sq=board->ep_square) != SquareNone) {
board->key ^= RANDOM_64(RandomEnPassant+SQUARE_FILE(sq)-FileA);
board->ep_square = SquareNone;
}
if (PIECE_IS_PAWN(piece)) {
delta = to - from;
if (delta == +32 || delta == -32) {
pawn = PAWN_MAKE(opp);
if (board->square[to-1] == pawn || board->square[to+1] == pawn) {
board->ep_square = (from + to) / 2;
board->key ^= RANDOM_64(RandomEnPassant+SQUARE_FILE(to)-FileA);
}
}
}
// update move number (captures are handled later)
board->ply_nb++;
if (PIECE_IS_PAWN(piece)) board->ply_nb = 0; // conversion
// update last square
board->cap_sq = SquareNone;
// remove the captured piece
sq = to;
if (MOVE_IS_EN_PASSANT(move)) sq = SQUARE_EP_DUAL(sq);
if ((capture=board->square[sq]) != Empty) {
ASSERT(COLOUR_IS(capture,opp));
ASSERT(!PIECE_IS_KING(capture));
undo->capture = true;
undo->capture_square = sq;
undo->capture_piece = capture;
undo->capture_pos = board->pos[sq];
square_clear(board,sq,capture,true);
board->ply_nb = 0; // conversion
board->cap_sq = to;
}
// move the piece
if (MOVE_IS_PROMOTE(move)) {
// promote
undo->pawn_pos = board->pos[from];
square_clear(board,from,piece,true);
piece = move_promote(move);
// insert the promote piece in MV order
for (pos = board->piece_size[me]; pos > 0 && piece > board->square[board->piece[me][pos-1]]; pos--) // HACK
;
square_set(board,to,piece,pos,true);
board->cap_sq = to;
} else {
// normal move
square_move(board,from,to,piece,true);
}
// move the rook in case of castling
if (MOVE_IS_CASTLE(move)) {
rook = Rook64 | COLOUR_FLAG(me); // HACK
if (to == G1) {
square_move(board,H1,F1,rook,true);
} else if (to == C1) {
square_move(board,A1,D1,rook,true);
} else if (to == G8) {
square_move(board,H8,F8,rook,true);
} else if (to == C8) {
square_move(board,A8,D8,rook,true);
} else {
ASSERT(false);
}
}
// debug
ASSERT(board_is_ok(board));
}
