A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
API surface — esengine/tilemap
Symbols: 0 public · 5 beta · 153 experimental · 0 deprecated
BuildNavGridOptions — interface @experimental
blockedTileIds: Iterable<number> | undefined
cellSize: number
height: number
isBlocked: ((tileId: number) => boolean) | undefined
origin: Vec2 | undefined
width: number
CHUNK_SIZE — const @experimental
16
COLLISION_BRUSHES — const @experimental
CollisionBrush[]
COLLISION_PALETTE_REF — const @experimental
"builtin:collision"
ChunkReadCore — interface @experimental
HEAPU8: Uint8Array<ArrayBufferLike> | undefined
_free: ((ptr: number) => void) | undefined
_malloc: ((bytes: number) => number) | undefined
tilemap_readChunkIndex: ((entity: number, rowsPtr: number, capacity: number) => number) | undefined
tilemap_readChunkTiles: ((entity: number, x: number, y: number, tilesPtr: number, capacity: number) => boolean) | undefined
CollectionGridTile — interface @experimental
id: number
pixels: Uint8Array<ArrayBufferLike>
CollisionBrush — interface @experimental
collision: ResolvedTileCollision
id: number
key: string
CollisionChunkSnapshot — type @experimental
DecodedChunk & { revision: number }
CollisionMaterial — interface @experimental
density: number | undefined
friction: number | undefined
restitution: number | undefined
DecodedChunk — interface @experimental
tiles: Uint16Array<ArrayBufferLike>
x: number
y: number
DestructibleTilemap — class @experimental
changedCells: number
createNavGrid: (opts: TileNavGridOptions) => NavGrid
damageAt: (x: number, y: number) => number
dig: (x: number, y: number, power?: number) => TileHit | null
digAtWorld: (worldX: number, worldY: number, power?: number) => TileHit | null
dispose: () => void
explode: (worldX: number, worldY: number, radius: number, power: number, opts?: TileExplosionOptions) => TileHit[]
fillRect: (x: number, y: number, width: number, height: number, tile: number) => readonly TileEdit[]
layer: number
load: (data: DestructibleTilemapData) => boolean
publishChunk: (chunkX: number, chunkY: number, tiles: Uint16Array) => void
releaseChunk: (chunkX: number, chunkY: number) => void
set: (x: number, y: number, tile: number) => boolean
setMany: (cells: Iterable<{ x: number; y: number; tile: number; }>) => readonly TileEdit[]
subscribe: (listener: (edits: readonly TileEdit[]) => void) => () => void
syncNavGrid: (grid: NavGrid, opts?: TileNavSyncOptions) => () => void
tileAt: (x: number, y: number) => number
toJSON: () => DestructibleTilemapData
worldToTile: (worldX: number, worldY: number) => { x: number; y: number; }
static new (app: App, layer: Entity, options: DestructibleTilemapOptions): DestructibleTilemap
static prototype: DestructibleTilemap
DestructibleTilemapData — interface @experimental
chunks: { x: number; y: number; cells: number[]; damage?: number[]; }[]
encoding: number[]
version: 1
DestructibleTilemapOptions — interface @experimental
collisionOutline: boolean | undefined
hardness: number | ((tileId: number) => number) | undefined
replaceWith: ((tileId: number) => number) | undefined
retile: TileRetile | undefined
streamed: boolean | undefined
LayerCollisionTable — interface @experimental
boxIds: ReadonlySet<number>
shapes: ReadonlyMap<number, ResolvedTileCollision>
LoadedTilemapLayer — type @experimental
TiledLayerData
LoadedTilemapSource — interface @experimental
collisionTileIds: number[] | undefined
hexSideLength: number | undefined
layers: TiledLayerData[]
objectGroups: TiledObjectGroupData[] | undefined
orientation: string | undefined
staggerAxis: string | undefined
staggerIndex: string | undefined
tileAnimations: Map<number, { tileId: number; duration: number; }[]> | undefined
tileHeight: number
tileProperties: Map<number, Map<string, string>> | undefined
tileShapes: Map<number, ResolvedTileCollision> | undefined
tileWidth: number
tilesets: LoadedTilemapTileset[]
LoadedTilemapTileset — interface @experimental
columns: number
firstId: number
margin: number
rows: number
spacing: number
textureHandle: number
MergedRect — interface @experimental
col: number
height: number
row: number
width: number
PublishedTilemap — interface @experimental
source: LoadedTilemapSource
PublishedTileset — interface @experimental
resolved: ResolvedTileset
ResolvedTileCollision — interface @experimental
density: number | undefined
friction: number | undefined
oneWay: { nx: number; ny: number; } | undefined
restitution: number | undefined
sensor: boolean | undefined
shape: { type: "box"; } | { type: "polygon"; points: [number, number][]; } | { type: "circle"; cx: number; cy: number; r: number; }
ResolvedTileset — interface @experimental
asset: TilesetAsset
textureHandle: number
textureHeight: number | undefined
textureWidth: number | undefined
TB_E — const @experimental
2
TB_N — const @experimental
1
TB_NE — const @experimental
16
TB_NW — const @experimental
128
TB_S — const @experimental
4
TB_SE — const @experimental
32
TB_SW — const @experimental
64
TB_W — const @experimental
8
TERRAIN_NEIGHBORS — const @experimental
readonly { dx: number; dy: number; bit: number; }[]
TILESET_FORMAT_VERSION — const @experimental
"1"
TILE_FLAGS_MASK — const @experimental
number
TILE_FLIP_D — const @experimental
32768
TILE_FLIP_H — const @experimental
8192
TILE_FLIP_V — const @experimental
16384
TILE_ID_MASK — const @experimental
8191
TerrainColor — interface @experimental
color: string
name: string
TerrainIndex — interface @experimental
byMask: Map<number, number>
mode: TerrainMode
TerrainIndices — interface @experimental
sets: Map<number, TerrainIndex>
tileTerrain: Map<number, number>
TerrainMode — type @experimental
'edge' | 'corner' | 'wang'
TextureDimensions — interface @experimental
height: number
width: number
TileCollisionPiece — interface @experimental
center: Vec2
circles: { c: Vec2; r: number; }[]
oneWay: { nx: number; ny: number; } | null
polylines: Vec2[][]
sensor: boolean
TileCollisionShape — type @experimental
| { type: 'box' }
| { type: 'polygon'; points: [number, number][] }
| { type: 'circle'; cx: number; cy: number; r: number }
TileEdit — interface @experimental
after: number
before: number
cause: TileEditCause
x: number
y: number
TileEditCause — type @experimental
'set' | 'dig' | 'explode' | 'retile' | 'load'
TileExplosionOptions — interface @experimental
falloff: number | undefined
shielded: boolean | undefined
TileFlags — interface @experimental
flipD: boolean
flipH: boolean
flipV: boolean
TileGridLayout — type @experimental
Omit<TileGridParams, 'tileWidth' | 'tileHeight'>
TileGridParams — interface @experimental
hexSideLength: number | undefined
orientation: number
staggerAxisX: boolean | undefined
staggerIndexEven: boolean | undefined
tileHeight: number
tileWidth: number
TileHit — interface @experimental
damage: number
destroyed: boolean
hardness: number
tile: number
x: number
y: number
TileNavGridOptions — interface @experimental
height: number
isBlocked: ((tileId: number) => boolean) | undefined
tileX: number | undefined
tileY: number | undefined
width: number
TileNavSyncOptions — interface @experimental
isBlocked: ((tileId: number) => boolean) | undefined
tileX: number | undefined
tileY: number | undefined
TileRetile — type @experimental
(x: number, y: number, read: (x: number, y: number) => number) => number | undefined
TileStamp — interface @experimental
cells: number[]
h: number
w: number
TiledAnimFrame — interface @experimental
duration: number
tileId: number
TiledCollectionTile — interface @experimental
height: number
id: number
image: string
width: number
TiledLayerData — interface @experimental
chunks: TiledChunkData[]
height: number
infinite: boolean
name: string
opacity: number
parallaxX: number
parallaxY: number
tiles: Uint16Array<ArrayBufferLike>
tintColor: { r: number; g: number; b: number; a: number; }
visible: boolean
width: number
TiledMapData — interface @experimental
collisionTileIds: number[]
height: number
hexSideLength: number
layers: TiledLayerData[]
objectGroups: TiledObjectGroupData[]
orientation: string
staggerAxis: string
staggerIndex: string
tileAnimations: Map<number, TiledAnimFrame[]>
tileHeight: number
tileProperties: Map<number, Map<string, string>>
tileShapes: Map<number, ResolvedTileCollision>
tileWidth: number
tilesets: TiledTilesetData[]
width: number
TiledObjectData — interface @experimental
gid: number | undefined
height: number
id: number
name: string
properties: Map<string, unknown>
rotation: number
shape: TiledObjectShape
type: string
vertices: number[] | null
visible: boolean
width: number
x: number
y: number
TiledObjectGroupData — interface @experimental
name: string
objects: TiledObjectData[]
properties: Map<string, unknown>
visible: boolean
TiledObjectShape — type @experimental
'rect' | 'ellipse' | 'polygon' | 'polyline' | 'point'
TiledTilesetData — interface @experimental
collectionTiles: TiledCollectionTile[] | undefined
columns: number
firstGid: number
image: string
margin: number | undefined
name: string
spacing: number | undefined
tileCount: number
tileHeight: number
tileWidth: number
Tilemap — const @experimental
ComponentDef<TilemapData>
TilemapAPI — const @experimental
{ initLayer(entity: number, width: number, height: number, tileWidth: number, tileHeight: number): void; destroyLayer(entity: number): void; setTile(entity: number, x: number, y: number, tileId: number): void; getTile(entity: number, x: number, y: number): number; fillRect(entity: number, x: number, y: number, w: number, h: number, tileId: number): void; setTiles(entity: number, tiles: Uint16Array): void; setTilesets(entity: number, slots: { firstId: number; textureHandle: number; columns: number; margin?: number; spacing?: number; extrude?: number; }[]): void; hasLayer(entity: number): boolean; setRenderProps(entity: number, textureHandle: number, tilesetColumns: number, uvTileW: number, uvTileH: number, sortLayer: number, depth: number, parallaxX: number, parallaxY: number): void; setTint(entity: number, r: number, g: number, b: number, a: number, opacity: number): void; setVisible(entity: number, visible: boolean): void; setOriginEntity(layerKey: number, originEntity: number): void; setTileAnimation(entity: number, tileId: number, frames: { tileId: number; duration: number; }[]): void; clearTileAnimations(entity: number): void; advanceAnimations(entity: number, dtMs: number): void; setTileProperty(entity: number, tileId: number, key: string, value: string): void; getTileProperty(entity: number, x: number, y: number, key: string): string; flipTile(entity: number, x: number, y: number, flipH: boolean, flipV: boolean, flipD: boolean): void; rotateTile(entity: number, x: number, y: number, degrees: number): void; initInfiniteLayer(entity: number, tileWidth: number, tileHeight: number): void; setChunkTiles(entity: number, chunkX: number, chunkY: number, tiles: Uint16Array, width: number, height: number): void; removeChunk(entity: number, chunkX: number, chunkY: number): void; setGridType(entity: number, type: number): void; setHexParams(entity: number, sideLength: number, staggerAxisX: boolean, staggerIndexEven: boolean): void; tileToWorld(entity: number, tx: number, ty: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; worldToTile(entity: number, wx: number, wy: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; exportChunks(entity: number): string; importChunks(entity: number, encoded: string): boolean; }
TilemapData — interface @experimental
source: string
TilemapLayer — const @beta
BuiltinComponentDef<TilemapLayerData>
TilemapLayerData — interface @beta
cellSize: Vec2
hexSideLength: number
lit: boolean | undefined
opacity: number
orientation: TilemapOrientation
originOffset: Vec2
parallaxFactor: Vec2
renderLayer: number
staggerAxis: TilemapStaggerAxis
staggerIndex: TilemapStaggerIndex
tileset: number
tilesetColumns: number
tintColor: Color
visible: boolean
TilemapLiveSync — const @experimental
{ setLayerTilesets(app: App, entity: number, refs: readonly string[]): void; }
TilemapLoadOptions — interface @experimental
collisionTileIds: number[] | undefined
generateObjectCollision: boolean | undefined
TilemapOrientation — enum @beta
Hexagonal = 3
Isometric = 1
Orthogonal = 0
Staggered = 2
TilemapPlugin — class @experimental
activeWhen: (ComponentDef<TilemapData> | BuiltinComponentDef<TilemapLayerData>)[]
build: (app: App) => void
cleanup: (app?: App) => void
name: string
static new (): TilemapPlugin
static prototype: TilemapPlugin
TilemapRuntime — class @experimental
dispose: () => void
install: (app: App) => void
resetLayers: () => void
setCollisionOutline: (entity: number, outline: boolean) => void
setLayerTilesets: (entity: number, refs: readonly string[]) => void
static new (): TilemapRuntime
static prototype: TilemapRuntime
TilemapStaggerAxis — enum @beta
X = 1
Y = 0
TilemapStaggerIndex — enum @beta
Even = 1
Odd = 0
Tilemaps — const @experimental
ResourceDef<{ initLayer(entity: number, width: number, height: number, tileWidth: number, tileHeight: number): void; destroyLayer(entity: number): void; setTile(entity: number, x: number, y: number, tileId: number): void; getTile(entity: number, x: number, y: number): number; fillRect(entity: number, x: number, y: number, w: number, h: number, tileId: number): void; setTiles(entity: number, tiles: Uint16Array): void; setTilesets(entity: number, slots: { firstId: number; textureHandle: number; columns: number; margin?: number; spacing?: number; extrude?: number; }[]): void; hasLayer(entity: number): boolean; setRenderProps(entity: number, textureHandle: number, tilesetColumns: number, uvTileW: number, uvTileH: number, sortLayer: number, depth: number, parallaxX: number, parallaxY: number): void; setTint(entity: number, r: number, g: number, b: number, a: number, opacity: number): void; setVisible(entity: number, visible: boolean): void; setOriginEntity(layerKey: number, originEntity: number): void; setTileAnimation(entity: number, tileId: number, frames: { tileId: number; duration: number; }[]): void; clearTileAnimations(entity: number): void; advanceAnimations(entity: number, dtMs: number): void; setTileProperty(entity: number, tileId: number, key: string, value: string): void; getTileProperty(entity: number, x: number, y: number, key: string): string; flipTile(entity: number, x: number, y: number, flipH: boolean, flipV: boolean, flipD: boolean): void; rotateTile(entity: number, x: number, y: number, degrees: number): void; initInfiniteLayer(entity: number, tileWidth: number, tileHeight: number): void; setChunkTiles(entity: number, chunkX: number, chunkY: number, tiles: Uint16Array, width: number, height: number): void; removeChunk(entity: number, chunkX: number, chunkY: number): void; setGridType(entity: number, type: number): void; setHexParams(entity: number, sideLength: number, staggerAxisX: boolean, staggerIndexEven: boolean): void; tileToWorld(entity: number, tx: number, ty: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; worldToTile(entity: number, wx: number, wy: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; exportChunks(entity: number): string; importChunks(entity: number, encoded: string): boolean; }>
TilesetAnimFrame — interface @experimental
durationMs: number
tile: number
TilesetAsset — interface @experimental
columns: number
extrude: number
margin: number
spacing: number
terrains: TilesetTerrain[] | undefined
texture: string
tileCount: number | undefined
tileHeight: number
tileWidth: number
tiles: Record<number, TilesetTile>
version: string
TilesetCollision — type @experimental
TileCollisionShape & {
/** One-way (jump-through) platform: contacts from behind this normal pass through. */
oneWay?: { nx: number; ny: number };
/** Non-solid trigger volume (fires events, no physical response). */
sensor?: boolean;
/** Physics material overrides (absent = engine defaults). */
density?: number;
friction?: number;
restitution?: number;
}
TilesetModel — interface @experimental
animations: Map<number, { tileId: number; duration: number; }[]>
collidableTileIds: number[]
slots: TilesetModelSlot[]
tileProperties: Map<number, Record<string, string>> | undefined
tileShapes: Map<number, ResolvedTileCollision>
TilesetModelSlot — interface @experimental
columns: number
extrude: number
firstId: number
margin: number
spacing: number
textureHandle: number
TilesetTerrain — interface @experimental
color: string | undefined
colors: TerrainColor[] | undefined
mode: TerrainMode
name: string
TilesetTile — interface @experimental
animation: TilesetAnimFrame[] | undefined
collision: TilesetCollision | undefined
probability: number | undefined
properties: Record<string, string> | undefined
terrain: TilesetTileTerrain | undefined
TilesetTileTerrain — interface @experimental
corners: number[] | undefined
mask: number | undefined
set: number
Vec2Like — interface @experimental
x: number
y: number
WangIndex — interface @experimental
byKey: Map<number, number>
WangIndices — interface @experimental
sets: Map<number, WangIndex>
tileTerrain: Map<number, number>
atlasCells — function @experimental
(size: number, margin: number, tileSize: number, spacing: number): number
buildCollisionPaletteModel — function @experimental
(material?: CollisionMaterial): TilesetModel
buildTerrainIndices — function @experimental
(asset: TilesetAsset): TerrainIndices
buildWangIndices — function @experimental
(asset: TilesetAsset): WangIndices
canonicalMask — function @experimental
(mode: TerrainMode, mask: number): number
collidableTileIds — function @experimental
(asset: TilesetAsset): number[]
collisionRefWithMaterial — function @experimental
(material: CollisionMaterial): string
createDestructibleTilemap — function @experimental
(app: App, layer: Entity, options?: DestructibleTilemapOptions): DestructibleTilemap
createTileset — function @experimental
(texture: string, tileWidth?: number, tileHeight?: number, columns?: number): TilesetAsset
decodeTilemapChunks — function @experimental
(blob: string): DecodedChunk[]
encodeTile — function @experimental
(id: number, flags?: TileFlags): number
flipFlagsH — function @experimental
(flags: TileFlags): TileFlags
flipFlagsV — function @experimental
(flags: TileFlags): TileFlags
flipStampH — function @experimental
(s: TileStamp): TileStamp
flipStampV — function @experimental
(s: TileStamp): TileStamp
generateChunkCollision — function @experimental
(world: World, chunks: { x: number; y: number; tiles: Uint16Array; }[], collisionIds: Set<number>, tileW: number, tileH: number, originX: number, originY: number, pixelsPerUnit?: number, layout?: TileGridLayout): Entity[]
generateChunkPolygonCollision — function @experimental
(world: World, chunks: { x: number; y: number; tiles: Uint16Array; }[], polygonShapes: Map<number, readonly [number, number][]>, tileW: number, tileH: number, originX: number, originY: number, pixelsPerUnit?: number, layout?: TileGridLayout): Entity[]
generateChunkTileShapes — function @experimental
(world: World, chunks: { x: number; y: number; tiles: Uint16Array; }[], tileShapes: Map<number, ResolvedTileCollision>, tileW: number, tileH: number, originX: number, originY: number, pixelsPerUnit?: number, layout?: TileGridLayout): Entity[]
generateLayerCollision — function @experimental
(world: World, tiles: ArrayLike<number>, gridWidth: number, gridHeight: number, tileW: number, tileH: number, collisionIds: Set<number>, originX: number, originY: number, pixelsPerUnit?: number, layout?: TileGridLayout): Entity[]
generateLayerTileShapes — function @experimental
(world: World, tiles: ArrayLike<number>, gridWidth: number, gridHeight: number, tileShapes: Map<number, ResolvedTileCollision>, tileW: number, tileH: number, originX: number, originY: number, pixelsPerUnit?: number, layout?: TileGridLayout): Entity[]
generateObjectCollision — function @experimental
(world: World, groups: TiledObjectGroupData[], originX: number, originY: number, pixelsPerUnit?: number): Entity[]
generateTileCollision — function @experimental
(world: World, layer: TiledLayerData, mapData: TiledMapData, collisionIds: Set<number>, originX: number, originY: number): Entity[]
getTextureDimensions — function @experimental
(handle: number): TextureDimensions | null
isCollisionObjectGroup — function @experimental
(group: TiledObjectGroupData): boolean
isCollisionPaletteRef — function @experimental
(refs: readonly string[]): boolean
isEmptyStamp — function @experimental
(s: TileStamp): boolean
isHexOrientation — function @experimental
(orientation: number): boolean
isNonOrthogonal — function @experimental
(orientation: number): boolean
isTileSolid — function @experimental
(layer: Entity | number, x: number, y: number): boolean
loadTiledCollisionObjects — function @experimental
(world: World, mapData: TiledMapData, mapOriginX: number, mapOriginY: number, pixelsPerUnit?: number): Entity[]
loadTiledMap — function @experimental
(world: World, mapData: TiledMapData, textureHandles: Map<string, number>, options?: TilemapLoadOptions): Entity[]
mergeCollisionTiles — function @experimental
(tiles: ArrayLike<number>, mapWidth: number, mapHeight: number, collisionTileIds: Set<number>): MergedRect[]
navGridFromTilemapLayer — function @experimental
(entity: Entity, opts: BuildNavGridOptions): NavGrid
navGridFromTiles — function @experimental
(getTile: (x: number, y: number) => number, opts: BuildNavGridOptions): NavGrid
normalizeCornerMask — function @experimental
(mask: number): number
oneWayNormalWorld — function @experimental
(nx: number, ny: number, fH: boolean, fV: boolean, fD: boolean): { x: number; y: number; }
orientationPerm — function @experimental
(flags: TileFlags): Perm
packCollectionGrid — function @experimental
(tiles: CollectionGridTile[], tileWidth: number, tileHeight: number): { pixels: Uint8Array; columns: number; rows: number; width: number; height: number; }
packCorners — function @experimental
(tl: number, tr: number, br: number, bl: number): number
parseCollisionMaterial — function @experimental
(refs: readonly string[]): CollisionMaterial
parseTileset — function @experimental
(rawJson: unknown): TilesetAsset
parseTmjJson — function @experimental
(json: Record<string, unknown>): TiledMapData | null
parseTmjWithExternals — function @experimental
(json: Record<string, unknown>, resolveExternal: (source: string) => Promise<string>): Promise<TiledMapData | null>
peeringRetile — function @experimental
(asset: TilesetAsset, firstId?: number): TileRetile
polygonLocalVerts — function @experimental
(norm: ReadonlyArray<readonly [number, number]>, tileW: number, tileH: number, flipH: boolean, flipV: boolean, flipD: boolean): { x: number; y: number; }[]
readCollisionChunks — function @experimental
(core: ChunkReadCore | null, entity: number, previous: ReadonlyMap<string, CollisionChunkSnapshot> | null): Map<string, CollisionChunkSnapshot> | null
resolveAutotile — function @experimental
(index: TerrainIndex, neighbors: readonly boolean[]): number
resolveAutotileMatch — function @experimental
(index: TerrainIndex, neighbors: readonly boolean[]): { tileId: number; exact: boolean; mask: number; }
resolveRelativePath — function @experimental
(basePath: string, relativePath: string): string
resolveTilesetModel — function @experimental
(tilesets: ResolvedTileset[]): TilesetModel
resolveWang — function @experimental
(index: WangIndex, corners: readonly number[]): number
resolveWangMatch — function @experimental
(index: WangIndex, corners: readonly number[]): { tileId: number; exact: boolean; key: number; }
resolvedTileset — function @experimental
(assets: AssetsData | null | undefined, ref: string): ResolvedTileset | undefined
rotateFlagsCW — function @experimental
(flags: TileFlags): TileFlags
rotateStampCW — function @experimental
(s: TileStamp): TileStamp
serializeTileset — function @experimental
(asset: TilesetAsset): Record<string, unknown>
singleStamp — function @experimental
(raw: number): TileStamp
spawnObjectRegion — function @experimental
(world: World, obj: TiledObjectData, parent: Entity, pixelsPerUnit: number, sensor: boolean): Entity | null
tileCellCenter — function @experimental
(p: TileGridParams, tx: number, ty: number): Vec2Like
tileCellOutline — function @experimental
(p: TileGridParams): Vec2Like[]
tileColliderShape — function @experimental
(rc: ResolvedTileCollision, tileW: number, tileH: number, flipH: boolean, flipV: boolean, flipD: boolean): Collider2DShape
tileCollisionAt — function @experimental
(layer: Entity | number, x: number, y: number): ResolvedTileCollision | null
tileCollisionAtWorld — function @experimental
(layer: Entity | number, worldX: number, worldY: number, originX?: number, originY?: number, rotation?: number): ResolvedTileCollision | null
tileCollisionOutlines — function @experimental
(chunks: DecodedChunk[], model: TilesetModel, tileW: number, tileH: number, originX: number, originY: number, layout?: TileGridLayout): TileCollisionPiece[]
tileFlagsOf — function @experimental
(raw: number): TileFlags
tileIdOf — function @experimental
(raw: number): number
tiledCollisionMods — function @experimental
(props: Array<Record<string, unknown>> | undefined): Partial<Pick<ResolvedTileCollision, "density" | "friction" | "oneWay" | "restitution" | "sensor">>
tiledObjectgroupShape — function @experimental
(objects: Array<Record<string, unknown>> | undefined, tw: number, th: number): ResolvedTileCollision["shape"] | null
tilemapPlugin — const @experimental
TilemapPlugin
tilemapSource — function @experimental
(assets: AssetsData | null | undefined, ref: string): LoadedTilemapSource | undefined
usesStagger — function @experimental
(orientation: number): boolean