Struct Ecs

pub struct Ecs<'ecs> { /* private fields */ }

A handle to EcsApp, which is real ecs instance.

This type is just for easy use in some cases such as writing a command. By removing verbose generic parameters, clients can declare parameters as Ecs instead of EcsApp<W, S> in their command functions for example.

Implementations

impl<'ecs> Ecs<'ecs>

pub fn default<Wp, W, G>(pool: Wp, groups: G) -> EcsApp<W, RandomState>

where Wp: Into<Vec<W>>, W: Work + 'static, G: AsRef<[usize]>,

Creates EcsApp with the given worker pool and group information.

The returned instance uses RandomState as hasher builder for its internal data structures. If you want another, call Ecs::create instead.

Examples

use my_ecs::prelude::*;

// Creates `EcsApp` with one group consisting of 4 workers.
let pool = WorkerPool::with_len(4);
let ecs = Ecs::default(pool, [4]);

// Creates `EcsApp` with two groups consisting of 2 workers respectively.
let pool = WorkerPool::with_len(4);
let ecs = Ecs::default(pool, [2, 2]);

pub fn create<Wp, W, G, S>(pool: Wp, groups: G) -> EcsApp<W, S>

where Wp: Into<Vec<W>>, W: Work + 'static, G: AsRef<[usize]>, S: BuildHasher + Default + 'static,

Creates EcsApp with the given workers, group information, and hasher builder type.

Examples

use my_ecs::prelude::*;
use std::hash::{BuildHasher, DefaultHasher};

// Something like `std::hash::RandomState`.
#[derive(Default)] struct FixedState;
impl BuildHasher for FixedState {
    type Hasher = DefaultHasher;
    fn build_hasher(&self) -> Self::Hasher {
        DefaultHasher::new()
    }
}

// Creates `EcsApp` with one group consisting of 4 workers.
let pool = WorkerPool::with_len(4);
let ecs: EcsApp<_, FixedState> = Ecs::create(pool, [4]);

// Creates `EcsApp` with two groups consisting of 2 workers respectively.
let pool = WorkerPool::with_len(4);
let ecs: EcsApp<_, FixedState> = Ecs::create(pool, [2, 2]);

Trait Implementations

impl<'ecs> Debug for Ecs<'ecs>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EcsEntry for Ecs<'_>

fn add_system<T, Sys>( &mut self, desc: T, ) -> WithResult<&mut Self, SystemId, EcsError<SystemDesc<Sys>>>

where T: Into<SystemDesc<Sys>>, Sys: System,

Adds the given system.

fn add_once_system<T, Req, F>( &mut self, sys: T, ) -> WithResult<&mut Self, SystemId, EcsError<SystemDesc<FnOnceSystem<Req, F>>>>

where T: Into<FnOnceSystem<Req, F>>, FnOnceSystem<Req, F>: System,

Adds the given FnOnce system.

fn unregister_system( &mut self, sid: SystemId, ) -> WithResult<&mut Self, (), EcsError>

Unregisters an inactive system for the given system id.

fn activate_system( &mut self, target: SystemId, at: InsertPos, live: Tick, ) -> WithResult<&mut Self, (), EcsError>

Activates a system for the given system id if it’s not active.

fn inactivate_system( &mut self, sid: SystemId, ) -> WithResult<&mut Self, (), EcsError>

Inactivates a system for the given system id.

fn register_entity( &mut self, desc: EntityReg, ) -> WithResult<&mut Self, EntityIndex, EcsError>

Registers an entity type from the given descriptor.

fn unregister_entity<C>( &mut self, ) -> WithResult<&mut Self, Box<dyn ContainEntity>, EcsError>

where C: Components,

Unregisters an entity type.

fn add_entity<E>( &mut self, ei: EntityIndex, value: E, ) -> WithResult<&mut Self, EntityId, EcsError<E>>

where E: Entity,

Adds an entity.

fn remove_entity( &mut self, eid: EntityId, ) -> WithResult<&mut Self, (), EcsError>

Removes an entity.

fn add_resource<T>( &mut self, desc: T, ) -> WithResult<&mut Self, ResourceIndex, EcsError<ResourceDesc>>

where T: Into<ResourceDesc>,

Adds the given resource.

fn remove_resource<R>(&mut self) -> WithResult<&mut Self, Option<R>, EcsError>

where R: Resource,

Removes a resource from the given resource type.

fn get_resource<R>(&self) -> Option<&R>

where R: Resource,

Retrieves shared reference to a resource for the given resource type.

fn get_resource_mut<R>(&mut self) -> Option<&mut R>

where R: Resource,

Retrieves mutable reference to a resource for the given resource type.

fn get_resource_index<R>(&self) -> Option<ResourceIndex>

where R: Resource,

Returns resource index for the given resource type.

fn execute_commands<T>( &mut self, cmds: T, ) -> WithResult<&mut Self, (), Box<dyn Error + Send + Sync + 'static>>

where T: HelpExecuteManyCommands,

Executes the given commands in order.

fn execute_command<F, R>( &mut self, f: F, ) -> WithResult<&mut Self, (), Box<dyn Error + Send + Sync + 'static>>

where F: FnOnce(Commander<'_>) -> R, R: Command,

Execute the given command.

fn errors(&mut self) -> Vec<Box<dyn Error + Send + Sync + 'static>>

Returns errors generated from commands or futures.

fn add_systems<T, Systems>( &mut self, descs: T, ) -> WithResult<&mut Self, (), EcsError>

where T: HelpAddManySystems<Systems>,

Adds the given systems.

fn add_once_systems<T, Once>( &mut self, descs: T, ) -> WithResult<&mut Self, (), EcsError>

where T: HelpAddManyOnce<Once>,

Adds the given FnOnce systems.

fn register_entity_of<T>( &mut self, ) -> WithResult<&mut Self, EntityIndex, EcsError>

where T: AsEntityReg,

Registers an entity type.

fn add_resources<T>(&mut self, descs: T) -> WithResult<&mut Self, (), EcsError>

where T: HelpAddManyResources,

Adds the given resources.