rubot 0.3.0

A generic game bot written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use crate::Game;

use std::fmt::{self, Debug};

use super::{Action, Branch, Ctxt, MiniMax, State};

impl<T: Game> Debug for Action<T>
where
    T::Action: Debug,
    T::Fitness: Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Action")
            .field("fitness", &self.fitness)
            .field("path", &self.fitness)
            .finish()
    }
}

impl<'a, T: Game> Debug for Ctxt<'a, T>
where
    T: Debug,
    T::Action: Debug,
    T::Fitness: Debug,
    T::Player: Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Ctxt")
            .field("state", &self.state)
            .field("player", &self.player)
            .field("best", &self.best)
            .field("unfinished", &self.unfinished)
            .field("terminated", &self.terminated)
            .field("partially_terminated", &self.partially_terminated)
            .finish()
    }
}

impl<T: Game> Debug for MiniMax<T>
where
    T::Action: Debug,
    T::Fitness: Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MiniMax::Terminated(path, branch) => write!(f, "Terminated({:?}, {:?})", path, branch),
            MiniMax::Open(path, branch) => write!(f, "Open({:?}, {:?})", path, branch),
            MiniMax::DeadEnd => write!(f, "DeadEnd"),
        }
    }
}

impl<T: Game> Debug for State<T>
where
    T::Action: Debug,
    T::Fitness: Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("State")
            .field("alpha", &self.alpha)
            .field("beta", &self.beta)
            .field("best_fitness", &self.best_fitness)
            .field("path", &self.path)
            .field("terminated", &self.terminated)
            .field("active", &self.active)
            .finish()
    }
}

impl<T: Game> Debug for Branch<T>
where
    T::Action: Debug,
    T::Fitness: Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Branch::Worse(fitness) => write!(f, "Worse({:?})", fitness),
            Branch::Better(fitness) => write!(f, "Better({:?})", fitness),
            Branch::Equal(fitness) => write!(f, "Equal({:?})", fitness),
        }
    }
}