double Alan_Turing_AI::material_value(const Board& board, Color perspective) const
{
double player_score = 0.0;
double opponent_score = 0.0;
for(char file = 'a'; file <= 'h'; ++file)
{
for(int rank = 1; rank <= 8; ++rank)
{
auto piece = board.piece_on_square(file, rank);
if(piece)
{
if(piece->color() == perspective)
{
player_score += piece_value(piece);
}
else
{
opponent_score += piece_value(piece);
}
}
}
}
return player_score/opponent_score;
}
int eval_attackers(s_board *board, uint64_t pos, int side)
{
assert(board != NULL);
assert(pos);
assert(side == WHITE || side == BLACK);
int eval = 0;
int sq = __builtin_ctzll(pos);
uint64_t attackers = 0;
// Pawns
attackers = board->colour[side] & board->pieces[PAWNS] & magic_moves_pawns(1-side, sq);
while(attackers)
{
eval += piece_value(PAWNS);
attackers &= 1-attackers;
}
// Knights
attackers = board->colour[side] & board->pieces[KNIGHTS] & magic_moves_knight(sq);
while(attackers)
{
eval += piece_value(KNIGHTS);
attackers &= 1-attackers;
}
// Bishops
attackers = magic_moves_bishop((board->colour[WHITE]|board->colour[BLACK]), sq) & board->colour[WHITE] & board->pieces[BISHOPS];
while(attackers)
{
eval += piece_value(BISHOPS);
attackers &= 1-attackers;
}
// Rooks
attackers = magic_moves_rook((board->colour[WHITE]|board->colour[BLACK]), sq) & board->colour[WHITE] & board->pieces[ROOKS];
while(attackers)
{
eval += piece_value(ROOKS);
attackers &= 1-attackers;
}
// Queens
attackers = magic_moves_bishop((board->colour[WHITE]|board->colour[BLACK]), sq) & board->colour[WHITE] & board->pieces[QUEENS];
attackers |= magic_moves_rook((board->colour[WHITE]|board->colour[BLACK]), sq) & board->colour[WHITE] & board->pieces[QUEENS];
while(attackers)
{
eval += piece_value(QUEENS);
attackers &= 1-attackers;
}
return eval;
}
void IncrementalUpdater::add_piece(const Color color,
const Piece::piece_index_t index,
const Position position,
IncrementalState* const state)
{
assert(0 <= index && index < PieceSet::c_no_pieces);
const score_t middlegame_value = piece_value(color, 0, index, position);
const score_t endgame_value = piece_value(color, 1, index, position);
state->incremental_score_white_middlegame += middlegame_value;
state->incremental_score_white_endgame += endgame_value;
state->material_score += material_scores()[index];
update_total_score(state);
}
bool Alan_Turing_AI::is_considerable(const Move& move, const Board& board) const
{
// Recapture is considerable
if(board.last_move_captured() && board.move_captures(move))
{
auto last_move = board.game_record().back();
if(last_move->end_file() == move.end_file() && last_move->end_rank() == move.end_rank())
{
return true;
}
}
auto attacking_piece = board.piece_on_square(move.start_file(), move.start_rank());
auto attacked_piece = board.piece_on_square(move.end_file(), move.end_rank());
if(attacked_piece)
{
// Capturing an undefended piece is considerable
auto temp_board = board;
auto result = temp_board.submit_move(move);
if(temp_board.safe_for_king(move.end_file(), move.end_rank(), attacking_piece->color()))
{
return true;
}
// Capturing with a less valuable piece is considerable
if(piece_value(attacked_piece) > piece_value(attacking_piece))
{
return true;
}
// A move resulting in checkmate is considerable
if(result.winner() == board.whose_turn())
{
return true;
}
}
return false;
}
