Struct LazyBuilder

pub struct LazyBuilder<'a> {
    pub entity: Entity,
    pub lazy: &'a LazyUpdate,
}

Like EntityBuilder, but inserts the component lazily, meaning on maintain. If you need those components to exist immediately, you have to insert them into the storages yourself.

Fields

entity: Entity

The entity that we’re inserting components for.

lazy: &'a LazyUpdate

The lazy update reference.

Trait Implementations

impl<'a> Builder for LazyBuilder<'a>

fn with<C>(self, component: C) -> Self

where C: Send + Sync + Component,

Inserts a component using LazyUpdate.

If a component was already associated with the entity, it will overwrite the previous component.

fn build(self) -> Entity

Finishes the building and returns the built entity. Please note that no component is associated to this entity until you call World::maintain.

fn maybe_with<C: Component + Send + Sync>(self, c: Option<C>) -> Self

where Self: Sized,

Convenience method that calls self.with(component) if Some(component) is provided

impl<'a> MarkedBuilder for LazyBuilder<'a>

fn marked<M>(self) -> Self

where M: Marker,

Add a Marker to the entity by fetching the associated allocator.

This will be applied on the next world.maintain().

Examples

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

struct NetworkSync;

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

let my_entity = lazy
    .create_entity(&entities)
    /* .with(Component1) */
    .marked::<SimpleMarker<NetworkSync>>()
    .build();

Panics

Panics during world.maintain() in case there’s no allocator added to the World.