use core::ffi::{c_int, c_ulonglong};
use std::ffi::CString;
use std::num::{NonZeroU8, NonZeroUsize};
use std::sync::atomic::AtomicBool;
use std::time::Duration;
use model::{CheckersBitBoard, Move, MoveDirection, PieceColor};
use crate::{
ActualLimit, Clock, Engine, EvalInfo, Evaluation, EvaluationSettings, Frontend, SearchLimit,
};
#[repr(C)]
struct CFrontend {
debug_fn: extern "C" fn(*const u8),
info_fn: extern "C" fn(*const EvalInfo),
bestmove_fn: extern "C" fn(*const Move),
}
impl Frontend for CFrontend {
fn debug(&self, msg: &str) {
(self.debug_fn)(msg.as_bytes().as_ptr())
}
fn info(&self, info: EvalInfo) {
(self.info_fn)(&info)
}
fn report_best_move(&self, best_move: Move) {
(self.bestmove_fn)(&best_move)
}
}
#[repr(C)]
struct EvalResult {
evaluation: Box<Evaluation>,
best_move: Option<Box<Move>>,
}
#[no_mangle]
extern "C" fn ampere_new_engine(hash_size: c_ulonglong, frontend: &CFrontend) -> Box<Engine<'_>> {
Box::new(Engine::new(hash_size as usize, frontend))
}
#[no_mangle]
extern "C" fn ampere_set_debug(engine: &Engine<'_>, debug: bool) {
engine.set_debug(debug)
}
#[no_mangle]
extern "C" fn ampere_islegal(engine: &Engine<'_>, ampere_move: &Move) -> bool {
engine.is_legal_move(*ampere_move)
}
#[no_mangle]
extern "C" fn ampere_current_position(engine: &Engine<'_>) -> Box<CheckersBitBoard> {
Box::new(engine.current_position())
}
#[no_mangle]
extern "C" fn ampere_reset_position(engine: &Engine<'_>) {
engine.reset_position();
}
#[no_mangle]
extern "C" fn ampere_set_position(engine: &Engine<'_>, board: &CheckersBitBoard) {
engine.set_position(*board);
}
#[no_mangle]
extern "C" fn ampere_play_move(engine: &Engine<'_>, ampere_move: &Move) -> bool {
engine.apply_move(*ampere_move).is_some()
}
#[no_mangle]
extern "C" fn ampere_evaluate(
engine: &'static Engine<'_>,
cancel: Option<&AtomicBool>,
nodes: c_int,
depth: c_int,
time: Option<&Clock>,
) -> EvalResult {
let limits = if nodes == 0 && depth == 0 && time.is_none() {
SearchLimit::Auto
} else {
let time = time.cloned().unwrap_or(Clock::Unlimited);
SearchLimit::Limited(ActualLimit {
nodes: NonZeroUsize::new(nodes as usize),
depth: NonZeroU8::new(depth as u8),
time: Some(time.recommended_time(engine.current_position().turn)),
})
};
let (eval, best) = engine.evaluate(
cancel,
EvaluationSettings {
restrict_moves: None,
ponder: false,
clock: Clock::Unlimited,
search_until: limits,
},
);
let evaluation = Box::new(eval);
let best_move = best.map(Box::new);
EvalResult {
evaluation,
best_move,
}
}
#[no_mangle]
extern "C" fn ampere_starteval_limited(
engine: &'static Engine<'_>,
ponder: bool,
nodes: c_int,
depth: c_int,
time: c_int,
) {
let limits = if nodes == 0 && depth == 0 && time == 0 {
SearchLimit::Auto
} else {
let time = if time == 0 {
None
} else {
Some(Duration::from_millis(time as u64))
};
SearchLimit::Limited(ActualLimit {
nodes: NonZeroUsize::new(nodes as usize),
depth: NonZeroU8::new(depth as u8),
time,
})
};
engine.start_evaluation(EvaluationSettings {
restrict_moves: None,
ponder,
clock: Clock::Unlimited,
search_until: limits,
})
}
#[no_mangle]
extern "C" fn ampere_starteval_unlimited(engine: &'static Engine<'_>, ponder: bool) {
engine.start_evaluation(EvaluationSettings {
restrict_moves: None,
ponder,
clock: Clock::Unlimited,
search_until: SearchLimit::Infinite,
})
}
#[no_mangle]
extern "C" fn ampere_stopeval(engine: &Engine<'_>) -> bool {
engine.stop_evaluation().is_some()
}
#[no_mangle]
extern "C" fn ampere_destroy_engine(engine: Box<Engine<'_>>) {
drop(engine)
}
#[no_mangle]
extern "C" fn ampere_evalinfo_nodes(info: &EvalInfo) -> c_ulonglong {
info.nodes_searched as c_ulonglong
}
#[no_mangle]
extern "C" fn ampere_evalinfo_evaluation(info: &EvalInfo) -> *const Evaluation {
&info.evaluation
}
#[no_mangle]
extern "C" fn ampere_evalinfo_bestmove(info: &EvalInfo) -> Option<&Move> {
info.current_best_move.as_ref()
}
#[no_mangle]
extern "C" fn ampere_evalinfo_depth(info: &EvalInfo) -> c_int {
info.current_depth as c_int
}
#[no_mangle]
extern "C" fn ampere_evalinfo_nodespersec(info: &EvalInfo) -> c_ulonglong {
info.nodes_per_second() as c_ulonglong
}
#[no_mangle]
extern "C" fn ampere_evalinfo_elapsed(info: &EvalInfo) -> c_ulonglong {
info.elapsed_milliseconds() as c_ulonglong
}
#[no_mangle]
extern "C" fn ampere_board_starting_position() -> Box<CheckersBitBoard> {
Box::new(CheckersBitBoard::starting_position())
}
#[no_mangle]
extern "C" fn ampere_board_new(
pieces: u32,
color: u32,
kings: u32,
turn: PieceColor,
) -> Box<CheckersBitBoard> {
Box::new(CheckersBitBoard::new(pieces, color, kings, turn))
}
#[no_mangle]
extern "C" fn ampere_clock_unlimited() -> Box<Clock> {
Box::new(Clock::Unlimited)
}
#[no_mangle]
extern "C" fn ampere_clock_timepermove(millis: c_int) -> Box<Clock> {
Box::new(Clock::TimePerMove(Duration::from_millis(millis as u64)))
}
#[no_mangle]
extern "C" fn ampere_clock_incremental(
white_time: c_int,
black_time: c_int,
white_inc: c_int,
black_inc: c_int,
moves_to_time_control: c_int,
time_control: c_int,
) -> Box<Clock> {
let moves_until_next_time_control = if time_control == 0 {
None
} else {
Some((
moves_to_time_control as u32,
Duration::from_millis(time_control as u64),
))
};
Box::new(Clock::Incremental {
white_time_remaining: Duration::from_millis(white_time as u64),
black_time_remaining: Duration::from_millis(black_time as u64),
white_increment: Duration::from_millis(white_inc as u64),
black_increment: Duration::from_millis(black_inc as u64),
moves_until_next_time_control,
})
}
#[no_mangle]
extern "C" fn ampere_clock_destroy(clock: Box<Clock>) {
drop(clock)
}
#[no_mangle]
extern "C" fn ampere_board_clone(board: &CheckersBitBoard) -> Box<CheckersBitBoard> {
Box::new(*board)
}
#[no_mangle]
extern "C" fn ampere_board_equal(a: &CheckersBitBoard, b: &CheckersBitBoard) -> bool {
*a == *b
}
#[no_mangle]
extern "C" fn ampere_board_hash(board: &CheckersBitBoard) -> u64 {
board.hash_code()
}
#[no_mangle]
extern "C" fn ampere_board_pieces(board: &mut CheckersBitBoard) -> &mut u32 {
&mut board.pieces
}
#[no_mangle]
extern "C" fn ampere_board_colors(board: &mut CheckersBitBoard) -> &mut u32 {
&mut board.color
}
#[no_mangle]
extern "C" fn ampere_board_kings(board: &mut CheckersBitBoard) -> &mut u32 {
&mut board.kings
}
#[no_mangle]
extern "C" fn ampere_board_turn(board: &mut CheckersBitBoard) -> &mut PieceColor {
&mut board.turn
}
#[no_mangle]
extern "C" fn ampere_board_has_piece_at(board: &CheckersBitBoard, square: c_int) -> bool {
board.piece_at(square as usize)
}
#[no_mangle]
unsafe extern "C" fn ampere_board_color_at(board: &CheckersBitBoard, square: c_int) -> PieceColor {
board.color_at_unchecked(square as usize)
}
#[no_mangle]
unsafe extern "C" fn ampere_board_king_at(board: &CheckersBitBoard, square: c_int) -> bool {
board.king_at_unchecked(square as usize)
}
#[no_mangle]
unsafe extern "C" fn ampere_board_move_piece(
board: &mut CheckersBitBoard,
start: c_int,
dest: c_int,
) {
*board = board.move_piece_to_unchecked(start as usize, dest as usize);
}
#[no_mangle]
extern "C" fn ampere_board_clear_piece(board: &mut CheckersBitBoard, square: c_int) {
*board = board.clear_piece(square as usize);
}
#[no_mangle]
extern "C" fn ampere_board_destroy(board: Box<CheckersBitBoard>) {
drop(board)
}
#[no_mangle]
extern "C" fn ampere_eval_is_force_win(evaluation: &Evaluation) -> bool {
evaluation.is_force_win()
}
#[no_mangle]
extern "C" fn ampere_eval_is_force_loss(evaluation: &Evaluation) -> bool {
evaluation.is_force_loss()
}
#[no_mangle]
extern "C" fn ampere_eval_is_force_seq(evaluation: &Evaluation) -> bool {
evaluation.is_force_sequence()
}
#[no_mangle]
unsafe extern "C" fn ampere_eval_forceseq_len(evaluation: &Evaluation) -> c_int {
evaluation.force_sequence_length().unwrap_unchecked() as c_int
}
#[no_mangle]
unsafe extern "C" fn ampere_eval_tofloat(evaluation: &Evaluation) -> f32 {
evaluation.to_f32_unchecked()
}
#[no_mangle]
extern "C" fn ampere_eval_destroy(evaluation: Box<Evaluation>) {
drop(evaluation)
}
#[no_mangle]
extern "C" fn ampere_move_new(start: c_int, direction: MoveDirection, jump: bool) -> Box<Move> {
Box::new(Move::new(start as usize, direction, jump))
}
#[no_mangle]
extern "C" fn ampere_move_clone(ampere_move: &Move) -> Box<Move> {
Box::new(*ampere_move)
}
#[no_mangle]
extern "C" fn ampere_move_equal(a: &Move, b: &Move) -> bool {
*a == *b
}
#[no_mangle]
unsafe extern "C" fn ampere_move_string(m: &Move, buffer: *mut u8) {
let buffer = std::slice::from_raw_parts_mut(buffer, 6);
let string = CString::new(m.to_string().as_bytes()).unwrap_unchecked();
let bytes = string.as_bytes_with_nul();
buffer[..bytes.len()].copy_from_slice(bytes)
}
#[no_mangle]
extern "C" fn ampere_move_start(ampere_move: &Move) -> c_int {
ampere_move.start() as c_int
}
#[no_mangle]
extern "C" fn ampere_move_direction(ampere_move: &Move) -> MoveDirection {
ampere_move.direction()
}
#[no_mangle]
extern "C" fn ampere_move_is_jump(ampere_move: &Move) -> bool {
ampere_move.is_jump()
}
#[no_mangle]
unsafe extern "C" fn ampere_move_jump_position(ampere_move: &Move) -> c_int {
ampere_move.jump_position() as c_int
}
#[no_mangle]
extern "C" fn ampere_move_end(ampere_move: &Move) -> c_int {
ampere_move.end_position() as c_int
}
#[no_mangle]
extern "C" fn ampere_move_destroy(ampere_move: Box<Move>) {
drop(ampere_move)
}
|
