Class default<CT>

Type parameters

CT

Hierarchy

default

Index

Constructors

constructor

Properties

Methods

Constructors

constructor

new default<CT>(): default<CT>

- Defined in World.ts:22
Type parameters
- CT
Returns default<CT>

Properties

componentCollections

componentCollections: Map<string, default<CT>> = ...

dev

dev: default<CT>

entities

entities: Map<string, default<CT>> = ...

entitiesByCTypes

entitiesByCTypes: Map<string[], Set<string>> = ...

entitiesByTags

entitiesByTags: Map<Tag, Set<string>> = ...

systems

systems: default<CT>

Methods

add

add<T>(eid: string, component: T): this

- Defined in World.ts:236
Add a component on the given entity

Type parameters
- T
Parameters
- eid: string
- component: T
Returns this

addSystem

addSystem(cTypes: ClassConstructor<CT>[], systemFunc: SystemFunc<CT>, funcName?: string): default<CT>

- Defined in World.ts:324
Method for adding systems.

Parameters
- cTypes: ClassConstructor<CT>[]
- systemFunc: SystemFunc<CT>
- Optional funcName: string
Returns default<CT>

clearEntityComponents

clearEntityComponents(entityId: string): default<CT>

- Defined in World.ts:348
Remove all components that belong to an entity.

Parameters
- entityId: string
Returns default<CT>

createEntity

createEntity(): default<CT>

- Defined in World.ts:364
Create an entity that is in the world. Basically just new Entity(world), but saves an import of Entity.

Returns default<CT>

destroyEntity

destroyEntity(entityId: string): default<CT>

- Defined in World.ts:376
Destroys an entity. Same as entity.destroy().

Parameters
- entityId: string
Returns default<CT>

find

find(predicate: (entity: default<CT>) => boolean): null | default<CT>

- Defined in World.ts:32
"finds" a single entity based on a predicate

Parameters
- predicate: (entity: default<CT>) => boolean
  - - (entity: default<CT>): boolean
    - Parameters
      - entity: default<CT>
      Returns boolean
Returns null | default<CT>

findAll

findAll(predicate: (entity: default<CT>) => boolean): default<CT>[]

- Defined in World.ts:45
"finds" all entities based on a predicate, kinda like filter.

Parameters
- predicate: (entity: default<CT>) => boolean
  - - (entity: default<CT>): boolean
    - Parameters
      - entity: default<CT>
      Returns boolean
Returns default<CT>[]

get

get<T>(eid: string, cl: ClassConstructor<T>): T

- Defined in World.ts:167
Given an entity id and componentType, returns component

Type parameters
- T
Parameters
- eid: string
- cl: ClassConstructor<T>
Returns T

getAllTagged

getAllTagged(tag: Tag): default<CT>[]

- Defined in World.ts:216
Gett all entities that have been tagged with the given tag.

Parameters
- tag: Tag
  
  A string or number.
Returns default<CT>[]

getComponent

getComponent<T>(cl: ClassConstructor<T>, defaultValue?: T): null | T

- Defined in World.ts:180
Find and get the first instance of a component, without any associated entities. Helpful is you know that only one instance of a component exists across all entities.

Type parameters
- T
Parameters
- cl: ClassConstructor<T>
  
  Component Class Contructor
- Optional defaultValue: T
  
  A default component instance if no components are found.
Returns null | T

getTagged

getTagged(tag: Tag): null | default<CT>

- Defined in World.ts:196
Get an entity that has been tagged with the given tag, or return null;

Parameters
- tag: Tag
Returns null | default<CT>

grab

grab<T>(cl: ClassConstructor<T>): null | { component: T; entity: default<CT> }

- Defined in World.ts:92
Grabs the first entity, and its related component, that matches the component type.
example
```
const { entity, component } = world.grab(MyComponent);
```
Type parameters
- T
Parameters
- cl: ClassConstructor<T>
Returns null | { component: T; entity: default<CT> }

grabAll

grabAll<T>(cl: ClassConstructor<T>): { component: T; entity: default<CT> }[]

- Defined in World.ts:149
Grab all the components primarily, and the entities if needed

Type parameters
- T
Parameters
- cl: ClassConstructor<T>
Returns { component: T; entity: default<CT> }[]

grabBy

grabBy<T>(cl: ClassConstructor<T>, predicate: (comp: T) => boolean): null | { component: T; entity: default<CT> }

- Defined in World.ts:121
Grab single component based on component type and predicate.
example
```
const { entity, component } = world.grabBy(FirstComponent, (comp) => comp.id == 'awesome')
```
Type parameters
- T
Parameters
- cl: ClassConstructor<T>
- predicate: (comp: T) => boolean
  - - (comp: T): boolean
    - Parameters
      - comp: T
      Returns boolean
Returns null | { component: T; entity: default<CT> }

locate

locate(cl: ClassConstructor<CT> | ClassConstructor<CT>[]): null | default<CT>

- Defined in World.ts:60
"locates" a single entity based on its Components.

Parameters
- cl: ClassConstructor<CT> | ClassConstructor<CT>[]
Returns null | default<CT>

locateAll

locateAll(cl: ClassConstructor<CT> | ClassConstructor<CT>[]): default<CT>[]

- Defined in World.ts:73
Locates all entities that contain the components named

Parameters
- cl: ClassConstructor<CT> | ClassConstructor<CT>[]
Returns default<CT>[]

registerEntity

registerEntity(entity: default<CT>): default<CT>

- Defined in World.ts:334
Setup an entity to exist in the given world. This is mostly an internal method, but exposed just in case.

Parameters
- entity: default<CT>
Returns default<CT>

remove

remove(eid: string, cType: ClassConstructor<CT>): this

- Defined in World.ts:275
Remove a component from the given entity. NOTE: This will change what systems will be called on the entity.

Parameters
- eid: string
- cType: ClassConstructor<CT>
Returns this

Generated using TypeDoc