grid-sim 0.3.0

grid-based simulation 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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

pub mod input_cells;
use self::input_cells::InputCells;
use world::CellState;
use std::str::FromStr;
use std::collections::HashMap;

type RulesetType = HashMap<(CellState, CellState), Vec<(usize, CellState)>>;

#[derive(Clone)]
pub enum Rulesets {
    Custom,
    Conway,
    ConwayEasy,
    ConwayVeryEasy,
    Decay,
}
#[derive(Clone)]
pub struct Ruleset {
    pub input_cells: InputCells,
    pub rules: Rulesets,
}
impl FromStr for Rulesets {
    type Err = ();
    fn from_str(s: &str) -> Result<Rulesets, ()> {
        match s {
            "Conway" => Ok(Rulesets::Conway),
            "ConwayEasy" => Ok(Rulesets::ConwayEasy),
            "ConwayVeryEasy" => Ok(Rulesets::ConwayVeryEasy),
            "Decay" => Ok(Rulesets::Decay),
            _ => Err(()),
        }
    }
}
impl Rulesets {
    pub fn get_data(&self) -> DSLRuleset {
        use self::CellState::{Dead, Live};
        match *self {
            //Custom will use yet-formalized DSL that will be used for config files
            Rulesets::Custom => {
                let mut ruleset = DSLRuleset::new();
                ruleset.add_cases(Dead, Live, vec![(3, Live)]);
                ruleset
            },
            Rulesets::Conway => {
                let mut ruleset = DSLRuleset::new();
                ruleset.add_cases(Dead, Live, vec![(3, Live)]);
                ruleset.add_cases(Live, Live, vec![
                    (0, Dead), (1, Dead), (4, Dead), (5, Dead),
                    (6, Dead), (7, Dead), (8, Dead), (9, Dead),
                ]);
                ruleset
            },
            Rulesets::ConwayEasy => {
                let mut ruleset = DSLRuleset::new();
                ruleset.add_cases(Dead, Live, vec![(3, Live)]);
                ruleset.add_cases(Live, Live, vec![
                    (0, Dead), (1, Dead), (2, Live), (3, Live), 
                    (4, Dead), (5, Dead), (6, Dead), (7, Live), (8, Dead), 
                ]);
                ruleset
            },
            Rulesets::ConwayVeryEasy => {
                let mut ruleset = DSLRuleset::new();
                ruleset.add_cases(Dead, Live, vec![
                    (3, Live), (4, Live),
                ]);
                ruleset.add_cases(Live, Live, vec![
                    (0, Dead), (1, Dead), (4, Dead), (5, Dead),
                    (6, Dead), (7, Live), (8, Dead), (9, Dead),
                ]);
                ruleset
            },
            Rulesets::Decay => {
                let mut ruleset = DSLRuleset::new();
                ruleset.add_cases(Dead, Live, vec![(3, Live), (4, Live)]);
                ruleset.add_cases(Live, Live, vec![
                    (0, Dead), (1, Live), (2, Dead), (3, Dead), 
                    (4, Live), (5, Dead), (6, Dead), (7, Dead), (8, Dead), 
                ]);
                ruleset
            },
        }
    }
}
pub struct DSLRuleset {
    data: RulesetType,
}
impl DSLRuleset {
    pub fn new() -> Self {
        DSLRuleset {
            data: HashMap::new(),
        }
    }
    pub fn add_cases(&mut self,
                 identity_state: CellState,
                 for_state: CellState,
                 cases: Vec<(usize, CellState)>
        ) {
        let key = (identity_state, for_state);

        self.data.insert(key, cases);
    }
    pub fn compute(&mut self,
               identity_state: CellState,
               input_states: Vec<(CellState, usize)>
        ) -> CellState {

        let mut return_state = identity_state.clone();

        let mut key = (identity_state, CellState::Uninitialized);
        //loop through list of amounts of each state from neighbor states
        for &(ref state, ref amt) in input_states.iter() {
            //reuse identity_state
            key.1 = state.clone();

            match self.data.get(&key) {
                Some(vec) => {
                    for &(ref trigger_amt, ref result_state) in vec {
                        if trigger_amt == amt {
                            return_state = result_state.clone();
                        }
                    }
                },
                None => (),
            }
        }

        return_state
    }
}