Skip to content

TilemapComponent

Defined in: tilemap/src/TilemapComponent.ts:56

Component that renders a Tiled map using @pixi/tilemap.

  • VisualComponent

new TilemapComponent(options): TilemapComponent

Defined in: tilemap/src/TilemapComponent.ts:78

TilemapComponentOptions

TilemapComponent

VisualComponent.constructor

readonly container: DisplayContainer

Defined in: tilemap/src/TilemapComponent.ts:61


readonly data: TilemapData

Defined in: tilemap/src/TilemapComponent.ts:62


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.

VisualComponent.entity


readonly fx: EffectsHost

Defined in: renderer/dist/index.d.ts:252

Component-scope effects host. .fx.addEffect(...) attaches a filter to this component’s render object; the effect is torn down automatically when the entity or component is destroyed. .fx.findEffect(definition) recovers the handle for the first matching effect.

VisualComponent.fx


readonly keyPrefix: string | null

Defined in: tilemap/src/TilemapComponent.ts:66

Prefix used to derive auto-keys for entities spawned from objects.


readonly mapKey: string | null

Defined in: tilemap/src/TilemapComponent.ts:64

Asset path of this map, or null if constructed from a raw TiledMapData without one.


readonly modifiers: VisualModifierHost

Defined in: renderer/dist/index.d.ts:257

Render-only transform, opacity, and visibility contributions. Modifiers combine with the component’s live base values and are never serialized.

VisualComponent.modifiers


static inspectExclude: string[]

Defined in: tilemap/src/TilemapComponent.ts:59

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"];
}

VisualComponent.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
}

VisualComponent.updatePriority

get alpha(): number

Defined in: renderer/dist/index.d.ts:311

Get the requested alpha before transient opacity modifiers.

number

set alpha(alpha): void

Defined in: renderer/dist/index.d.ts:309

Set the container’s alpha (opacity).

number

void

VisualComponent.alpha


get blendMode(): BLEND_MODES

Defined in: renderer/dist/index.d.ts:315

Get the container’s blend mode.

BLEND_MODES

set blendMode(mode): void

Defined in: renderer/dist/index.d.ts:313

Set how the container combines with what is drawn beneath it.

BLEND_MODES

void

VisualComponent.blendMode


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

VisualComponent.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

VisualComponent.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

VisualComponent.enabled


get heightPx(): number

Defined in: tilemap/src/TilemapComponent.ts:188

Map height in pixels.

number


get layerName(): string

Defined in: renderer/dist/index.d.ts:290

The layer this visual draws on. See setLayer.

string

VisualComponent.layerName


get mask(): MaskHandle | undefined

Defined in: renderer/dist/index.d.ts:333

The currently attached mask handle, if any.

MaskHandle | undefined

VisualComponent.mask


get renderAboveEffects(): boolean

Defined in: renderer/dist/index.d.ts:287

Whether this visual draws after the scene’s layers, outside every layer- and scene-scope effect and mask, while keeping its logical parent (position, alpha, visibility, camera). Screen-scope effects still cover it, and hit testing follows the logical tree — a UI element drawn under an escaped visual still receives the pointer first.

Set while the visual is out of the display tree — in a subclass constructor, or on a component not yet added — it records the flag and applies it on add.

boolean

set renderAboveEffects(value): void

Defined in: renderer/dist/index.d.ts:288

boolean

void

VisualComponent.renderAboveEffects


get renderObject(): DisplayContainer

Defined in: tilemap/src/TilemapComponent.ts:135

The underlying tilemap container.

DisplayContainer

VisualComponent.renderObject


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

VisualComponent.scene


get tileHeight(): number

Defined in: tilemap/src/TilemapComponent.ts:198

Tile height in pixels.

number


get tileWidth(): number

Defined in: tilemap/src/TilemapComponent.ts:193

Tile width in pixels.

number


get tint(): number

Defined in: tilemap/src/TilemapComponent.ts:146

Set the container’s tint color.

number

set tint(color): void

Defined in: tilemap/src/TilemapComponent.ts:141

Set the container’s tint color.

ColorSource

void

VisualComponent.tint


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

VisualComponent.updatePriority


get visible(): boolean

Defined in: renderer/dist/index.d.ts:322

Get the requested visibility, whatever the entity’s activeness.

boolean

set visible(value): void

Defined in: renderer/dist/index.d.ts:320

Set the container’s visibility. Written while the entity is dormant, it is remembered and applied when the entity is activated.

boolean

void

VisualComponent.visible


get widthPx(): number

Defined in: tilemap/src/TilemapComponent.ts:183

Map width in pixels.

number

_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

VisualComponent._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

VisualComponent._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

VisualComponent._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

VisualComponent._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

VisualComponent._runCleanups


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

VisualComponent.addCleanup


protected applyEffectiveAlpha(alpha): void

Defined in: tilemap/src/TilemapComponent.ts:150

Apply the final alpha after transient modifiers.

number

void

VisualComponent.applyEffectiveAlpha


protected applyVisualOptions(options): void

Defined in: renderer/dist/index.d.ts:275

Apply the shared visible/tint/alpha/interactive options to renderObject. Call once from the subclass constructor, after the concrete Pixi object is created.

VisualComponentOptions

void

VisualComponent.applyVisualOptions


clearMask(): void

Defined in: renderer/dist/index.d.ts:331

Detach and destroy the current mask, if any.

void

VisualComponent.clearMask


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

VisualComponent.destroy


protected destroyOptions(): DestroyOptions

Defined in: tilemap/src/TilemapComponent.ts:409

Pixi destroy options passed to renderObject.destroy(). Default: undefined (Pixi’s own defaults). Override for a component whose destroy must cascade to children (SplitText’s per-segment display objects).

DestroyOptions

VisualComponent.destroyOptions


findObject(id): MapObject | undefined

Defined in: tilemap/src/TilemapComponent.ts:364

Find an object by its Tiled id. Searches every object layer.

number

MapObject | undefined


findObjectByName(name): MapObject | undefined

Defined in: tilemap/src/TilemapComponent.ts:374

Find the first object with a matching name. Searches every object layer.

string

MapObject | undefined


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

VisualComponent.fixedUpdate


forEachObject(layerName, fn): void

Defined in: tilemap/src/TilemapComponent.ts:334

Iterate every object on the given layer (or every layer if omitted), passing the auto-derived stable key alongside each object so callers can spawn entities with scene.spawn(Class, params, { key }).

Skips objects that don’t have a key prefix (component constructed from raw map: without mapKey or keyPrefix) — those callers should iterate getObjects directly.

string | undefined

(obj, key) => void

void


getAllObjects(): MapObject[]

Defined in: tilemap/src/TilemapComponent.ts:315

Flat list of every object across every object layer. Memoized — safe because parsed map data is immutable post-construction.

MapObject[]


getCollisionShapes(objectLayerName?): TilemapColliderConfig[]

Defined in: tilemap/src/TilemapComponent.ts:257

Extract physics-agnostic collision shapes from object layers.

string

TilemapColliderConfig[]


getObjectGroups(objectLayerName?): MapObjectGroup[]

Defined in: tilemap/src/TilemapComponent.ts:286

Objects grouped strictly by object layer and class.

string

MapObjectGroup[]


getObjects(objectLayerName?): Record<string, MapObject[]>

Defined in: tilemap/src/TilemapComponent.ts:265

Objects grouped by class ?? name. Use getObjectGroups when the source layer must be preserved.

string

Record<string, MapObject[]>


getProperty<T>(obj, name): T | undefined

Defined in: tilemap/src/TilemapComponent.ts:384

Read a typed custom property from any tilemap data that has properties.

T = unknown

HasProperties

string

T | undefined


getPropertyArray<T>(obj, name): T[]

Defined in: tilemap/src/TilemapComponent.ts:392

Read an indexed property bag (name[0], name[1], …) as an array. Throws when the indices skip one.

T = unknown

HasProperties

string

T[]


getTileAt(worldX, worldY, layerName?): number | null

Defined in: tilemap/src/TilemapComponent.ts:225

Returns the tile id at a world position. The point is converted through the inverse of the entity’s world transform, so a map that is parented, scaled or rotated answers where its tiles are drawn; each layer’s own draw offset is then applied. Returns null if the position is outside every layer or the tile is empty.

A world scale of 0 on either axis collapses the map, so no world point maps back to a cell and the method returns null.

A tileset’s tileoffset is not reversed here: it moves where a tile’s image is drawn, not which cell the tile occupies, and one layer can mix tilesets that offset differently. So a tile from an offset tileset answers at its cell, which is where its collision and neighbours are, rather than under the part of the image that overhangs. A tile image that does not match the grid is the same case: it sits on its cell’s bottom edge, and the cells its image reaches into answer with whatever they hold themselves.

Tiled’s flip bits are stripped, so the id compares against a tileset’s numbering whichever way the tile faces. Read them from the raw layer data with readTileGid when orientation matters.

number

number

string

number | null


inspectRender(): object

Defined in: renderer/dist/index.d.ts:340

Derived render facet for the Inspector — world-space bounds and the component’s own (local, non-inherited) visible flag, computed on demand from the live render object. See computeRenderFacet for the bounds coordinate space.

bounds: { height: number; width: number; x: number; y: number; } | null

Axis-aligned bounding box of the component’s geometry, in world space (the same coordinate space the Inspector reports for entity.transform — pixels, before camera/viewport projection). Measured from the geometry itself, so a sized-but-hidden object still reports its real box; null means there is no measurable geometry at all (an empty Graphics, a zero-area object), NOT that the object is hidden. Read RenderFacetSnapshot.visible for the hidden/shown state.

visible: boolean

The component’s own (local, non-inherited) visibility flag at snapshot time. A hidden ancestor (e.g. a parent/layer container set invisible) is NOT folded in — read the relevant parent separately if you need the fully resolved on-screen state.

VisualComponent.inspectRender


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

VisualComponent.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

VisualComponent.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

VisualComponent.listenScene


objectKey(obj): string

Defined in: tilemap/src/TilemapComponent.ts:354

Auto-derived stable key for an object: <keyPrefix>#object:<id>.

MapObject

string


onAdd(): void

Defined in: tilemap/src/TilemapComponent.ts:155

void

VisualComponent.onAdd


onDestroy(): void

Defined in: tilemap/src/TilemapComponent.ts:413

void

VisualComponent.onDestroy


onDisable(): void

Defined in: renderer/dist/index.d.ts:343

Called when the component stops being effectively enabled — enabled went false, the entity (or an ancestor) was deactivated, or the component is being removed or destroyed. Put live resources to sleep here; the component is reused afterwards, so do not free anything onEnable cannot rebuild.

void

VisualComponent.onDisable


onEnable(): void

Defined in: renderer/dist/index.d.ts:342

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

VisualComponent.onEnable


resolveRef(obj, propName): MapObject | undefined

Defined in: tilemap/src/TilemapComponent.ts:400

Resolve a Tiled object-reference property to the actual object. Auto-collects across every layer so callers don’t have to.

HasProperties

string

MapObject | undefined


resolveRefArray(obj, propName): MapObject[]

Defined in: tilemap/src/TilemapComponent.ts:405

Same as resolveRef, but for indexed object-reference arrays.

HasProperties

string

MapObject[]


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

VisualComponent.service


setLayer(name): void

Defined in: renderer/dist/index.d.ts:303

Draw this visual on another layer.

Called before the component reaches the display tree — in a subclass constructor, or on a component that has not been added yet — it records the name and nothing else. Called afterwards it detaches the render object and re-parents it through the same resolution onAdd uses, so a SortGroupComponent on the new layer still claims it.

The visual joins its new parent last, which on a layer with no sort means it draws in front of everything already there.

string

void

VisualComponent.setLayer


setMask(factory): MaskHandle

Defined in: renderer/dist/index.d.ts:329

Attach a mask to this component’s render object, replacing any existing mask. Returns a handle for inverse toggling, redraw (graphicsMask), or removal. The mask is torn down automatically when the component is destroyed.

MaskFactory

MaskHandle

VisualComponent.setMask


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

VisualComponent.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>

VisualComponent.stateMachine


update(deltaSeconds): void

Defined in: tilemap/src/TilemapComponent.ts:173

Advance the tile-animation clock. ComponentUpdateSystem supplies time already scaled by the scene and the entity, and skips paused scenes, so a paused game freezes its tilemaps and timeScale slows them.

number

void

VisualComponent.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

VisualComponent.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/tilemap.md.