Adds a component to an entity, optionally initializing the state object.
ecs.createComponent({
name: 'foo',
state: { val: 1 }
})
ecs.addComponent(id1, 'foo') // use default state
ecs.addComponent(id2, 'foo', { val:2 }) // pass in state data
Hash of component definitions. Also aliased to comps.
var comp = { name: 'foo' }
ecs.createComponent(comp)
ecs.components['foo'] === comp // true
ecs.comps['foo'] // same
Creates a new component from a definition object.
The definition must have a name; all other properties are optional.
Returns the component name, to make it easy to grab when the component
is being required from a module.
var comp = {
name: 'some-unique-string',
state: {},
order: 99,
multi: false,
onAdd: (id, state) => { },
onRemove: (id, state) => { },
system: (dt, states) => { },
renderSystem: (dt, states) => { },
}
var name = ecs.createComponent( comp )
// name == 'some-unique-string'
Note the multi flag - for components where this is true, a given
entity can have multiple state objects for that component.
For multi-components, APIs that would normally return a state object
(like getState) will instead return an array of them.
Creates a new entity id (currently just an incrementing integer).
Optionally takes a list of component names to add to the entity (with default state data).
var id1 = ecs.createEntity()
var id2 = ecs.createEntity([ 'some-component', 'other-component' ])
Deletes the component definition with the given name. First removes the component from all entities that have it.
Note: This API shouldn't be necessary in most real-world usage - you should set up all your components during init and then leave them be. But it's useful if, say, you receive an ECS from another library and you need to replace its components.
ecs.deleteComponent( 'some-component' )
Returns the entity's collideEntities component state
Returns the entity's collideTerrain component state
Makes a hasComponent-like accessor function bound to a given component.
The accessor is much faster than hasComponent.
ecs.createComponent({
name: 'foo',
})
var hasFoo = ecs.getComponentAccessor('foo')
// ...
ecs.addComponent(id, 'foo')
hasFoo(id) // true
Returns the entity's mesh component state
Returns the entity's movement component state
Get the entity's physics component state.
Returns the entity's position vector.
Returns the entity's position component state
Get the component state for a given entity.
It will automatically have an __id property for the entity id.
ecs.createComponent({
name: 'foo',
state: { val: 0 }
})
ecs.addComponent(id, 'foo')
ecs.getState(id, 'foo').val // 0
ecs.getState(id, 'foo').__id // equals id
Makes a getState-like accessor bound to a given component.
The accessor is faster than getState, so you may want to create
an accessor for any component you'll be accessing a lot.
ecs.createComponent({
name: 'size',
state: { val: 0 }
})
var getEntitySize = ecs.getStateAccessor('size')
// ...
ecs.addComponent(id, 'size', { val:123 })
getEntitySize(id).val // 123
Get an array of state objects for every entity with the given component.
Each one will have an __id property for the entity id it refers to.
Don't add or remove elements from the returned list!
var arr = ecs.getStatesList('foo')
// returns something shaped like:
// [
// {__id:0, x:1},
// {__id:7, x:2},
// ]
Checks if an entity has a component.
ecs.addComponent(id, 'foo')
ecs.hasComponent(id, 'foo') // true
Returns whether the entity has a mesh
Returns whether the entity has a physics body
Returns whether the entity has a position
Hash containing the component names of built-in components.
Pairwise collideEntities event - assign your own function to this property if you want to handle entity-entity overlap events.
Removes one particular instance of a multi-component. To avoid breaking loops, the relevant state object will get nulled immediately, and spliced from the states array later when safe (after the current tick/render/animationFrame).
// where component 'foo' is a multi-component
ecs.getState(id, 'foo') // [ state1, state2, state3 ]
ecs.removeMultiComponent(id, 'foo', 1)
ecs.getState(id, 'foo') // [ state1, null, state3 ]
// one JS event loop later...
ecs.getState(id, 'foo') // [ state1, state3 ]
Functions exactly like tick, but calls renderSystem functions.
this effectively gives you a second set of systems that are
called with separate timing, in case you want to
tick and render in separate loops
(which you should!).
ecs.createComponent({
name: foo,
order: 5,
renderSystem: function(dt, states) {
// states is the same array you'd get from #getStatesList()
}
})
ecs.render(1000/60)
Tells the ECS that a game tick has occurred, causing component
system functions to get called.
The optional parameter simply gets passed to the system functions. It's meant to be a timestep, but can be used (or not used) as you like.
If components have an order property, they'll get called in that order
(lowest to highest). Component order defaults to 99.
ecs.createComponent({
name: foo,
order: 1,
system: function(dt, states) {
// states is the same array you'd get from #getStatesList()
states.forEach(state => {
console.log('Entity ID: ', state.__id)
})
}
})
ecs.tick(30) // triggers log statements
Helper to set up a general entity, and populate with some common components depending on arguments.
Set an entity's position, and update all derived state.
In general, always use this to set an entity's position unless you're familiar with engine internals.
noa.ents.setPosition(playerEntity, [5, 6, 7])
noa.ents.setPosition(playerEntity, 5, 6, 7) // also works
Generated using TypeDoc
noa.entities- manages entities and components.This class extends ent-comp, a general-purpose ECS. It's also decorated with noa-specific helpers and accessor functions for querying entity positions, etc.
Expects entity definitions in a specific format - see source
componentsfolder for examples.This module uses the following default options (from the options object passed to the Engine):