Struct draught::comp::Computer

pub struct Computer {
    pub search_depth: usize,
    pub team: Team,
    pub last_node_count: usize,
    pub perfect_chance: f64,
}

Root-level structure for managing the game as a collection of board states

Fields

search_depth: usize

team: Team

last_node_count: usize

perfect_chance: f64

Implementations

impl Computer

pub fn new(search_depth: usize, team: Team, perfect_chance: f64) -> Computer

fn available_turns(&self, board: &Board) -> Vec<Move>

Get vector of available moves for a given board

fn gen_tree(&mut self, tree: &mut Arena<BoardNode>, board: Board) -> NodeId

Generate tree of boards to given search depth, return root node

fn propagate_scores(tree: Arena<BoardNode>, root: NodeId) -> Arena<BoardNode>

Propagate scores up the tree employing MiniMax algorithm

fn best_score(board: &Board, children_scores: Vec<isize>) -> isize

Get best of given scores for given team

fn insert_board_scores(
    &mut self,
    tree: &mut Arena<BoardNode>,
    nodes: Vec<NodeId>
)

For given NodeIDs, insert score of board into tree Used for leaf nodes ready for propagating up tree

fn get_leaf_nodes(
    &mut self,
    tree: &mut Arena<BoardNode>,
    root: NodeId
) -> Vec<NodeId>

Traverse tree from given root ID and get NodeIDs of leaf nodes (those without children)

fn expand_layer(
    &mut self,
    tree: &mut Arena<BoardNode>,
    nodes: Vec<NodeId>
) -> Vec<NodeId>

Expand all given nodes and return newly inserted layer of nodes

fn expand_node(
    &mut self,
    tree: &mut Arena<BoardNode>,
    node: NodeId
) -> Vec<NodeId>

Insert all possible next boards as children of given board node

fn insert_boards(
    &mut self,
    tree: &mut Arena<BoardNode>,
    boards: Vec<BoardNode>
) -> Vec<NodeId>

Insert given boards into tree

fn get_move_boards(&self, board: &BoardNode) -> Vec<BoardNode>

Get all possible next boards from given board

pub fn get_move(&mut self, brd: Board) -> Option<Board>

Get a new board based on the given using MiniMax to make decisions

fn random_choice(
    tree: &Arena<BoardNode>,
    possible_moves: Vec<NodeId>,
    rng: &mut ThreadRng
) -> Board

Get a random board from possible node IDs and associated tree

Trait Implementations

impl Debug for Computer

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

Formats the value using the given formatter.