Struct shipyard::EntitiesViewMut

pub struct EntitiesViewMut<'a> { /* fields omitted */ }

Exclusive view over Entities storage.

Methods from Deref<Target = Entities>

pub fn is_alive(&self, entity: EntityId) -> bool

Returns true if entity matches a living entity.

pub fn add_component<S: AddComponent>(
    &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

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

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<'_>

Creates multiple new entities and returns an iterator yielding the new EntityIds.
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<'_>

Creates an iterator over all entities.

pub fn spawn(&mut self, entity: EntityId) -> bool

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> BorrowInfo for EntitiesViewMut<'a>

fn borrow_info(infos: &mut Vec<TypeInfo>)

This information is used during workload creation to determine which systems can run in parallel.

impl Deref for EntitiesViewMut<'_>

type Target = Entities

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for EntitiesViewMut<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl IntoBorrow for EntitiesViewMut<'_>

type Borrow = EntitiesMutBorrower

Helper type almost allowing GAT on stable.