Struct Opponent

pub struct Opponent { /* private fields */ }

Provides a computer controlled AI opponent.

This can be used to create single player games or implement a hint system for human users.

Implementations

impl Opponent

pub fn new(difficulty: Difficulty) -> Self

Constructs a new AI opponent using the provided difficulty.

Examples

Construct a hard AI opponent:

use open_ttt_lib::ai;

let hard_opponent = ai::Opponent::new(ai::Difficulty::Hard);

Construct an AI opponent that randomly picks positions:

use open_ttt_lib::ai;

let rando = ai::Opponent::new(ai::Difficulty::None);

pub fn get_move(&self, game: &Game) -> Option<Position>

Gets the position the AI opponent wishes to move based on the provided game.

None is returned if the game is over. The AI opponent never tries to select an invalid position, that is a position that is not free.

Examples

use open_ttt_lib::ai;
use open_ttt_lib::game;

let game = game::Game::new();
let ai_opponent = ai::Opponent::new(ai::Difficulty::Medium);

match ai_opponent.get_move(&game) {
    Some(position) => assert!(game.can_move(position)),
    None => panic!("The game is over so the AI opponent cannot do a move."),
};

pub fn evaluate_game(&self, game: &Game) -> HashMap<Position, Outcome>

Evaluates each free position in the provided game.

Each free position in the game is mapped to an outcome for the AI opponent. If the game is over an empty map is returned.

This functionality is useful if you wish to examine how the AI opponent viewed the game. E.g. this can be helpful for creating a hint system to help human players pick a position or when fine-tuning the AI difficulty settings.

Examples

use open_ttt_lib::ai;
use open_ttt_lib::game;

let game = game::Game::new();
let ai_opponent = ai::Opponent::new(ai::Difficulty::Medium);

let outcomes = ai_opponent.evaluate_game(&game);

// Display the outcome for each position.
for (position, outcome) in outcomes {
    assert!(game.can_move(position));
    println!("position: {:?} outcome: {:?}", position, outcome);
}

Trait Implementations

impl Clone for Opponent

fn clone(&self) -> Opponent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Opponent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Opponent

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Opponent

fn eq(&self, other: &Opponent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Opponent