sim-ecs - v0.6.5
    Preparing search index...

    Class RuntimeWorld

    Implements

    Index

    Constructors

    constructor

    Properties

    addEntitiesToGroup addEntity addEntityToGroup addResource assimilateGroup buildEntity clearEntities clearGroups clearResources config createEntity createGroup data eventBus getEntities getGroupEntities getResource getResources hasEntity hasResource load merge name popState pushState refreshEntityQueryRegistration removeEntity removeGroup removeResource replaceResource save

    Accessors

    awaiter currentState isRunning systemActions transitionActions

    Methods

    [dispose] flushCommands hmrReplaceSystem prepare start step stop

    Constructors

    Properties

    addEntitiesToGroup: (
        this: PreptimeWorld | RuntimeWorld,
        groupHandle: number,
        entities:
            | IterableIterator<Readonly<IEntity>, any, any>
            | readonly Readonly<IEntity>[],
    ) => void = addEntitiesToGroup

    Add several entities in this world to a group in this world

    addEntity: (this: RuntimeWorld, entity: Readonly<IEntity>) => void = addEntity

    Add an entity to this world

    addEntityToGroup: (
        this: PreptimeWorld | RuntimeWorld,
        groupHandle: number,
        entity: Readonly<IEntity>,
    ) => void = addEntityToGroup

    Add an entity in this world to a group in this world

    addResource: <T extends object>(
        this: RuntimeWorld,
        obj: Readonly<T> | TTypeProto<T>,
        ...args: readonly unknown[],
    ) => T = addResource

    Add a resource to this world and returns the resource instance

    Type declaration

      • <T extends object>(
            this: RuntimeWorld,
            obj: Readonly<T> | TTypeProto<T>,
            ...args: readonly unknown[],
        ): T

      • Type Parameters

        • T extends object

        Parameters

        • this: RuntimeWorld
        • obj: Readonly<T> | TTypeProto<T>
        • ...args: readonly unknown[]

          constructor parameters

        Returns T

    assimilateGroup: (
        this: PreptimeWorld | RuntimeWorld,
        otherWorld: Readonly<IPreptimeWorld>,
        handle: number,
    ) => number = assimilateGroup

    Move group from other world to this one. A new handle will be generated!

    buildEntity: (this: IMutableWorld, uuid?: string) => IEntityBuilder = buildEntity

    Convenience builder to create a new Entity

    clearEntities: (this: IMutableWorld & (PreptimeWorld | RuntimeWorld)) => void = clearEntities

    Clear all entities and groups from this world

    clearGroups: (this: PreptimeWorld | RuntimeWorld) => void = clearGroups

    Disband all groups. Entities will not be removed

    clearResources: (this: PreptimeWorld | RuntimeWorld) => void = clearResources

    Remove all resources from this world

    config: IRuntimeWorldInitConfig

    Initial config

    createEntity: (this: IMutableWorld) => IEntity = createEntity

    Create a new entity and add it to this world

    createGroup: (this: PreptimeWorld | RuntimeWorld) => number = createGroup

    Create a new group and add it to this world

    data: IRuntimeWorldData

    Data to operate on. This data may mutate at any time

    eventBus: EventBus = ...

    Architecture to send messages between systems

    getEntities: (
        this: PreptimeWorld | RuntimeWorld,
        query?: Readonly<IEntitiesQuery>,
    ) => IterableIterator<IEntity> = getEntities

    Query entities and find the ones with a certain combination of component. To get a single entity by ID, please use the global function getEntity()

    getGroupEntities: (
        this: PreptimeWorld | RuntimeWorld,
        groupHandle: number,
    ) => IterableIterator<IEntity> = getGroupEntities

    Get all entities associated with a group

    getResource: <T extends object>(this: RuntimeWorld, type: TTypeProto<T>) => T = getResource

    Get a resource which was previously stored

    getResources: (
        this: PreptimeWorld | RuntimeWorld,
        types?: readonly TExistenceQueryParameter<any>[],
    ) => IterableIterator<object> = getResources

    Get all resources stored in this world. Useful for debugging

    hasEntity: (this: RuntimeWorld, entity: Readonly<IEntity>) => boolean = hasEntity

    Check whether an entity exists in this world

    hasResource: <T extends object>(
        this: PreptimeWorld | RuntimeWorld,
        obj: Readonly<T> | TTypeProto<T>,
    ) => boolean = hasResource

    Check if a resource was stored

    load: (
        this: RuntimeWorld,
        prefab: Readonly<ISerialFormat>,
        options?: Readonly<ISerDeOptions<TDeserializer>>,
        intoGroup?: number,
    ) => number = load

    Load a prefab

    merge: (
        this: IMutableWorld & (PreptimeWorld | RuntimeWorld),
        elsewhere: Readonly<IPreptimeWorld>,
        intoGroup?: number,
    ) => [number, IEntity[]] = merge

    Merge entities from another world into this one

    name: string

    World's name

    popState: (this: RuntimeWorld) => Promise<void> = popState
    pushState: (this: RuntimeWorld, NewState: IIStateProto) => Promise<void> = pushState
    refreshEntityQueryRegistration: (
        this: RuntimeWorld,
        entity: Readonly<IEntity>,
    ) => void = refreshEntityQueryRegistration

    Refresh an entity's registration with queries. This is useful e.g. after an entity was mutated

    removeEntity: (this: RuntimeWorld, entity: Readonly<IEntity>) => void = removeEntity

    Remove an entity from this world

    removeGroup: (
        this: IMutableWorld & (PreptimeWorld | RuntimeWorld),
        groupHandle: number,
    ) => void = removeGroup

    Remove a group and all entities inside from this world

    removeResource: <T extends object>(
        this: RuntimeWorld,
        type: TTypeProto<T>,
    ) => void = removeResource

    Remove a resource from this world

    replaceResource: <T extends object>(
        this: RuntimeWorld,
        obj: Readonly<T> | TTypeProto<T>,
        ...args: readonly unknown[],
    ) => Promise<void> = replaceResource

    Replace a resource from this world with a new value

    save: (
        this: RuntimeWorld,
        options?: Readonly<ISerDeOptions<TSerializer>>,
    ) => ISerialFormat = save

    Prepare a savable version of the current world. The query can be used to only save a sub-set with specific conditions

    Accessors

    Methods

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods