use crate::bot::Bot;
use crate::bot::random_numbers;
use crate::game::GameState;
use crate::game::Player;
use rand::rngs::StdRng;
use rand::seq::IndexedRandom;
#[derive(Debug, Clone)]
pub struct TacticalBot {
random_numbers: StdRng,
}
impl TacticalBot {
pub fn from_entropy() -> Self {
Self::with_seed(None)
}
pub fn seeded(seed: u64) -> Self {
Self::with_seed(Some(seed))
}
pub(crate) fn with_seed(seed: Option<u64>) -> Self {
Self {
random_numbers: random_numbers(seed),
}
}
fn safe_move(&mut self, state: &GameState, moves: &[usize]) -> Option<usize> {
let safe: Vec<usize> = moves
.iter()
.copied()
.filter(|column| !hands_over_a_win(state, *column))
.collect();
let candidates = if safe.is_empty() { moves } else { &safe };
candidates
.choose_weighted(&mut self.random_numbers, |column| {
centrality(*column, state.column_count())
})
.ok()
.copied()
}
}
impl Default for TacticalBot {
fn default() -> Self {
Self::from_entropy()
}
}
impl Bot for TacticalBot {
fn choose_move(&mut self, state: &GameState) -> Option<usize> {
let moves = state.legal_moves();
if moves.is_empty() {
return None;
}
let winning = moves
.iter()
.copied()
.find(|column| wins_now(state, *column, state.current_player()));
winning.or_else(|| self.safe_move(state, &moves))
}
fn name(&self) -> &'static str {
"Tactical bot"
}
}
fn after(state: &GameState, column: usize) -> Option<GameState> {
let mut next = state.clone();
next.apply_move(column).ok()?;
Some(next)
}
fn wins_now(state: &GameState, column: usize, player: Player) -> bool {
after(state, column).and_then(|next| next.winner()) == Some(player)
}
fn hands_over_a_win(state: &GameState, column: usize) -> bool {
let Some(next) = after(state, column) else {
return false;
};
let opponent = next.current_player();
next.legal_moves()
.into_iter()
.any(|answer| wins_now(&next, answer, opponent))
}
fn centrality(column: usize, column_count: usize) -> u32 {
let middle = column_count / 2;
let distance = column.abs_diff(middle);
let weight = column_count.saturating_sub(distance);
u32::try_from(weight).unwrap_or(u32::MAX).max(1)
}