Skip to content

ParticleEmitterComponent

Defined in: particles/src/ParticleEmitterComponent.ts:105

Component that owns a PixiJS ParticleContainer and drives particle emission. Requires a Transform on the same entity: the system that ticks emitters queries for both, so an emitter without one never emits and never ages the particles a burst already spawned.

The container follows the entity’s world position, so particles carry container-local coordinates and the container’s own position is the depth key a layer sort such as ySort reads.

  • Component

new ParticleEmitterComponent(config): ParticleEmitterComponent

Defined in: particles/src/ParticleEmitterComponent.ts:121

EmitterConfig

ParticleEmitterComponent

Component.constructor

_accumulator: number = 0

Defined in: particles/src/ParticleEmitterComponent.ts:112

Internal


readonly _active: ParticleState[] = []

Defined in: particles/src/ParticleEmitterComponent.ts:111

Internal


readonly _pool: ParticlePool

Defined in: particles/src/ParticleEmitterComponent.ts:110

Internal


readonly container: ParticleContainer

Defined in: particles/src/ParticleEmitterComponent.ts:107


entity: Entity

Defined in: core/dist/index.d.ts:4116

Back-reference to the owning entity. Set by the engine when the component is added to an entity. Do not set manually.

Component.entity


static optional inspectExclude?: readonly string[]

Defined in: core/dist/index.d.ts:4338

Own fields and getters the Inspector leaves out of this component’s reflected state. Use it for bulk data that is not worth a diagnostic copy — a parsed tilemap, a large lookup table. Lists merge down the class chain, so a subclass adds to its base class’s exclusions.

class TilemapComponent extends VisualComponent {
static inspectExclude = ["data"];
}

Component.inspectExclude


static optional updatePriority?: number

Defined in: core/dist/index.d.ts:4325

Class-level default for updatePriority: every instance runs at this priority unless its own updatePriority is written. Undeclared = 0. Subclasses inherit their base class’s value unless they declare their own. Declare it on a component whose behavior depends on running after (or before) a sibling, so the entity that adds it does not have to control the add order.

class BoundsClamp extends Component {
static updatePriority = 10; // after the follow that moves the camera
}

Component.updatePriority

get activeCount(): number

Defined in: particles/src/ParticleEmitterComponent.ts:308

Number of currently alive particles.

number


get blendMode(): BLEND_MODES

Defined in: particles/src/ParticleEmitterComponent.ts:318

Get the particles’ blend mode.

BLEND_MODES

set blendMode(mode): void

Defined in: particles/src/ParticleEmitterComponent.ts:313

Set how the particles combine with what is drawn beneath them.

BLEND_MODES

void


get context(): EngineContext

Defined in: core/dist/index.d.ts:4171

Access the EngineContext from the entity’s scene. Throws if the entity is not in a scene.

EngineContext

Component.context


get effectiveEnabled(): boolean

Defined in: core/dist/index.d.ts:4141

Whether the component is actually running: enabled, on an active entity, and past onAdd. This is the state onEnable and onDisable track — read it when a method has to behave one way live and another way dormant.

boolean

Component.effectiveEnabled


get enabled(): boolean

Defined in: core/dist/index.d.ts:4133

Whether this component runs. Disabled components are skipped by ComponentUpdateSystem.

Writing this fires onEnable / onDisable when the effective state changes — enabled && entity.isActive. A component disabled here stays disabled through a setActive(false) / setActive(true) cycle on its entity.

boolean

set enabled(value): void

Defined in: core/dist/index.d.ts:4134

boolean

void

Component.enabled


get isEmitting(): boolean

Defined in: particles/src/ParticleEmitterComponent.ts:303

Whether continuous emission is active.

boolean


get scene(): Scene

Defined in: core/dist/index.d.ts:4166

Access the entity’s scene. Throws if the entity is not in a scene. Prefer this over threading through this.entity.scene in component code.

Scene

Component.scene


get updatePriority(): number

Defined in: core/dist/index.d.ts:4159

Where this component runs among its siblings. ComponentUpdateSystem calls update / fixedUpdate on an entity’s components in ascending priority; equal priorities run in add order. Undeclared = 0, so a negative value runs before siblings that keep the default and a positive value runs after them. Writable at any time, before or after add(). Defaults to the class’s static updatePriority.

class Player extends Entity {
setup() {
this.add(new Mover());
this.add(new Brain()).updatePriority = -1; // decides before Mover moves
}
}

number

set updatePriority(value): void

Defined in: core/dist/index.d.ts:4160

number

void

Component.updatePriority

_applyEnabled(effective): void

Defined in: core/dist/index.d.ts:4273

Internal

Force an effective-enabled transition, firing the hook on a flip. Used by Entity for teardown, where enabled and the entity’s activeness both still read true.

boolean

void

Component._applyEnabled


_isTornDown(): boolean

Defined in: core/dist/index.d.ts:4254

Internal

Internal: true once this component has been removed or its entity destroyed. Components are terminal — Entity.add uses this to reject re-attaching an instance whose cleanups and onDestroy already ran.

boolean

Component._isTornDown


_markTornDown(): void

Defined in: core/dist/index.d.ts:4260

Internal

Internal: mark this component torn down. Called by Entity.remove() and Entity._performDestroy() after onDestroy runs.

void

Component._markTornDown


_refreshEnabled(): void

Defined in: core/dist/index.d.ts:4266

Internal

Recompute effective enabled-ness from enabled and the entity’s activeness, firing the hook on a flip.

void

Component._refreshEnabled


_runCleanups(onError?): void

Defined in: core/dist/index.d.ts:4241

Internal

Run and clear all registered cleanups. Called by Entity.remove() and Entity._performDestroy() before onDestroy.

(error) => void

void

Component._runCleanups


_spawn(localX, localY, cfg): void

Defined in: particles/src/ParticleEmitterComponent.ts:450

Internal

Spawn one particle at container-local coordinates, reading cfg for every spawn-time value. Continuous emission passes the emitter’s own configuration; a burst with overrides passes its merged copy.

number

number

ResolvedConfig

void


_syncContainer(worldX, worldY): void

Defined in: particles/src/ParticleEmitterComponent.ts:431

Internal

Move the container to the entity’s world position. In world space, live particles shift by the inverse delta so they keep the position they were drawn at; in local space they follow the container.

number

number

void


_update(dt, worldX, worldY): void

Defined in: particles/src/ParticleEmitterComponent.ts:359

Internal

Called by ParticleSystem each frame.

number

number

number

void


protected addCleanup(fn): void

Defined in: core/dist/index.d.ts:4229

Register a cleanup function to run when this component is removed or destroyed, before onDestroy. Use it for what listen, listenScene and listenBus do not cover, such as an unsubscribe from a custom emitter.

() => void

void

Component.addCleanup


burst(count, overrides?): void

Defined in: particles/src/ParticleEmitterComponent.ts:252

Spawn count particles at the entity’s world position.

number

Partial<Pick<EmitterOptions, "lifetime" | "speed" | "angle" | "scale" | "alpha" | "rotation" | "rotationSpeed" | "tint" | "spawnOffset" | "radialSpeed">>

void

burst(count, worldX, worldY, overrides?): void

Defined in: particles/src/ParticleEmitterComponent.ts:254

Spawn count particles at an explicit world position.

number

number

number

Partial<Pick<EmitterOptions, "lifetime" | "speed" | "angle" | "scale" | "alpha" | "rotation" | "rotationSpeed" | "tint" | "spawnOffset" | "radialSpeed">>

void


configure(options): void

Defined in: particles/src/ParticleEmitterComponent.ts:240

Change the emitter’s configuration from now on. When a change reaches a particle depends on where the emitter reads the option. The spawn-time options — lifetime, speed, angle, scale, alpha, rotation, rotationSpeed, tint, spawnOffset and radialSpeed — are resolved once per particle, so a particle already in flight keeps what it was spawned with and the next particle spawned uses the new value. gravity, damping, alphaFadeIn and alphaFadeOut are read from this configuration every frame for every live particle, so they reach particles already in flight on the next frame. rate applies to the next frame of continuous emission, and blendMode is a property of the container every particle is drawn in.

The whole merged configuration is checked, and a rejected call leaves every previous value in force.

The emitter reads only the options EmitterUpdateOptions lists and ignores any other key, such as maxParticles in a spread EmitterConfig.

The emitter copies what it is given, so changing the object afterwards changes nothing. For a one-off variation, pass overrides to ParticleEmitterComponent.burst instead.

EmitterUpdateOptions

void


destroy(): void

Defined in: core/dist/index.d.ts:4247

End this component’s life on its own — the same as entity.remove(SomeClass), without having to name its own class from inside itself, which breaks under subclassing.

void

Component.destroy


emit(): void

Defined in: particles/src/ParticleEmitterComponent.ts:161

Start continuous emission at config.rate particles/sec.

void


optional fixedUpdate(dt): void

Defined in: core/dist/index.d.ts:4310

Called every fixed timestep by the built-in ComponentUpdateSystem.

number

Fixed timestep in seconds, scaled by scene and entity timeScale.

void

Component.fixedUpdate


protected listen<T>(source, token, handler): void

Defined in: core/dist/index.d.ts:4211

Subscribe to events from an entity or a state machine, auto-unsubscribe on removal.

this.listen(this.entity, Hurt, ({ dir }) => this.knockback(dir));
this.listen(brain.mode, brain.mode.events.entered, ({ state }) =>
this.anim.play(state),
);

T

EventSource

EventToken<T>

(data) => void

void

Component.listen


protected listenBus<K>(event, handler): void

Defined in: core/dist/index.d.ts:4222

Subscribe to an engine EventBus event, auto-unsubscribe on removal. Throws when the entity is not in a scene, like listenScene.

K extends keyof EngineEvents

K

(data) => void

void

Component.listenBus


protected listenScene<T>(token, handler): void

Defined in: core/dist/index.d.ts:4217

Subscribe to scene-level events, auto-unsubscribe on removal. Handlers fire for bubbled entity events (entity = source) and scene.emit events (entity = undefined).

T

EventToken<T>

(data, entity?) => void

void

Component.listenScene


onAdd(): void

Defined in: particles/src/ParticleEmitterComponent.ts:322

Called when the component is added to an entity. Validate dependencies here — a service, a sibling component, a render layer — and throw when one is missing. The throw is attributed to this component, recorded in Inspector.getErrors().callbackErrors, and rethrown, so it reaches the caller of entity.add() unchanged.

void

Component.onAdd


onDestroy(): void

Defined in: particles/src/ParticleEmitterComponent.ts:344

Called when the component is destroyed (entity destroyed or component removed).

void

Component.onDestroy


onDisable(): void

Defined in: particles/src/ParticleEmitterComponent.ts:335

Hide the live particles. Emission stops on its own — a dormant entity is out of the query ParticleSystem iterates — and the pooled particles are kept, so the emitter picks up mid-flight when the entity comes back.

void

Component.onDisable


onEnable(): void

Defined in: particles/src/ParticleEmitterComponent.ts:340

Called when the component becomes effectively enabled — enabled is true and the entity is active. Fires right after onAdd() for a component added to an active entity, and again on every later flip. Bring live resources back online here (unpause a sound, show a display object, re-enable a physics body). Game-state reset does not belong here: the hook sees whatever state the component held while dormant.

void

Component.onEnable


requestEmission(): ParticleEmissionHandle

Defined in: particles/src/ParticleEmitterComponent.ts:179

Keep continuous emission active until the returned handle is released. Several callers can hold requests without stopping one another.

ParticleEmissionHandle


protected service<T>(key): T

Defined in: core/dist/index.d.ts:4188

Lazy proxy-based service resolution. Can be used at field-declaration time:

readonly input = this.service(InputManagerKey);

The actual resolution is deferred until first property access.

T extends object

ServiceKey<T>

T

Component.service


protected sibling<C>(cls): C

Defined in: core/dist/index.d.ts:4199

Lazy proxy-based sibling component resolution. Can be used at field-declaration time:

readonly anim = this.sibling(AnimatedSpriteComponent);

The actual resolution is deferred until first property access. The reference passes instanceof cls before it resolves, so an engine API that checks the type of what it is handed (camera.follow(this.transform)) accepts it.

C extends Component

ComponentClass<C>

C

Component.sibling


protected stateMachine<S>(states, initial, options?): StateMachine<S>

Defined in: core/dist/index.d.ts:4235

Create a state machine whose hooks and event handlers are attributed to this component when they throw. The machine can be declared as a field because service lookup waits until a hook runs.

S extends string

StateDefinitions<S>

NoInfer<S>

StateMachineOptions

StateMachine<S>

Component.stateMachine


stop(): void

Defined in: particles/src/ParticleEmitterComponent.ts:170

Stop emission started by emit. Active emission requests remain in effect. Existing particles continue to their end of life.

void


optional update(dt): void

Defined in: core/dist/index.d.ts:4305

Called every frame by the built-in ComponentUpdateSystem.

number

Frame delta in seconds, scaled by scene and entity timeScale.

void

Component.update


protected use<T>(key): T

Defined in: core/dist/index.d.ts:4179

Resolve a service by key, cached after first lookup. Scene-scoped values (registered via scene._registerScoped) take precedence over engine scope. A key declared with scope: "scene" that falls back to engine scope emits a one-shot dev warning — almost always signals a missed beforeEnter hook.

T

ServiceKey<T>

T

Component.use

Coding agents: fetch https://yage.dev/llms.txt first and prefer the Markdown references it links over these HTML pages. This page's Markdown counterpart is /llms/packages/particles.md.