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 28)

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 tree = mcts.get_tree();
    let root = mcts.get_root();
    for node_id in root.children() {
        let node = tree.get(node_id).unwrap();
        println!(
            "Move: {:?} = {:.2?}%",
            node.data().prev_move,
            node.data().wins_rate() * 100.0
        );
    }

    // Get the most promising move
    let best_move_node = mcts.get_most_perspective_move();
    let best_move = best_move_node.data().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: Board> Default for MctsNode<T>

fn default() -> Self

Returns the “default value” for a type.