Struct MctsNode

pub struct MctsNode<T: Board> {
    pub id: i32,
    pub height: i32,
    pub board: Box<T>,
    pub prev_move: Option<T::Move>,
    pub current_player: Player,
    pub outcome: GameOutcome,
    pub visits: i32,
    pub wins: i32,
    pub draws: i32,
    pub bound: Bound,
    pub is_fully_calculated: bool,
}

Represents a single node in the Monte Carlo search tree.

Each node stores the state of the game, statistics about the outcomes of simulations, and information about the move that led to this state.

Fields

id: i32

A unique identifier for the node.

height: i32

The depth of the node in the tree.

board: Box<T>

The game state that this node represents.

prev_move: Option<T::Move>

The move that led to this node’s state from its parent. None for the root node.

current_player: Player

The player whose turn it is in this node’s game state.

outcome: GameOutcome

The outcome of the game at this node, if it is terminal.

visits: i32

The number of times this node has been visited during the search.

wins: i32

The number of times simulations from this node have resulted in a win for the current player.

draws: i32

The number of times simulations from this node have resulted in a draw.

bound: Bound

The bound of the node, used for alpha-beta pruning.

is_fully_calculated: bool

A flag indicating whether the outcome of this node is definitively known.

Implementations

impl<T: Board> MctsNode<T>

pub fn new(id: i32, boxed_board: Box<T>) -> Self

Creates a new MctsNode with the given ID and board state.

pub fn wins_rate(&self) -> f64

Calculates the win rate of this node.

Examples found in repository

examples/tic_tac_toe.rs (line 26)

fn main() {
    // Create a new Tic-Tac-Toe board
    let board = TicTacToeBoard::default();

    // Create a new MCTS search instance
    let mut mcts = MonteCarloTreeSearch::builder(board)
        .with_alpha_beta_pruning(false)
        .with_random_generator(CustomNumberGenerator::default())
        .build();

    // Run the search for 20,000 iterations
    mcts.iterate_n_times(20000);

    // Print the chances
    let root = mcts.get_root();
    for node in root.children() {
        println!(
            "Move: {:?} = {:.2?}%",
            node.value().prev_move,
            node.value().wins_rate() * 100.0
        );
    }

    // Get the most promising move
    let best_move_node = root.get_best_child().unwrap();
    let best_move = best_move_node.value().prev_move;

    println!("The best move is: {:?}", best_move);
    assert_eq!(best_move, Some(4));
}

pub fn draws_rate(&self) -> f64

Calculates the draw rate of this node.

Trait Implementations

impl<T: Clone + Board> Clone for MctsNode<T>

where T::Move: Clone,

fn clone(&self) -> MctsNode<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Board> Debug for MctsNode<T>

where T::Move: Debug,

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

Formats the value using the given formatter.

impl<T: Board> Hash for MctsNode<T>

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<T: Board> PartialEq for MctsNode<T>

fn eq(&self, other: &Self) -> 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<T: Board> Eq for MctsNode<T>