Struct specs::world::EntityResBuilder

#[must_use = "Please call .build() on this to finish building it."]
pub struct EntityResBuilder<'a> {
    pub entity: Entity,
    pub entities: &'a EntitiesRes,
    // some fields omitted
}

An entity builder from EntitiesRes. Allows building an entity with its components if you have mutable access to the component storages.

Fields

entity: Entity

The entity being built

entities: &'a EntitiesRes

The active borrow to EntitiesRes, used to delete the entity if the builder is dropped without called build().

Implementations

impl<'a> EntityResBuilder<'a>

pub fn marked<M>(
    self,
    storage: &mut WriteStorage<'_, M>,
    alloc: &mut M::Allocator
) -> Self where
    M: Marker, 

Add a Marker to the entity with the associated allocator, and component storage.

Examples

use specs::{
    prelude::*,
    saveload::{SimpleMarker, SimpleMarkerAllocator},
};

struct NetworkSync;

let mut world = World::new();
world.register::<SimpleMarker<NetworkSync>>();
world.insert(SimpleMarkerAllocator::<NetworkSync>::new());

let mut storage = world.write_storage::<SimpleMarker<NetworkSync>>();
let mut alloc = world.write_resource::<SimpleMarkerAllocator<NetworkSync>>();

let entities = world.entities();
entities
    .build_entity()
    /* .with(Component1) */
    .marked(&mut storage, &mut alloc)
    .build();

impl<'a> EntityResBuilder<'a>

pub fn with<T: Component>(self, c: T, storage: &mut WriteStorage<'_, T>) -> Self

Appends a component and associates it with the entity.

pub fn build(self) -> Entity

Finishes the building and returns the entity.

Trait Implementations

impl<'a> Drop for EntityResBuilder<'a>

fn drop(&mut self)

Executes the destructor for this type.