ecs_rust/
entity_manager.rs

1use std::collections::HashMap;
2use std::any::TypeId;
3use std::mem::transmute;
4use std::vec;
5
6use super::entity::Entity;
7use super::component::Component;
8use super::component_manager::{
9	ComponentManager,
10	ComponentManagerTrait,
11	cast_manager,
12	cast_manager_mut
13};
14
15struct Entities {
16	entities: Vec<Entity>,
17	availables: Vec<usize>
18}
19
20impl Entities {
21	fn new() -> Self {
22		Entities {
23			entities: vec![],
24			availables: vec![]
25		}
26	}
27
28	fn has(&self, entity_id: usize) -> bool {
29		entity_id < self.entities.len() && self.entities[entity_id].is_alive()
30	}
31
32	fn create(&mut self) -> usize {
33		if self.availables.len() > 0 {
34			let index = self.availables.remove(0);
35			self.entities[index].reset();
36			return index;
37		}
38		let entity = Entity::new();
39		self.entities.push(entity);
40		self.entities.len() - 1
41	}
42
43	fn remove(&mut self, entity_id: usize) {
44		if !self.has(entity_id) {
45			// @TODO: Error handling
46			return;
47		}
48		self.entities[entity_id].invalid();
49		self.availables.push(entity_id);
50	}
51}
52
53// @TODO: Is this name good?
54pub struct EntityIdAccessor {
55	cache_map: HashMap<TypeId, Vec<usize>>,
56	updated_frame_map: HashMap<TypeId, u64> // @TODO: Rename
57}
58
59impl EntityIdAccessor {
60	pub fn new() -> Self {
61		EntityIdAccessor {
62			cache_map: HashMap::new(),
63			updated_frame_map: HashMap::new()
64		}
65	}
66
67	pub fn borrow_ids<T: 'static + Component>(&mut self, manager: &EntityManager) -> Option<&Vec<usize>> {
68		if !manager.has_component_manager::<T>() {
69			return None;
70		}
71
72		let type_id = TypeId::of::<T>();
73		let needs_update = if !self.cache_map.contains_key(&type_id) {
74			self.cache_map.insert(type_id, Vec::new());
75			true
76		} else {
77			let updated_frame = *self.updated_frame_map.get(&type_id).unwrap();
78			manager.get_updated_frame::<T>() != updated_frame
79		};
80
81		if needs_update {
82			let src = &manager.borrow_entity_ids::<T>().unwrap();
83			let dst = self.cache_map.get_mut(&type_id).unwrap();
84			dst.clear();
85			for id in src.iter() {
86				dst.push(*id);
87			}
88			self.updated_frame_map.insert(type_id, manager.get_frame());
89		}
90
91		self.cache_map.get(&type_id)
92	}
93
94	pub fn borrow_ids_for_pair<
95		T1: 'static + Component,
96		T2: 'static + Component
97	>(&mut self, manager: &EntityManager) -> Option<&Vec<usize>> {
98		if !manager.has_component_manager::<T1>() ||
99			!manager.has_component_manager::<T2>() {
100			return None;
101		}
102
103		let type_id = TypeId::of::<(T1, T2)>();
104		let needs_update = if !self.cache_map.contains_key(&type_id) {
105			self.cache_map.insert(type_id, Vec::new());
106			true
107		} else {
108			let updated_frame = *self.updated_frame_map.get(&type_id).unwrap();
109			manager.get_updated_frame::<T1>() != updated_frame ||
110				manager.get_updated_frame::<T2>() != updated_frame
111		};
112
113		if needs_update {
114			// @TODO: Can be optimized if iterating a shorter array
115			let src = &manager.borrow_entity_ids::<T1>().unwrap();
116			let manager2 = manager.borrow_component_manager::<T2>();
117			let dst = self.cache_map.get_mut(&type_id).unwrap();
118			dst.clear();
119			for id in src.iter() {
120				if manager2.has(*id) {
121					dst.push(*id);
122				}
123			}
124			self.updated_frame_map.insert(type_id, manager.get_frame());
125		}
126
127		self.cache_map.get(&type_id)
128	}
129
130	pub fn borrow_ids_for_triple<
131		T1: 'static + Component,
132		T2: 'static + Component,
133		T3: 'static + Component
134	>(&mut self, manager: &EntityManager) -> Option<&Vec<usize>> {
135		if !manager.has_component_manager::<T1>() ||
136			!manager.has_component_manager::<T2>() ||
137			!manager.has_component_manager::<T3>() {
138			return None;
139		}
140
141		let type_id = TypeId::of::<(T1, T2, T3)>();
142		let needs_update = if !self.cache_map.contains_key(&type_id) {
143			self.cache_map.insert(type_id, Vec::new());
144			true
145		} else {
146			let updated_frame = *self.updated_frame_map.get(&type_id).unwrap();
147			manager.get_updated_frame::<T1>() != updated_frame ||
148				manager.get_updated_frame::<T2>() != updated_frame ||
149				manager.get_updated_frame::<T3>() != updated_frame
150		};
151
152		if needs_update {
153			// @TODO: Can be optimized if iterating the shortest array
154			let src = &manager.borrow_entity_ids::<T1>().unwrap();
155			let manager2 = manager.borrow_component_manager::<T2>();
156			let manager3 = manager.borrow_component_manager::<T3>();
157			let dst = self.cache_map.get_mut(&type_id).unwrap();
158			dst.clear();
159			for id in src.iter() {
160				if manager2.has(*id) && manager3.has(*id) {
161					dst.push(*id);
162				}
163			}
164			self.updated_frame_map.insert(type_id, manager.get_frame());
165		}
166
167		self.cache_map.get(&type_id)
168	}
169
170	pub fn borrow_ids_for_quad<
171		T1: 'static + Component,
172		T2: 'static + Component,
173		T3: 'static + Component,
174		T4: 'static + Component
175	>(&mut self, manager: &EntityManager) -> Option<&Vec<usize>> {
176		if !manager.has_component_manager::<T1>() ||
177			!manager.has_component_manager::<T2>() ||
178			!manager.has_component_manager::<T3>() ||
179			!manager.has_component_manager::<T4>() {
180			return None;
181		}
182
183		let type_id = TypeId::of::<(T1, T2, T3, T4)>();
184		let needs_update = if !self.cache_map.contains_key(&type_id) {
185			self.cache_map.insert(type_id, Vec::new());
186			true
187		} else {
188			let updated_frame = *self.updated_frame_map.get(&type_id).unwrap();
189			manager.get_updated_frame::<T1>() != updated_frame ||
190				manager.get_updated_frame::<T2>() != updated_frame ||
191				manager.get_updated_frame::<T3>() != updated_frame ||
192				manager.get_updated_frame::<T4>() != updated_frame
193		};
194
195		if needs_update {
196			// @TODO: Can be optimized if iterating the shortest array
197			let src = &manager.borrow_entity_ids::<T1>().unwrap();
198			let manager2 = manager.borrow_component_manager::<T2>();
199			let manager3 = manager.borrow_component_manager::<T3>();
200			let manager4 = manager.borrow_component_manager::<T4>();
201			let dst = self.cache_map.get_mut(&type_id).unwrap();
202			dst.clear();
203			for id in src.iter() {
204				if manager2.has(*id) && manager3.has(*id) && manager4.has(*id) {
205					dst.push(*id);
206				}
207			}
208			self.updated_frame_map.insert(type_id, manager.get_frame());
209		}
210
211		self.cache_map.get(&type_id)
212	}
213}
214
215pub struct EntityManager {
216	entities: Entities,
217	manager_map: HashMap<TypeId, Box<dyn ComponentManagerTrait>>,
218	frame: u64, // Rename
219	updated_frame_map: HashMap<TypeId, u64> // Rename
220}
221
222impl EntityManager {
223	pub fn new() -> Self {
224		EntityManager {
225			entities: Entities::new(),
226			manager_map: HashMap::new(),
227			frame: 0,
228			updated_frame_map: HashMap::new()
229		}
230	}
231
232	pub fn increment_frame(&mut self) {
233		self.frame += 1;
234	}
235
236	fn get_frame(&self) -> u64 {
237		self.frame
238	}
239
240	fn get_updated_frame<T: 'static + Component>(&self) -> u64 {
241		*self.updated_frame_map.get(&TypeId::of::<T>()).unwrap()
242	}
243
244	pub fn register<T: 'static + Component>(&mut self) -> &mut Self {
245		// @TODO: Error handling if already registered?
246		if ! self.has_component_manager::<T>() {
247			let type_id = TypeId::of::<T>();
248			self.manager_map.insert(type_id, Box::new(ComponentManager::<T>::new()));
249			self.updated_frame_map.insert(type_id, self.get_frame());
250		}
251		self
252	}
253
254	pub fn create_entity(&mut self) -> usize {
255		self.entities.create()
256	}
257
258	pub fn remove_entity(&mut self, entity_id: usize) {
259		let frame = self.get_frame();
260		for (_, manager) in self.manager_map.iter_mut() {
261			if manager.has(entity_id) {
262				manager.remove(entity_id);
263				// @TODO: Write comment for +1
264				self.updated_frame_map.insert(manager.get_type_id(), frame + 1);
265			}
266		}
267		self.entities.remove(entity_id);
268	}
269
270	pub fn add_component_to_entity<T: 'static + Component>(&mut self, entity_id: usize, component: T) -> &mut Self {
271		if ! self.has_component_manager::<T>() {
272			// @TODO: Better error handling
273			println!("Unknown component");
274			return self;
275		}
276		self.borrow_component_manager_mut::<T>()
277			.add(entity_id, component);
278		self.updated_frame_map.insert(TypeId::of::<T>(), self.get_frame());
279
280		self
281	}
282
283	fn borrow_entity_ids<T: 'static + Component>(&self) -> Option<&Vec<usize>> {
284		if ! self.has_component_manager::<T>() {
285			// @TODO: Better error handling
286			println!("Unknown component");
287			return None;
288		}
289		Some(self.borrow_component_manager::<T>().borrow_entity_ids())
290	}
291
292	pub fn borrow_component<T: 'static + Component>(&self, entity_id: usize) -> Option<&T> {
293		match self.has_component_manager::<T>() {
294			true => self.borrow_component_manager::<T>()
295				.borrow_component(entity_id),
296			false => None
297		}
298	}
299
300	pub fn borrow_component_mut<T: 'static + Component>(&mut self, entity_id: usize) -> Option<&mut T> {
301		match self.has_component_manager::<T>() {
302			true => self.borrow_component_manager_mut::<T>()
303				.borrow_component_mut(entity_id),
304			false => None
305		}
306	}
307
308	pub fn borrow_components<T: 'static + Component>(&self) -> Option<&Vec<T>> {
309		match self.has_component_manager::<T>() {
310			true => Some(
311				self.borrow_component_manager::<T>()
312					.borrow_components()
313			),
314			false => None
315		}
316	}
317
318	pub fn borrow_components_mut<T: 'static + Component>(&mut self) -> Option<&mut Vec<T>> {
319		match self.has_component_manager::<T>() {
320			true => Some(
321				self.borrow_component_manager_mut::<T>()
322					.borrow_components_mut()
323			),
324			false => None
325		}
326	}
327
328	pub fn borrow_component_pair_mut<
329		T1: 'static + Component,
330		T2: 'static + Component
331	>(&mut self, entity_id: usize) -> Option<(&mut T1, &mut T2)> {
332		if ! self.has_component_manager::<T1>() ||
333			! self.has_component_manager::<T2>() {
334			return None;
335		}
336
337		let type_id1 = TypeId::of::<T1>();
338		let type_id2 = TypeId::of::<T2>();
339
340		let manager1 = cast_manager_mut_unsafe(self.manager_map.get(&type_id1).unwrap());
341		let manager2 = cast_manager_mut_unsafe(self.manager_map.get(&type_id2).unwrap());
342
343		if !manager1.has(entity_id) || !manager2.has(entity_id) {
344			return None;
345		}
346
347		Some((
348			manager1.borrow_component_mut(entity_id).unwrap(),
349			manager2.borrow_component_mut(entity_id).unwrap()
350		))
351	}
352
353	pub fn borrow_component_triple_mut<
354		T1: 'static + Component,
355		T2: 'static + Component,
356		T3: 'static + Component
357	>(&mut self, entity_id: usize) -> Option<(&mut T1, &mut T2, &mut T3)> {
358		if ! self.has_component_manager::<T1>() ||
359			! self.has_component_manager::<T2>() ||
360			! self.has_component_manager::<T3>() {
361			return None;
362		}
363
364		let type_id1 = TypeId::of::<T1>();
365		let type_id2 = TypeId::of::<T2>();
366		let type_id3 = TypeId::of::<T3>();
367
368		let manager1 = cast_manager_mut_unsafe(self.manager_map.get(&type_id1).unwrap());
369		let manager2 = cast_manager_mut_unsafe(self.manager_map.get(&type_id2).unwrap());
370		let manager3 = cast_manager_mut_unsafe(self.manager_map.get(&type_id3).unwrap());
371
372		if !manager1.has(entity_id) || !manager2.has(entity_id) || !manager3.has(entity_id) {
373			return None;
374		}
375
376		Some((
377			manager1.borrow_component_mut(entity_id).unwrap(),
378			manager2.borrow_component_mut(entity_id).unwrap(),
379			manager3.borrow_component_mut(entity_id).unwrap()
380		))
381	}
382
383	pub fn borrow_component_quad_mut<
384		T1: 'static + Component,
385		T2: 'static + Component,
386		T3: 'static + Component,
387		T4: 'static + Component
388	>(&mut self, entity_id: usize) -> Option<(&mut T1, &mut T2, &mut T3, &mut T4)> {
389		if ! self.has_component_manager::<T1>() ||
390			! self.has_component_manager::<T2>() ||
391			! self.has_component_manager::<T3>() ||
392			! self.has_component_manager::<T4>() {
393			return None;
394		}
395
396		let type_id1 = TypeId::of::<T1>();
397		let type_id2 = TypeId::of::<T2>();
398		let type_id3 = TypeId::of::<T3>();
399		let type_id4 = TypeId::of::<T4>();
400
401		let manager1 = cast_manager_mut_unsafe(self.manager_map.get(&type_id1).unwrap());
402		let manager2 = cast_manager_mut_unsafe(self.manager_map.get(&type_id2).unwrap());
403		let manager3 = cast_manager_mut_unsafe(self.manager_map.get(&type_id3).unwrap());
404		let manager4 = cast_manager_mut_unsafe(self.manager_map.get(&type_id4).unwrap());
405
406		if !manager1.has(entity_id) || !manager2.has(entity_id) || !manager3.has(entity_id) || !manager4.has(entity_id) {
407			return None;
408		}
409
410		Some((
411			manager1.borrow_component_mut(entity_id).unwrap(),
412			manager2.borrow_component_mut(entity_id).unwrap(),
413			manager3.borrow_component_mut(entity_id).unwrap(),
414			manager4.borrow_component_mut(entity_id).unwrap()
415		))
416	}
417
418	fn has_component_manager<T: 'static + Component>(&self) -> bool {
419		let type_id = TypeId::of::<T>();
420		self.manager_map.contains_key(&type_id)
421	}
422
423	fn borrow_component_manager<T: 'static + Component>(&self) -> &ComponentManager<T> {
424		let type_id = TypeId::of::<T>();
425		cast_manager(self.manager_map.get(&type_id).unwrap().as_ref())
426	}
427
428	fn borrow_component_manager_mut<T: 'static + Component>(&mut self) -> &mut ComponentManager<T> {
429		let type_id = TypeId::of::<T>();
430		cast_manager_mut(self.manager_map.get_mut(&type_id).unwrap().as_mut())
431	}
432}
433
434// @TODO: Write comment
435fn cast_manager_mut_unsafe<T: 'static + Component>
436	(manager: &Box<dyn ComponentManagerTrait>) -> &mut ComponentManager<T> {
437	let ptr = cast_manager(manager.as_ref())
438		as *const ComponentManager<T> as *mut ComponentManager<T>;
439	unsafe { transmute(ptr) }
440}
ecs_rust/entity_manager.rs

ecs_rust/
entity_manager.rs
