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
131
use std::borrow::Cow;
#[cfg(feature = "serde")]
use serde::Deserialize;
use cell::{Cell, CellState};
use container::EntityContainer;
use entity::{EntityState, MutEntityState};
use generator::Generator;
pub trait Universe<C: CellState, E: EntityState<C>, M: MutEntityState>: Default {
fn get_cell(&self, coord: usize) -> Option<Cow<Cell<C>>>;
unsafe fn get_cell_unchecked(&self, coord: usize) -> Cow<Cell<C>>;
fn set_cell(&mut self, coord: usize, new_state: C);
fn set_cell_unchecked(&mut self, coord: usize, new_state: C);
fn get_entities<'a>(&'a self) -> &'a EntityContainer<C, E, M>;
fn get_entities_mut<'a>(&'a mut self) -> &'a mut EntityContainer<C, E, M>;
fn get_cells<'a>(&'a self) -> &'a [Cell<C>];
fn get_cells_mut<'a>(&'a mut self) -> &'a mut [Cell<C>];
fn empty() -> Self;
}
#[derive(Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Universe2DConf {
pub size: u32,
}
impl Default for Universe2DConf {
fn default() -> Universe2DConf { Universe2DConf { size: 800 } }
}
#[derive(Clone)]
pub struct Universe2D<C: CellState, E: EntityState<C>, M: MutEntityState> {
pub conf: Universe2DConf,
pub cells: Vec<Cell<C>>,
pub entities: EntityContainer<C, E, M>,
}
impl<C: CellState, E: EntityState<C>, M: MutEntityState> Universe2D<C, E, M> {
pub fn new(conf: Universe2DConf, gen: &mut Generator<C, E, M>) -> Universe2D<C, E, M> {
assert!(conf.size > 0);
let universe_size = conf.size as usize;
let mut universe = Universe2D {
conf,
cells: Vec::new(),
entities: EntityContainer::new(universe_size),
};
let (cells, entities) = gen.gen(&universe.conf);
universe.cells = cells;
for (universe_index, entity_vec) in entities.into_iter().enumerate() {
for entity in entity_vec {
universe.entities.insert(entity, universe_index);
}
}
universe
}
pub fn uninitialized() -> Self {
let conf = Universe2DConf::default();
let universe_size = conf.size as usize;
Universe2D {
conf,
cells: Vec::new(),
entities: EntityContainer::new(universe_size),
}
}
pub fn get_conf<'a>(&'a self) -> &'a Universe2DConf { &self.conf }
pub fn get_size(&self) -> usize { self.conf.size as usize }
}
impl<C: CellState, E: EntityState<C>, M: MutEntityState> Default for Universe2D<C, E, M> {
fn default() -> Self { Universe2D::uninitialized() }
}
impl<C: CellState, E: EntityState<C>, M: MutEntityState> Universe<C, E, M> for Universe2D<C, E, M> {
fn get_cell(&self, coord: usize) -> Option<Cow<Cell<C>>> {
self.cells.get(coord).map(|c| Cow::Borrowed(c))
}
unsafe fn get_cell_unchecked(&self, coord: usize) -> Cow<Cell<C>> {
Cow::Borrowed(self.cells.get_unchecked(coord))
}
fn set_cell(&mut self, coord: usize, new_state: C) {
match self.cells.get_mut(coord) {
Some(&mut Cell { ref mut state }) => *state = new_state,
None => (),
}
}
fn set_cell_unchecked(&mut self, coord: usize, new_state: C) {
self.cells[coord].state = new_state;
}
fn get_entities<'a>(&'a self) -> &'a EntityContainer<C, E, M> { &self.entities }
fn get_entities_mut<'a>(&'a mut self) -> &'a mut EntityContainer<C, E, M> { &mut self.entities }
fn get_cells<'a>(&'a self) -> &'a [Cell<C>] { &self.cells }
fn get_cells_mut<'a>(&'a mut self) -> &'a mut [Cell<C>] { &mut self.cells }
fn empty() -> Self { Self::uninitialized() }
}