Skip to content

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.

27.3 KB
Raw Blame

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