Struct shipyard::Entities [−][src]
Entities holds the EntityIds to all entities: living, removed and dead.
A living entity is an entity currently present, with or without component.
Removed and dead entities don’t have any component.
The big difference is that removed ones can become alive again.
The life cycle of an entity looks like this:
Generation -> Deletion -> Dead
⬑–––––↵
Implementations
impl Entities
[src]
pub fn is_alive(&self, entity: EntityId) -> bool
[src]
Returns true
if entity
matches a living entity.
pub fn add_component<S: AddComponent>(
&self,
entity: EntityId,
storages: S,
component: S::Component
)
[src]
&self,
entity: EntityId,
storages: S,
component: S::Component
)
Adds component
to entity
, multiple components can be added at the same time using a tuple.
Entities
is only borrowed immutably.
Panics
entity
is not alive.
Example
use shipyard::{EntitiesView, ViewMut, World}; let mut world = World::new(); let entity = world.add_entity(()); let (entities, mut u32s) = world.borrow::<(EntitiesView, ViewMut<u32>)>().unwrap(); entities.add_component(entity, &mut u32s, 0);
pub fn delete_unchecked(&mut self, entity_id: EntityId) -> bool
[src]
Deletes an entity, returns true if the entity was alive.
If the entity has components, they will not be deleted and still be accessible using this id.
pub fn add_entity<T: AddEntity>(
&mut self,
storages: T,
component: T::Component
) -> EntityId
[src]
&mut self,
storages: T,
component: T::Component
) -> EntityId
Stores component
in a new entity and returns its EntityId
.
Multiple components can be added at the same time using a tuple.
Example:
use shipyard::{EntitiesViewMut, ViewMut, World}; let world = World::new(); let (mut entities, mut usizes, mut u32s) = world .borrow::<(EntitiesViewMut, ViewMut<usize>, ViewMut<u32>)>() .unwrap(); let entity = entities.add_entity((&mut usizes, &mut u32s), (0, 1)); assert_eq!(usizes[entity], 0); assert_eq!(u32s[entity], 1);
pub fn bulk_add_entity<T: AddEntity + BulkReserve, I: IntoIterator<Item = T::Component>>(
&mut self,
storages: T,
component: I
) -> BulkEntityIter<'_>ⓘNotable traits for BulkEntityIter<'a>
impl<'a> Iterator for BulkEntityIter<'a> type Item = EntityId;
[src]
&mut self,
storages: T,
component: I
) -> BulkEntityIter<'_>ⓘ
Notable traits for BulkEntityIter<'a>
impl<'a> Iterator for BulkEntityIter<'a> type Item = EntityId;
Creates multiple new entities and returns an iterator yielding the new EntityId
s.
Multiple components can be added at the same time using a tuple.
Example
use shipyard::{EntitiesViewMut, ViewMut, World}; let world = World::new(); let (mut entities, mut usizes, mut u32s) = world .borrow::<(EntitiesViewMut, ViewMut<usize>, ViewMut<u32>)>() .unwrap(); let entity0 = entities.bulk_add_entity((), (0..1).map(|_| {})).next(); let entity1 = entities.bulk_add_entity(&mut u32s, 1..2).next(); let new_entities = entities.bulk_add_entity((&mut u32s, &mut usizes), (10..20).map(|i| (i as u32, i)));
pub fn iter(&self) -> EntitiesIter<'_>
[src]
Creates an iterator over all entities.
pub fn spawn(&mut self, entity: EntityId) -> bool
[src]
Make the given entity alive.
Does nothing if an entity with a greater generation is already at this index.
Returns true
if the entity is successfully spawned.
Trait Implementations
impl<'a> IntoIterator for &'a Entities
[src]
type Item = EntityId
The type of the elements being iterated over.
type IntoIter = EntitiesIter<'a>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl Storage for Entities
[src]
fn clear(&mut self)
[src]
fn memory_usage(&self) -> Option<StorageMemoryUsage>
[src]
fn any(&self) -> &dyn Any
[src]
fn any_mut(&mut self) -> &mut dyn Any
[src]
fn delete(&mut self, _entity: EntityId)
[src]
fn name(&self) -> Cow<'static, str>
[src]
fn sparse_array(&self) -> Option<&SparseArray<[EntityId; 32]>>
[src]
Auto Trait Implementations
impl RefUnwindSafe for Entities
impl Send for Entities
impl Sync for Entities
impl Unpin for Entities
impl UnwindSafe for Entities
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,