Enum open_ttt_lib::ai::Difficulty

pub enum Difficulty {
    None,
    Easy,
    Medium,
    Hard,
    Unbeatable,
    Custom(fn(depth: i32) -> bool),
}

Selects the difficulty used by the Opponent.

The exact behavior of Easy, Medium, and Hard difficulties are set via play testing and are subject to adjustment in future library versions.

Variants

None

The Opponent picks random positions and does not actually evaluate the game.

Easy

Intended for players who are new to tic-tac-toe to learn the rules of the game. The Opponent mostly picks random squares, but occasionally goes for the win or blocks the player from winning.

Medium

Medium difficulty is for players who have some experience with tic-tac-toe. The AI provides a challenge to the player but games are still winnable, especially if the player plans several moves ahead.

Hard

At hard difficulty the computer plays almost perfect games. The player must capitalize on rare mistakes made by the computer to win. This is the recommended difficulty for experienced tic-tac-toe players.

Unbeatable

The Opponent plays perfect games and cannot be defeated. The best outcome for the player is a cat’s game.

Custom(fn(depth: i32) -> bool)

Provides full control over the Opponent’s difficulty via the provided function.

The AI algorithm selects a free position then traverses the tree of all possible moves looking for one of the end game conditions: win, loss, or cat’s game. The provided function is invoked before processing each node in the outcome tree. Return true to evaluate the node. Return false to stop processing the node, and all child nodes thus preventing the algorithm from considering the outcomes from that branch of the tree.

The depth of the node being considered is provided as the function’s parameter so the custom difficulty can take into account how many moves ahead the Opponent is looking. E.g. the Opponent could be more likely to make mistakes the farther ahead it looks. The depth starts at zero.

Notes

• The number of nodes to evaluate for a game can be large resulting in the provided function being invoked many times when evaluating a game.
• The AI algorithms contain speed optimizations that might skip evaluating part or all of the outcome tree. In these cases the provided function is not called.

Examples

Implement custom difficulties with the same behavior as the None and Unbeatable variants:

use open_ttt_lib::ai;
let same_as_none = ai::Difficulty::Custom(|_| false);
let same_as_unbeatable = ai::Difficulty::Custom(|_| true);

Create a custom difficulty that is perfect when looking at the current move and has a fixed probability of failing to consider deeper parts of the tree.

use rand::Rng;
use open_ttt_lib::ai;

fn should_evaluate_node(depth: i32) -> bool {
    if depth == 0 {
        true
    } else {
        let evaluate_node_probability = 0.8;
        rand::thread_rng().gen_bool(evaluate_node_probability)
    }
}

let custom_difficulty = ai::Difficulty::Custom(should_evaluate_node);

Trait Implementations

impl Clone for Difficulty

fn clone(&self) -> Difficulty

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Difficulty

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

Formats the value using the given formatter.

impl Hash for Difficulty

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Difficulty> for Difficulty

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Copy for Difficulty

impl StructuralPartialEq for Difficulty