Struct EntitiesAndComponentsThreadSafe

pub struct EntitiesAndComponentsThreadSafe<'a> { /* private fields */ }

This struct is a thread safe version of the EntitiesAndComponents struct It is used to allow systems to access the entities and components in parallel It will not allow any non send sync components to be accessed or added

Implementations

impl<'b> EntitiesAndComponentsThreadSafe<'b>

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> + Send + Sync>( &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 try_get_component<T: Component + Send + Sync>( &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

pub fn try_get_component_mut<T: Component + Send + Sync>( &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

pub fn get_components<'a, T: ComponentsRef<'a> + Send + Sync + '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

pub fn get_components_mut<'a, T: ComponentsMut<'a> + Send + Sync + '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

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

Gets a tuple of references to components on an entity

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

Gets a mutable reference to a component on an entity

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

Adds a component to an entity If the component already exists on the entity, it will be overwritten

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

Removes a component from an entity

pub fn get_entities_with_component<T: Component + Send + Sync>( &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 + Send + Sync>( &self, ) -> usize

gets the number of entities with a certain component

pub fn get_entity_with_component<T: Component + Send + Sync>( &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 + Send + Sync>(&self) -> Option<&T>

Gets a resource from the game engine

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

Adds a resource to the game engine

pub fn remove_resource<T: Resource + Send + Sync>(&mut self)

Removes a resource from the game engine

pub fn get_resource_mut<T: Resource + Send + Sync>(&mut self) -> Option<&mut T>

Gets a resource from the game engine mutably, panics if the resource does not exist

pub fn does_entity_exist(&self, entity: Entity) -> bool

Checks if an entity exists in the world

pub fn get_children(&self, entity: Entity) -> Vec<Entity>

gets the children of an entity

pub fn get_parent(&self, entity: Entity) -> Option<Entity>

gets the parent of an entity returns None if the entity is a root entity

pub fn set_parent( &mut self, child_entity: Entity, parent_entity: Entity, ) -> bool

sets the parent of an entity if the entity already has a parent it will be changed returns true if the parent was set, false if the parent was not set (inverse relationship detected)

pub fn remove_parent(&mut self, child_entity: Entity)

this function removes the link between a parent and a child making the child a root entity

pub fn get_entities_with_children( &self, ) -> Flatten<IntoIter<Values<'_, DefaultKey, Entity>>>

gets the entities with children

pub fn get_entities_with_parent( &self, ) -> Flatten<IntoIter<Values<'_, DefaultKey, Entity>>>

gets the entities with parents

Trait Implementations

impl Send for EntitiesAndComponentsThreadSafe<'_>

impl Sync for EntitiesAndComponentsThreadSafe<'_>