initial commit

crates/comet_ecs/src/world.rs

@@ -0,0 +1,209 @@
+use std::any::TypeId;
+use bit_set::BitSet;
+use crate::{
+	Entity,
+	Component,
+	Transform2D,
+	Transform3D,
+	ComponentStorage,
+	SparseSet,
+	IdQueue,
+	Archetypes,
+	ComponentSet
+};
+use comet_log::*;
+
+pub struct World {
+	dimension: String,
+	id_queue: IdQueue,
+	next_id: u32,
+	entities: Vec<Option<Entity>>,
+	components: ComponentStorage,
+	archetypes: Archetypes
+}
+
+impl World {
+	pub fn new(dimension: &str) -> Self {
+		let mut component_storage = ComponentStorage::new();
+		match dimension {
+			"2D" => component_storage.register_component::<Transform2D>(0),
+			"3D" => component_storage.register_component::<Transform3D>(0),
+			_ => {}
+		}
+
+		Self {
+			dimension: dimension.to_string(),
+			id_queue: IdQueue::new(),
+			next_id: 0,
+			entities: Vec::new(),
+			components: component_storage,
+			archetypes: Archetypes::new()
+		}
+	}
+
+	pub fn active_entities(&self) -> u32 {
+		self.entities.len() as u32 - self.id_queue.size()
+	}
+
+	fn get_next_id(&mut self) {
+		if self.id_queue.is_empty() {
+			self.next_id = self.entities.len() as u32;
+			return;
+		}
+		if self.next_id > self.id_queue.front().unwrap() || self.entities[self.next_id as usize] != None {
+			self.next_id = self.id_queue.dequeue().unwrap();
+		}
+	}
+
+	pub fn dimension(&self) -> &String {
+		&self.dimension
+	}
+
+	pub fn id_queue(&self) -> &IdQueue {
+		&self.id_queue
+	}
+
+	pub fn entities(&self) -> &Vec<Option<Entity>> {
+		&self.entities
+	}
+
+	pub fn components(&self) -> &ComponentStorage {
+		&self.components
+	}
+
+	pub fn components_mut(&mut self) -> &mut ComponentStorage {
+		&mut self.components
+	}
+
+	pub fn new_entity(&mut self) -> u32 {
+		let id = self.next_id;
+		if (self.next_id as usize) >= self.entities.len() {
+			self.entities.push(Some(Entity::new(self.next_id)));
+			match self.dimension.as_str() {
+				"2D" => self.add_component::<Transform2D>(self.next_id as usize, Transform2D::new()),
+				"3D" => self.add_component::<Transform3D>(self.next_id as usize, Transform3D::new()),
+				_ => {}
+			}
+			self.get_next_id();
+			return id;
+		}
+		self.entities[self.next_id as usize] = Some(Entity::new(self.next_id));
+		println!("{:?}", self.dimension);
+		match self.dimension.as_str() {
+			"2D" => self.add_component::<Transform2D>(self.next_id as usize, Transform2D::new()),
+			"3D" => self.add_component::<Transform3D>(self.next_id as usize, Transform3D::new()),
+			_ => {}
+		}
+		self.get_next_id();
+		id
+	}
+
+	pub fn get_entity(&self, entity_id: usize) -> &Entity {
+		assert_ne!(self.entities.get(entity_id), None, "There is no entity with this ID ({}) in the world!", entity_id);
+		self.entities.get(entity_id).unwrap().as_ref().unwrap()
+	}
+
+	pub fn get_entity_mut(&mut self, entity_id: usize) -> &mut Entity {
+		assert_ne!(self.entities.get(entity_id), None, "There is no entity with this ID ({}) in the world!", entity_id);
+		self.entities.get_mut(entity_id).unwrap().as_mut().unwrap()
+		//self.entities.get_mut(id).unwrap()
+	}
+
+	pub fn delete_entity(&mut self, entity_id: usize) {
+		self.entities[entity_id] = None;
+		//self.get_entity(id);
+		for (key, value) in self.components.iter_mut() {
+			value.remove::<u8>(entity_id);
+		}
+		self.id_queue.sorted_enqueue(entity_id as u32);
+		self.get_next_id();
+		self.remove_entity_from_archetype_subsets(entity_id as u32, self.get_component_set(entity_id));
+		info!(format!("Deleted entity! ID: {}", entity_id));
+	}
+
+	fn create_archetype(&mut self, components: ComponentSet) {
+		self.archetypes.create_archetype(components);
+	}
+
+	fn add_entity_to_archetype(&mut self, entity_id: u32, components: ComponentSet) {
+		self.archetypes.add_entity_to_archetype(&components, entity_id);
+	}
+
+	fn remove_entity_from_archetype(&mut self, entity_id: u32, components: ComponentSet) {
+		self.archetypes.remove_entity_from_archetype(&components, entity_id);
+	}
+
+	fn remove_entity_from_archetype_subsets(&mut self, entity_id: u32, components: ComponentSet) {
+		let component_sets = self.archetypes.component_sets();
+		let keys: Vec<ComponentSet> = component_sets.iter()
+			.enumerate()
+			.filter_map(|(i, &ref elem)| if elem.is_subset(&components) { Some(i) } else { None })
+			.collect::<Vec<usize>>()
+			.iter()
+			.map(|index| component_sets[*index].clone())
+			.collect::<Vec<ComponentSet>>();
+
+		for key in keys {
+			self.remove_entity_from_archetype(entity_id, key.clone());
+			if self.archetypes.get_archetype(&key).unwrap().len() == 0 {
+				self.archetypes.remove_archetype(&key);
+			}
+		}
+	}
+
+	fn get_component_set(&self, entity_id: usize) -> ComponentSet {
+		let components = self.entities.get(entity_id).unwrap().as_ref().unwrap().get_components().iter().collect::<Vec<usize>>();
+		let type_ids = components.iter().map(|index| self.components.keys[*index]).collect::<Vec<TypeId>>();
+		ComponentSet::from_ids(type_ids)
+	}
+
+	pub fn register_component<T: Component + 'static>(&mut self) {
+		self.components.register_component::<T>(self.entities.len());
+		info!(format!("Registered component: {}", T::type_name()));
+	}
+
+	pub fn deregister_component<T: Component + 'static>(&mut self) {
+		self.components.deregister_component::<T>();
+		info!(format!("Deregistered component: {}", T::type_name()));
+	}
+
+	pub fn add_component<T: Component + 'static>(&mut self, entity_id: usize, component: T) {
+		assert_ne!(self.entities.get(entity_id), None, "There is no entity with this ID ({}) in the world!", entity_id);
+		self.components.set_component(entity_id, component);
+		let component_index = self.components.keys.iter_mut().position(|x| *x == T::type_id()).unwrap();
+
+		self.get_entity_mut(entity_id).add_component(component_index);
+
+		if !self.archetypes.contains_archetype(&self.get_component_set(entity_id)) {
+			self.create_archetype(self.get_component_set(entity_id));
+		}
+		self.add_entity_to_archetype(entity_id as u32, self.get_component_set(entity_id));
+
+		info!(format!("Added component {} to entity {}", T::type_name(), entity_id));
+		debug!(format!("{:?}", self.archetypes));
+	}
+
+	pub fn remove_component<T: Component + 'static>(&mut self, entity_id: usize) {
+		self.components.remove_component::<T>(entity_id);
+		self.remove_entity_from_archetype_subsets(entity_id as u32, self.get_component_set(entity_id));
+		info!(format!("Removed component {} from entity {}", T::type_name(), entity_id));
+	}
+
+	pub fn get_component<T: Component + 'static>(&self, entity_id: usize) -> &T {
+		assert_ne!(self.entities.get(entity_id), None, "There is no entity with this ID ({}) in the world!", entity_id);
+		assert!(self.components.get_component::<T>(entity_id) != None, "There is no component {} bound to the entity {} in the world!", T::type_name(), entity_id);
+		self.components.get_component::<T>(entity_id).unwrap()
+	}
+
+	pub fn get_component_mut<T: Component + 'static>(&mut self, entity_id: usize) -> &mut T {
+		assert_ne!(self.entities.get(entity_id), None, "There is no entity with this ID ({}) in the world!", entity_id);
+		assert!(self.components.get_component::<T>(entity_id) != None, "There is no component {} bound to the entity {} in the world!", T::type_name(), entity_id);
+		self.components.get_component_mut::<T>(entity_id).unwrap()
+	}
+
+	pub fn get_entities_with(&self, components: ComponentSet) -> Vec<u32> {
+		assert!(self.archetypes.contains_archetype(&components), "The given components {:?} are not registered in the world!", components);
+		info!(format!("Querying entities with components: {:?}", components));
+		self.archetypes.get_archetype(&components).unwrap().clone()
+	}
+}