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
83
84
85
86
87
88
89
90
91
92
93
94

use std::str::FromStr;
use std::fmt;
use super::helpers;
use super::moves::Move;

#[derive(Clone, Copy, PartialEq)]
pub enum Booster {
    Shadow,
    Speedy,
    Regenerative,
    ZombieCorps,
    Atlas,
    Strong,
    Backwards,
    Moustachio,
    None
}

impl Booster {
    pub fn get_moves(self) -> Vec<Move> {
        match self {
            Booster::Shadow => vec![
                Move::ShadowFireball,
                Move::ShadowSlip
            ],
            Booster::Speedy => vec![
                Move::RunInCircles,
                Move::LightningFastKarateChop
            ],
            Booster::Regenerative => vec![
                Move::Regenerate,
                Move::Gravedigger
            ],
            Booster::ZombieCorps => vec![
                Move::ZombieCorps,
                Move::Apocalypse
            ],
            Booster::Atlas => vec![
                Move::Lightning,
                Move::Earthquake
            ],
            Booster::Strong => vec![
                Move::Twist,
                Move::Bend
            ],
            Booster::Backwards => vec![
                Move::BackwardsMoustachio,
                Move::NoseOfTheTaunted
            ],
            Booster::Moustachio => vec![
                Move::MustacheMash,
                Move::BigHairyDeal
            ],
            Booster::None => Vec::new()
        }
    }
}

impl FromStr for Booster {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match &helpers::lowercase_no_whitespace(s)[..] {
            "shadow" => Ok(Booster::Shadow),
            "speedy" => Ok(Booster::Speedy),
            "regenerative" => Ok(Booster::Regenerative),
            "zombiecorps" => Ok(Booster::ZombieCorps),
            "atlas" => Ok(Booster::Atlas),
            "strong" => Ok(Booster::Strong),
            "backwards" => Ok(Booster::Backwards),
            "moustachio" => Ok(Booster::Moustachio),
            "none" | "nobooster" => Ok(Booster::None),
            _ => Err(())
        }
    }
}

impl fmt::Display for Booster {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let string = match self {
            &Booster::Shadow => "Shadow",
            &Booster::Speedy => "Speedy",
            &Booster::Regenerative => "Regenerative",
            &Booster::ZombieCorps => "Zombie Corps",
            &Booster::Atlas => "Atlas",
            &Booster::Strong => "Strong",
            &Booster::Backwards => "Backwards",
            &Booster::Moustachio => "Moustachio",
            &Booster::None => "No Booster"
        };

        write!(f, "{}", string)
    }
}