Struct ABC_ECS::EntitiesAndComponents

pub struct EntitiesAndComponents { /* private fields */ }

This struct holds all the entities and components in the game engine It is the main way to interact with the game engine, it is seperate from systems for safety reasons

Implementations

impl EntitiesAndComponents

pub fn new() -> Self

Creates a new EntitiesAndComponents struct

pub fn add_entity(&mut self) -> Entity

Adds an entity to the game engine Returns the entity

pub fn add_entity_with<T: OwnedComponents<Input = T>>( &mut self, components: T ) -> Entity

Adds an entity to the game engine with components

pub fn remove_entity(&mut self, entity: Entity)

Removes an entity from the game engine

pub fn get_entities(&self) -> Vec<Entity>

Gets a reference to all the entities in the game engine Should rarely if ever be used

pub fn get_nth_entity(&self, index: usize) -> Option<Entity>

Gets a copy of an entity at a certain index

pub fn get_entity_count(&self) -> usize

Gets the number of entities in the game engine

pub fn get_all_components(&self, entity: Entity) -> &Map<dyn Any + 'static>

Gets a reference to all the components on an entity Returns an AnyMap, which can be used to get a reference to a component This should rarely if ever be used

pub fn get_all_components_mut( &mut self, entity: Entity ) -> &mut Map<dyn Any + 'static>

Gets a mutable reference to the components on an entity If the entity does not exist, it will panic This should rarely if ever be used

pub fn try_get_component<T: Component>(&self, entity: Entity) -> Option<&Box<T>>

Gets a reference to a component on an entity If the component does not exist on the entity, it will return None panics if the entity does not exist

pub fn try_get_component_mut<T: Component>( &mut self, entity: Entity ) -> Option<&mut Box<T>>

Gets a mutable reference to a component on an entity If the component does not exist on the entity, it will return None panics if the entity does not exist

pub fn get_components<'a, T: ComponentsRef<'a> + 'static>( &'a self, entity: Entity ) -> T::Result

Gets a tuple of references to components on an entity If the component does not exist on the entity, it will panic panics if the entity does not exist

pub fn get_components_mut<'a, T: ComponentsMut<'a> + 'static>( &'a mut self, entity: Entity ) -> T::Result

Gets a mutable reference to a component on an entity If the component does not exist on the entity, it will panic panics if the entity does not exist

pub fn try_get_components<'a, T: TryComponentsRef<'a> + 'static>( &'a self, entity: Entity ) -> T::Result

Gets a tuple of references to components on an entity If the component does not exist on the entity it will return None panics if the entity does not exist

pub fn try_get_components_mut<'a, T: TryComponentsMut<'a> + 'static>( &'a mut self, entity: Entity ) -> T::Result

Gets a mutable reference to a component on an entity If the component does not exist on the entity it will return None panics if the entity does not exist

pub fn add_component_to<T: Component>(&mut self, entity: Entity, component: T)

Adds a component to an entity If the component already exists on the entity, it will be overwritten panics if the entity does not exist

pub fn remove_component_from<T: Component>(&mut self, entity: Entity)

Removes a component from an entity If the component does not exist on the entity, it will do nothing panics if the entity does not exist

pub fn get_entities_with_component<T: Component>( &self ) -> Flatten<IntoIter<Values<'_, DefaultKey, Entity>>>

returns an iterator over all entities with a certain component

pub fn get_entity_count_with_component<T: Component>(&self) -> usize

gets the number of entities with a certain component

pub fn get_entity_with_component<T: Component>( &self, index: usize ) -> Option<Entity>

gets the nth entity with a certain component O(n) use get_entities_with_component if you need to iterate over all entities with a certain component

pub fn get_resource<T: Resource>(&self) -> Option<&T>

Gets a resource from the game engine

pub fn add_resource<T: Resource>(&mut self, resource: T)

Adds a resource to the game engine