Roster: Phaser AE API 3.0.0-2

Functions

`deformFacing`

function deformFacing(d: { speed: number; phase: number }, time: number): number

From @phaser-ae/kernel

The flip deformer's facing at a moment: above 0 the front shows, below 0 the grid is mirrored and the BACK should show — swap h.frame on the sign change for a two-sided card. time is the sim clock (game.clock.time).

Classes

`KernelHandle`

class KernelHandle implements Handle

From @phaser-ae/kernel/internal

One canonical handle per id: getters and setters into the tables at the id's slot. After kill, reads return the last values (a snapshot taken at the kill) and writes are errors in dev and ignored otherwise. Each pack's columns appear under its key as a sub-handle, made on first read (h.physics.vx).

lastSlot: number — The slot it held: its current one while alive, the one it was killed in after.
prefix: string — The spawn id it was suffixed from (enemy-crab for enemy-crab-7).
data: Record<string, unknown> — Per-object game state — velocity, hp, a timer. Declared at spawn (data: { vx: 0 }), typed from it, snapshotted with the object. Never keep a Map beside the roster.
tagSet: Set<string> — Its tags; read them through tags.
packKeys: Set<string> — The pack column keys its spawn spec carried data for.
[packKey: string]: unknown
constructor(private readonly r: KernelRoster, readonly id: Id, readonly owner: PackId, slot: number)
get tags(): ReadonlySet<string> — Its tags; tagged() indexes them.
__addTag(t: string): void — The tag verb's path.
__teleport(x: number, y: number): void — The teleport verb's path: set x/y and the previous x/y together, so nothing interpolates.
__removeTag(t: string): void — The untag verb's path.
get alive(): boolean — False once killed; the handle is then inert: reads give the last values, and writes are an error in dev and ignored otherwise.
get frozen(): boolean — True while the scene that spawned this object is suspended beneath another.
get isLive(): boolean — The same as alive, for kernel code.
slotOrNeg1(): number — Its slot while alive, -1 once killed.
get x(): number — Centre x, world units. Default 0. Non-finite writes throw in dev.
set x(v: number) — Centre x, world units. Default 0. Non-finite writes throw in dev.
get y(): number — Centre y, world units. Default 0.
set y(v: number) — Centre y, world units. Default 0.
get z(): number — z, world units; 3D worlds. Default 0.
set z(v: number) — z, world units; 3D worlds. Default 0.
get rot(): number — Rotation in radians. Default 0.
set rot(v: number) — Rotation in radians. Default 0.
get yaw(): number — The same number as rot, by the name 3D code uses: the turn about y, radians; 0 faces +z.
set yaw(v: number) — The same number as rot, by the name 3D code uses: the turn about y, radians; 0 faces +z.
get sx(): number — Scale x; negative mirrors. Default 1.
set sx(v: number) — Scale x; negative mirrors. Default 1.
get sy(): number — Scale y; negative mirrors. Default 1.
set sy(v: number) — Scale y; negative mirrors. Default 1.
get pitch(): number — 3D worlds: pitch about x, radians. Default 0.
set pitch(v: number) — 3D worlds: pitch about x, radians. Default 0.
get roll(): number — 3D worlds: roll about z, radians. Default 0.
set roll(v: number) — 3D worlds: roll about z, radians. Default 0.
get sz(): number — 3D worlds: scale z; negative mirrors. Default 1.
set sz(v: number) — 3D worlds: scale z; negative mirrors. Default 1.
get width(): number — Width in world units; scale multiplies on top. Default: its picture's width (32 with no picture). Setting it fixes the size.
set width(v: number) — Width in world units; scale multiplies on top. Default: its picture's width (32 with no picture). Setting it fixes the size.
get height(): number — Height in world units; scale multiplies on top. Default: its picture's height (32 with no picture). Setting it fixes the size.
set height(v: number) — Height in world units; scale multiplies on top. Default: its picture's height (32 with no picture). Setting it fixes the size.
get frame(): number — The engine-wide frame number (every picture's frames share one numbering), not a frame of its own picture: use setFrame(i) for that. Default 0. Most code never needs the number.
set frame(v: number) — The engine-wide frame number (every picture's frames share one numbering), not a frame of its own picture: use setFrame(i) for that. Default 0. Most code never needs the number.
get texture(): string | null — The picture it shows, by name: one painted with game.paint, pixel art from game.pixels, or a loaded file's key. Null for a plain rectangle. Setting it shows that picture's first frame; a sprite whose size was never given takes the new picture's size.
set texture(key: string | null) — The picture it shows, by name: one painted with game.paint, pixel art from game.pixels, or a loaded file's key. Null for a plain rectangle. Setting it shows that picture's first frame; a sprite whose size was never given takes the new picture's size.
setTexture(key: string, frame = 0): void — Show frame frame (default 0) of the picture named key. Throws for an unknown key.
setFrame(index: number): void — Show frame index of its own picture: 0 is the picture's first (setFrame(1) on a two-frame button shows it pressed).
get scale(): number — Uniform scale: reads sx, sets sx, sy and sz together (sz only matters in a 3D world).
set scale(v: number) — Uniform scale: reads sx, sets sx, sy and sz together (sz only matters in a 3D world).
play(name: string): void — Play an animation declared at spawn (anims); calling it every step does not restart it.
destroy(): void — Remove it from the game. The same as kill().
kill(): void — Remove it from the game, at once: it leaves every query and its slot is free for the next spawn. The kill signal and scene.kill hook follow at the end of the step. The handle then reads its last values. Killing a dead handle this way does nothing.
sizeByPicture(): void — The kernel's: this sprite's size is its picture's until code gives it one.
get tint(): string — CSS colour string; stored packed, read back as hex. Default '#ffffff'.
set tint(v: string) — CSS colour string; stored packed, read back as hex. Default '#ffffff'.
get color(): string — The same as tint, by the name a mesh or a shape uses: the colour it is drawn in.
set color(v: string) — The same as tint, by the name a mesh or a shape uses: the colour it is drawn in.
get alpha(): number — Opacity 0..1, multiplied with the tint's alpha. Default 1.
set alpha(v: number) — Opacity 0..1, multiplied with the tint's alpha. Default 1.
get blend(): BlendMode — How this object's pixels combine with what is beneath. Default 'normal'.
set blend(v: BlendMode) — How this object's pixels combine with what is beneath. Default 'normal'.
get repeatX(): number — Texture repeats across the quad's width (1 = the frame once) — a TileSprite is a sprite with these set. Default 1.
set repeatX(v: number) — Texture repeats across the quad's width (1 = the frame once) — a TileSprite is a sprite with these set. Default 1.
get repeatY(): number — Texture repeats across the quad's height. Default 1.
set repeatY(v: number) — Texture repeats across the quad's height. Default 1.
get scrollX(): number — UV scroll offset x in frame fractions. Default 0.
set scrollX(v: number) — UV scroll offset x in frame fractions. Default 0.
get scrollY(): number — UV scroll offset y in frame fractions. Default 0.
set scrollY(v: number) — UV scroll offset y in frame fractions. Default 0.
get deform(): DeformState — A live view: h.deform.kind = 'sway'; h.deform.amount = 0.2.
snap(): void — Make prev equal the current transform, so this step's change is NOT interpolated: a teleport, a re-layout, a resize. The next step interpolates again.
get drawBy(): number — Who draws this object: 0 (default) is the backend's own sprite pass; any other value is the id of a DRAWER a pack registered (registry kind 'drawer'), which the backend calls for this object's run — in its sorted place, not on top. The effects pack sets it on objects with an fx bag. Game code reads it; packs write it.
set drawBy(v: number) — Who draws this object: 0 (default) is the backend's own sprite pass; any other value is the id of a DRAWER a pack registered (registry kind 'drawer'), which the backend calls for this object's run — in its sorted place, not on top. The effects pack sets it on objects with an fx bag. Game code reads it; packs write it.
get visible(): boolean — Drawn at all. Default true.
set visible(v: boolean) — Drawn at all. Default true.
get layer(): LayerName — The layer it draws in, one the composed world declares. An unknown name throws in dev and lands on the first layer otherwise.
set layer(v: LayerName) — The layer it draws in, one the composed world declares. An unknown name throws in dev and lands on the first layer otherwise.
get depth(): number — Its draw depth, written every frame by the world from its layer and the world's rule (y, z, distance). Never set it.
get prev(): Readonly<Transform> — The transform at the start of this fixed step; the world draws prev→current at the clock's alpha.
get aggregate(): { readonly count: number } | null — Present on one-object-many-instances systems (particles, tilemaps): set with roster.aggregate(h, …).
snapshotAndDetach(): void — Kernel use, at kill: keep the last values for reads, then let go of the slot.

`KernelRoster`

class KernelRoster implements Roster

From @phaser-ae/kernel/internal

The roster's storage: structure-of-arrays, one typed array per column indexed by slot, grown by doubling. The p… columns hold the previous step's transform, rolled by one copy per column per step. Pack columns live beside the kernel's own. Slots are free-listed and reused; ids and handles never are. Worlds read the columns directly (@phaser-ae/kernel/internal); everything else goes through handles and queries.

art: { size(frame: number): { w: number; h: number } | null; first(key: string): number; keyOf(frame: number): string | null } | null — The pictures, as the game's assets know them: what texture, setTexture and picture-sized sprites read. Set by the game.
onPlay: ((h: Handle, name: string) => void) | null — What handle.play(name) calls. Set by the game, which owns animations.
x!: Float32Array — Centre x.
y!: Float32Array — Centre y.
z!: Float32Array — z (3D).
rot!: Float32Array — Rotation; the yaw in 3D.
sx!: Float32Array — Scale x.
sy!: Float32Array — Scale y.
pitch!: Float32Array — Pitch (3D).
roll!: Float32Array — Roll (3D).
sz!: Float32Array — Scale z (3D).
width!: Float32Array — Width before scale.
height!: Float32Array — Height before scale.
px!: Float32Array — Previous x.
py!: Float32Array — Previous y.
pz!: Float32Array — Previous z.
prot!: Float32Array — Previous rotation.
psx!: Float32Array — Previous scale x.
psy!: Float32Array — Previous scale y.
ppitch!: Float32Array — Previous pitch.
proll!: Float32Array — Previous roll.
psz!: Float32Array — Previous scale z.
depth!: Float64Array — Draw depth: layer × LAYER_SPAN + the world's rule. Float64, so a small z survives at high layer indices.
frame!: Uint32Array — Global frame index.
tint!: Uint32Array — Packed rgba8 tint.
flags!: Uint8Array — Alive, visible, frozen, hidden and picture-sized bits.
layer!: Uint16Array — Global layer index.
scene!: Uint16Array — The owning scene's index (0: spawned before any scene).
alpha!: Float32Array — Opacity.
blend!: Uint8Array — Blend mode index into BLEND_MODES.
repeatX!: Float32Array — Texture repeats across the width.
repeatY!: Float32Array — Texture repeats across the height.
scrollX!: Float32Array — UV scroll x.
scrollY!: Float32Array — UV scroll y.
deformKind!: Uint8Array — Deform kind index.
deformAmount!: Float32Array — Deform amount.
deformSpeed!: Float32Array — Deform speed.
deformPhase!: Float32Array — Deform phase.
drawBy!: Uint8Array — Drawer id; 0 for the backend's sprite pass.
spawnOrder!: Float64Array — Monotonic birth order, independent of recycled storage slots.
resolveDeform: (name: string) => number | undefined — Custom deform kinds: name → index from DEFORM_CUSTOM_BASE. The game wires these to the registry.
customDeforms: () => ReadonlyArray<string> — The registered custom deform names, in index order from DEFORM_CUSTOM_BASE.
currentScene: number — The scene new spawns belong to. The kernel sets it on scene enter.
count: number — Live objects, suspended scenes' included.
wrap: Wrap | null — Set by a wrapping world. Queries then see across the seam.
constructor(readonly dev: boolean, initial = 256)
wrapAll(): void — World use, after every fixed step in a wrapping world: bring x/y into range and shift prev by the same amount, so interpolation never sweeps.
declareColumns(pack: PackId, key: string, decl: Columns, defaults: Record<string, number> = {}, methods: Record<string, (h: KernelHandle, ...args: never[]) => unknown> = {}): void — Kernel use, at compose: allocate a pack's columns under key. A key declared twice throws.
columns<C extends Columns>(packOrKey: PackId): ColumnView<C> — A pack's raw columns, by its id or its column key, with the slots of every live object not in a suspended scene. Throws for a pack with no columns.
declareLayers(names: ReadonlyArray<LayerName>): void — Kernel use: the global layer names, every world's in composed order.
layerIndex(name: LayerName): number — A layer's global index. An unknown name throws in dev and is layer 0 otherwise.
layerName(i: number): LayerName — A global layer index's name; '' for none.
get layers(): ReadonlyArray<LayerName> — Every global layer name, in index order.
readonly aggregates: Map<number, Aggregate> — slot → aggregate. Read by Gather2d.
aggregate(h: Handle, a: Aggregate | null): void — Make h an aggregate: one object, many instances, emitted by the world's gather inside the camera view. null clears.
spawn(spec: SpawnSpec): Handle — Spawn the kernel's columns only — no other pack's spawn data. Packs use kernel.spawn for the full call. Returns a live handle; the spawn signal and scene.spawn hook follow at the end of the step.
kill(h: Handle): void — Kill at once, as h.kill() does. Killing a dead handle this way throws in dev.
drainSpawned(): KernelHandle[] — Kernel use, at the end of each step: the objects spawned since the last call, for the spawn signal and hook.
drainKilled(): KernelHandle[] — Kernel use, at the end of each step: the objects killed since the last call, for the kill signal and hook.
killAll(): void — Kill every live object, on destroy.
setSceneState(scene: number, frozen: boolean, hidden: boolean): void — Kernel use: freeze (out of every query) and/or hide a scene's objects while it is beneath a push; both clear when it resumes.
isFrozen(slot: number): boolean — Is the object in this slot frozen (its scene suspended)?
killScene(scene: number): void — Kernel use: kill everything a scene spawned, when it exits. Scene 0 (spawned before any scene) persists.
bySlot(slot: number): Handle | undefined — The live handle in a slot (an instance table's order entry); undefined when the slot is free. For packs that walk a table back to its objects.
byId(id: string): Handle | undefined — An exact id, or a bare prefix ('player') when exactly one live object carries it. Two is an error in dev: say which.
*tagged(tag: string): Iterable<Handle> — Every live object with the tag, from an index. Objects of a suspended scene are left out. The query IS the list — never keep a second one.
*all(): Iterable<Handle> — Every live, non-suspended object. Suspended scenes' objects are on stage but out of every query.
*near(x: number, y: number, r: number): Iterable<Handle> — Every live object within radius of a point: its bounding circle (half its scaled diagonal) reaches it. From a spatial hash shared by collision, picking and AI. The hash files objects where they were at the first query after each step began (or after a spawn or kill); the distance test uses where they are now, so only an object moved more than a 64-unit cell since then can be missed. Across the wrap seam in a wrapping world. Suspended scenes' objects are left out.
*inRect(x: number, y: number, w: number, h: number): Iterable<Handle> — Every live object whose box (its scaled size) overlaps the rect (top-left x/y, w×h), from the same hash as near and across the wrap seam.
at(x: number, y: number, accept?: (h: Handle) => boolean): Handle | undefined — Picking: the visible object whose box holds a world point, front-most by depth (the newest on a tie), of those accept takes (all of them when it is left out).
touched(): void — Writes do NOT invalidate the hash: the broadphase is rebuilt once per fixed step (rollPrev marks it) and on spawn or kill, and the 64-unit cells absorb a step's worth of motion. Rebuilding on every write would make a collision step cost objects × writes.
addTag(h: KernelHandle, tag: string): void — Tag an object and index it (the tag verb's path).
removeTag(h: KernelHandle, tag: string): void — Untag an object and drop it from that tag's index.
rollPrev(): void — One memcpy per column: prev ← curr. Called by the kernel at each fixed step, before simulate.
rollOne(s: number): void — Make one slot's previous transform its current one: a spawn, or h.snap().
get used(): number — Slots in use, for worlds and backends that gather.
isAlive(slot: number): boolean — Is the slot occupied by a live object?
isVisible(slot: number): boolean — Is the slot's object drawn: alive, visible, and not hidden beneath an opaque pushed scene?
setVisible(slot: number, v: boolean): void — Set the slot's visible flag.
packColumnsFor(key: string): PackColumns | undefined — A pack's column record by its key, or undefined.
handleAt(slot: number): KernelHandle | null — The handle in a slot, or null when the slot is free.

Constants

`BLEND_MODES`

const BLEND_MODES: ReadonlyArray<BlendMode>

From @phaser-ae/kernel

Blend modes by index, as the instance table's blend column stores them.

`DEFORM_CUSTOM_BASE`

const DEFORM_CUSTOM_BASE: 16

From @phaser-ae/kernel

The deformKind index of the first registered custom DeformDef; the second is this plus one, and so on.

`DEFORM_KINDS`

const DEFORM_KINDS: ReadonlyArray<DeformKind>

From @phaser-ae/kernel

The built-in deform kinds by index, as the instance table's deformKind column stores them. Custom definitions take indices from DEFORM_CUSTOM_BASE in registration order.

Types

`BlendMode`

type BlendMode = 'normal' | 'add' | 'multiply' | 'screen' | 'subtract'

From @phaser-ae/kernel

normal: over · add: light sums · multiply: darken by the texture · screen: lighten · subtract: cut light.

`ColumnView`

interface ColumnView<C extends Columns>

From @phaser-ae/kernel

A live view over one pack's columns for a slot range — what a pack's step reads.

readonly count: number — Live slots in the view.
readonly slots: Uint32Array — The slot index of each live object, count long.
readonly cols: { readonly [K in keyof C]: ColumnArray } — One typed array per declared column, indexed by slot (not by position in slots).

`DeformKind`

type DeformKind = 'none' | 'wave' | 'sway' | 'flip' | 'jelly' | (string & {})

From @phaser-ae/kernel

wave: a left-anchored cloth ripple · sway: a bottom-anchored pendulum bend · flip: a fake-3D card flip about the vertical axis · jelly: a volume-preserving squash wobble. Any other string is a CUSTOM deformer a deform-* pack registered under the registry kind 'deform' (a DeformDef); an unregistered name throws at spawn or assignment.

`DeformState`

interface DeformState

From @phaser-ae/kernel

An object's vertex deformation, live on the handle.

kind: DeformKind — Which deformation; 'none' is a plain quad.
amount: number — Strength: WORLD UNITS for wave (ripple height), sway (lean) and a custom kind such as curl (cylinder radius); a FRACTION of the size for jelly (0.13 is a lively wobble); ignored by flip. Default 8.
speed: number — Cycles per second. Default 1.
phase: number — Phase offset in radians, so neighbours do not move in step. Default 0.

`Handle`

interface Handle

From @phaser-ae/kernel

One object, as game code holds it: getters and setters straight into the roster's columns at its slot.

readonly id: Id — <spec.id>-<n>, unique for the life of the game.
readonly owner: PackId — The pack that spawned it (a pack sets owner in the spec), or 'game'.
readonly tags: ReadonlySet<string> — Its tags; tagged() indexes them.
readonly alive: boolean — False once killed; the handle is then inert: reads give the last values, and writes are an error in dev and ignored otherwise.
readonly frozen: boolean — True while the scene that spawned it is suspended beneath a pushed scene: it still draws, but is out of every query.
x: number — Centre x, world units. Default 0. Non-finite writes throw in dev.
y: number — Centre y, world units. Default 0.
z: number — z, world units; 3D worlds. Default 0.
rot: number — Rotation in radians. Default 0.
yaw: number — The same number as rot, by the name 3D code uses: the turn about y, radians; 0 faces +z.
sx: number — Scale x; negative mirrors. Default 1.
sy: number — Scale y; negative mirrors. Default 1.
pitch: number — 3D worlds: pitch about x, radians. Default 0.
roll: number — 3D worlds: roll about z, radians. Default 0.
sz: number — 3D worlds: scale z; negative mirrors. Default 1.
width: number — Width in world units; scale multiplies on top. Default: its picture's width (32 with no picture). Setting it fixes the size.
height: number — Height in world units; scale multiplies on top. Default: its picture's height (32 with no picture). Setting it fixes the size.
scale: number — Uniform scale: reads sx, sets sx, sy and sz together (sz only matters in a 3D world).
readonly prev: Readonly<Transform> — The transform at the start of this fixed step; the world draws prev→current at the clock's alpha.
snap(): void — Make prev equal the current transform, so this step's change is NOT interpolated: a teleport, a re-layout, a resize. The next step interpolates again.
layer: LayerName — The layer it draws in, one the composed world declares. An unknown name throws in dev and lands on the first layer otherwise.
readonly depth: number — Its draw depth, written every frame by the world from its layer and the world's rule (y, z, distance). Never set it.
visible: boolean — Drawn at all. Default true.
frame: number — The engine-wide frame number (every picture's frames share one numbering), not a frame of its own picture: use setFrame(i) for that. Default 0. Most code never needs the number.
texture: string | null — The picture it shows, by name: one painted with game.paint, pixel art from game.pixels, or a loaded file's key. Null for a plain rectangle. Setting it shows that picture's first frame; a sprite whose size was never given takes the new picture's size.
setTexture(key: string, frame?: number): void — Show frame frame (default 0) of the picture named key. Throws for an unknown key.
setFrame(index: number): void — Show frame index of its own picture: 0 is the picture's first (setFrame(1) on a two-frame button shows it pressed).
play(name: string): void — Play an animation declared at spawn (anims); calling it every step does not restart it.
destroy(): void — Remove it from the game. The same as kill().
kill(): void — Remove it from the game, at once: it leaves every query and its slot is free for the next spawn. The kill signal and scene.kill hook follow at the end of the step. The handle then reads its last values. Killing a dead handle this way does nothing.
tint: string — CSS colour string; stored packed, read back as hex. Default '#ffffff'.
color: string — The same as tint, by the name a mesh or a shape uses: the colour it is drawn in.
alpha: number — Opacity 0..1, multiplied with the tint's alpha. Default 1.
blend: BlendMode — How this object's pixels combine with what is beneath. Default 'normal'.
repeatX: number — Texture repeats across the quad's width (1 = the frame once) — a TileSprite is a sprite with these set. Default 1.
repeatY: number — Texture repeats across the quad's height. Default 1.
scrollX: number — UV scroll offset x in frame fractions. Default 0.
scrollY: number — UV scroll offset y in frame fractions. Default 0.
readonly deform: DeformState — Vertex deformation: the quad becomes a 24×64 grid displaced in the vertex stage. kind: 'none' is a plain quad.
drawBy: number — Who draws this object: 0 (default) is the backend's own sprite pass; any other value is the id of a DRAWER a pack registered (registry kind 'drawer'), which the backend calls for this object's run — in its sorted place, not on top. The effects pack sets it on objects with an fx bag. Game code reads it; packs write it.
readonly aggregate: { readonly count: number } | null — Present on one-object-many-instances systems (particles, tilemaps): set with roster.aggregate(h, …).
readonly data: Record<string, unknown> — Per-object game state — velocity, hp, a timer. Declared at spawn (data: { vx: 0 }), typed from it, snapshotted with the object. Never keep a Map beside the roster.

`Roster`

interface Roster

From @phaser-ae/kernel

The roster: spawn, kill, and every query over what exists.

spawn(spec: SpawnSpec): Handle — Spawn the kernel's columns only — no other pack's spawn data. Packs use kernel.spawn for the full call. Returns a live handle; the spawn signal and scene.spawn hook follow at the end of the step.
kill(h: Handle): void — Kill at once, as h.kill() does. Killing a dead handle this way throws in dev.
byId(id: Id | string): Handle | undefined — By full id, or by spawn prefix when exactly one live object has it; two or more throws in dev. Undefined when none.
bySlot(slot: number): Handle | undefined — The live handle in a slot (an instance table's order entry); undefined when the slot is free. For packs that walk a table back to its objects.
tagged(tag: string): Iterable<Handle> — Every live object with the tag, from an index. Objects of a suspended scene are left out. The query IS the list — never keep a second one.
near(x: number, y: number, radius: number): Iterable<Handle> — Every live object within radius of a point: its bounding circle (half its scaled diagonal) reaches it. From a spatial hash shared by collision, picking and AI. The hash files objects where they were at the first query after each step began (or after a spawn or kill); the distance test uses where they are now, so only an object moved more than a 64-unit cell since then can be missed. Across the wrap seam in a wrapping world. Suspended scenes' objects are left out.
inRect(x: number, y: number, w: number, h: number): Iterable<Handle> — Every live object whose box (its scaled size) overlaps the rect (top-left x/y, w×h), from the same hash as near and across the wrap seam.
at(x: number, y: number, accept?: (h: Handle) => boolean): Handle | undefined — Picking: the visible object whose box holds a world point, front-most by depth (the newest on a tie), of those accept takes (all of them when it is left out).
readonly count: number — Live objects, including suspended scenes'.
all(): Iterable<Handle> — Every live, non-suspended object. Suspended scenes' objects are on stage but out of every query.
readonly wrap: { readonly w: number; readonly h: number } | null — Set by a wrapping world: queries, collision and drawing all measure across the seam. Game code reads it, never sets it.
aggregate(h: Handle, a: Aggregate | null): void — Make h an aggregate: one object, many instances, emitted by the world's gather inside the camera view. null clears.
columns<C extends Columns>(pack: PackId): ColumnView<C> — A pack's raw columns, by its id or its column key, with the slots of every live object not in a suspended scene. Throws for a pack with no columns.

`SpawnSpec`

interface SpawnSpec

From @phaser-ae/kernel

A spawn is data. Kinds that recur are plain templates spread into it.

id: string — Human-legible prefix; the kernel suffixes it: enemy-crab → enemy-crab-7.
tags?: ReadonlyArray<string> — Tags to index it under.
x?: number — Centre x, world units. Default 0.
y?: number — Centre y, world units. Default 0.
z?: number — z, world units. Default 0.
rot?: number — Rotation in radians. Default 0.
yaw?: number — The same as rot, by the name 3D code uses (rot wins when both are given).
sx?: number — Scale x. Default 1.
sy?: number — Scale y. Default 1.
pitch?: number — 3D worlds: pitch in radians about x. Default 0.
roll?: number — 3D worlds: roll in radians about z. Default 0.
sz?: number — 3D worlds: scale z. Default 1.
width?: number — Width in world units. Default: the picture's width, or the height's share of it when only height is given (32 with no picture).
height?: number — Height in world units. Default: the picture's height, or the width's share of it when only width is given (32 with no picture).
scale?: number — Uniform scale on top of the size; sets sx, sy and sz (an explicit one wins). Default 1.
texture?: string — The picture to show, by name (game.paint, game.pixels, or a loaded file's key). frame is then a frame of it (default 0).
layer?: LayerName — A layer the composed world declares; an unknown name throws in dev. Default: the first layer.
frame?: number — The global frame index, or with texture a frame of that picture. Default 0, the white square.
tint?: string — CSS colour. Default '#ffffff'.
color?: string — The same as tint (tint wins when both are given).
alpha?: number — Opacity 0..1. Default 1.
blend?: BlendMode — Blend mode; an unknown one throws. Default 'normal'.
uvRepeat?: { x: number; y: number } | number — Texture repeats, one number for both axes or per axis. Default 1.
uvScroll?: { x: number; y: number } — UV scroll offset in frame fractions. Default 0.
deform?: { kind: DeformKind; amount?: number; speed?: number; phase?: number } — Vertex deformation; defaults amount 8 (world units), speed 1, phase 0. An unknown kind (built-in or a composed deform-* pack's name) throws.
visible?: boolean — Drawn at all. Default true.
data?: Record<string, unknown> — Per-object game state. h.data is typed from this literal.
[packKey: string]: unknown — Per-pack data under the pack's key, typed by the pack's columns. Packs extend this.