kaplay-plugin-tiled/dist/plugin.d.cts

KAPLAY plugin for Tiled maps

import { CompList } from 'kaplay';
import { KAPLAYCtx } from 'kaplay';

export declare type AddTiledMap = (map: TiledMap, options: TiledMapOpt) => void;

declare type TiledLayer = TiledObjectLayer | TiledTileLayer;

export declare type TiledMap = TiledMapData | string;

declare interface TiledMapData {
    height: number;
    infinite: boolean;
    layers: TiledLayer[];
    orientation: string;
    renderorder?: string;
    tileheight: number;
    tilesets: TiledTileset[];
    tilewidth: number;
    width: number;
}

export declare interface TiledMapOpt {
    layerNames?: string[];
    objects?: TiledObjectRule[];
    sprite: string;
    tiles?: TiledTileRule[];
}

declare interface TiledObject {
    height: number;
    id: number;
    name: string;
    point?: boolean;
    properties?: TiledProperty[];
    rotation: number;
    type: string;
    visible: boolean;
    width: number;
    x: number;
    y: number;
}

declare interface TiledObjectContext {
    height: number;
    id: number;
    layer: string;
    name: string;
    width: number;
    x: number;
    y: number;
    point: boolean;
    properties: Record<string, TiledPropertyValue>;
    rotation: number;
    type: string;
}

declare interface TiledObjectLayer {
    draworder?: string;
    id: number;
    name: string;
    objects: TiledObject[];
    opacity?: number;
    type: string;
    visible?: boolean;
    x?: number;
    y?: number;
}

declare interface TiledObjectMatch {
    layer?: string;
    name?: string;
    properties?: Record<string, TiledPropertyValue>;
    type?: string;
}

declare interface TiledObjectRule {
    comps: (object: TiledObjectContext) => CompList<unknown>;
    match: TiledObjectMatch;
}

/**
 * KAPLAY plugin that adds `addTiledMap()` to the context.
 *
 * @param k - The active KAPLAY context.
 * @returns - The plugin API.
 */
export declare function tiledPlugin(k: KAPLAYCtx): {
    addTiledMap: AddTiledMap;
};

declare interface TiledProperty {
    name: string;
    type?: string;
    value: TiledPropertyValue;
}

declare type TiledPropertyValue = boolean | number | string;

declare interface TiledTileContext {
    flip: {
        diagonal: boolean;
        horizontal: boolean;
        vertical: boolean;
    };
    gid: number;
    layer: string;
    height: number;
    tileHeight: number;
    tileWidth: number;
    tileX: number;
    tileY: number;
    width: number;
    x: number;
    y: number;
    properties: Record<string, TiledPropertyValue>;
    tileId: number;
}

declare interface TiledTileDefinition {
    id: number;
    properties?: TiledProperty[];
}

declare interface TiledTileLayer {
    data: number[];
    height: number;
    name: string;
    opacity?: number;
    type: string;
    visible?: boolean;
    width: number;
    x?: number;
    y?: number;
}

declare interface TiledTileMatch {
    gid?: number;
    layer?: string;
    properties?: Record<string, TiledPropertyValue>;
    tileId?: number;
}

declare interface TiledTileRule {
    comps: (tile: TiledTileContext) => CompList<unknown>;
    match: TiledTileMatch;
}

declare interface TiledTileset {
    columns: number;
    firstgid: number;
    image: string;
    imageheight: number;
    imagewidth: number;
    margin?: number;
    name: string;
    spacing?: number;
    tilecount: number;
    tileheight: number;
    tiles?: TiledTileDefinition[];
    tilewidth: number;
}

export { }


declare module 'kaplay' {
    interface KAPLAYCtx {
        addTiledMap: (map: TiledMap, options: TiledMapOpt) => void;
    }
}