@canvasengine/tiled 2.0.0-beta.25

package/dist/classes/Gid.d.ts

@@ -0,0 +1,13 @@
+import { TiledProperties } from './Properties';
+export declare class TileGid extends TiledProperties {
+    obj?: any;
+    private _gid;
+    constructor(obj?: any);
+    static getRealGid(gid: number): number;
+    get horizontalFlip(): boolean;
+    get verticalFlip(): boolean;
+    get diagonalFlip(): boolean;
+    get rotatedHex120(): boolean;
+    get gid(): number;
+    set gid(val: number);
+}

package/dist/classes/Layer.d.ts

@@ -0,0 +1,26 @@
+import { TiledLayer } from '../types/Layer';
+import { TiledObjectClass } from './Object';
+import { TiledProperties } from './Properties';
+import { Tile } from './Tile';
+import { Tileset } from './Tileset';
+export declare class Layer extends TiledProperties {
+    private tilesets;
+    private parent?;
+    cacheTiles: boolean;
+    tiles: (Tile | undefined)[];
+    objects: TiledObjectClass[];
+    get size(): number;
+    constructor(layer: TiledLayer, tilesets: Tileset[], parent?: Layer | undefined);
+    createTile(gid: number, tileIndex: number, layerIndex?: number): Tile | undefined;
+    private mergePropertiesWithParent;
+    private propertiesTiles;
+    private mapObjects;
+    getTileByIndex(tileIndex: number): Tile | undefined;
+    static findTileSet(gid: number, tileSets: Tileset[]): Tileset | undefined;
+    getLayerParent(): Layer | undefined;
+    tilesForEach(cb: (tile: Tile | undefined, index: number) => void): void;
+    setData(tileIndex: number, gid: number): void;
+}
+export interface Layer extends TiledLayer {
+    objects: TiledObjectClass[];
+}

package/dist/classes/Map.d.ts

@@ -0,0 +1,232 @@
+import { TiledLayer } from '../types/Layer';
+import { TiledMap } from '../types/Map';
+import { TiledTileset } from '../types/Tileset';
+import { Layer } from './Layer';
+import { TiledObjectClass } from './Object';
+import { TiledProperties } from './Properties';
+import { Tile } from './Tile';
+import { Tileset } from './Tileset';
+export interface TileInfo {
+    tiles: Tile[];
+    hasCollision: boolean | undefined;
+    isClimbable?: boolean | undefined;
+    isOverlay: boolean | undefined;
+    objectGroups: TiledObjectClass[];
+    tileIndex: number;
+}
+export interface GetTileOptions {
+    populateTiles?: boolean;
+}
+export declare let bufferTilesets: {};
+export declare class MapClass extends TiledProperties {
+    /**
+     * @title Data of map
+     * @prop {object} [data]
+     * @readonly
+     * @memberof Map
+     * @memberof RpgSceneMap
+     * */
+    data: TiledMap;
+    tilesets: Tileset[];
+    layers: Layer[];
+    private tmpLayers;
+    private tilesIndex;
+    /**
+     * Allows to define the size of ArrayBuffer to keep in memory the tiles of the map
+     */
+    private allocateMemory;
+    /**
+     * If set to true, the memory allocation will take only one tile (the tile of the last layer)
+     */
+    private lowMemory;
+    constructor(map?: TiledMap);
+    load(map: TiledMap): void;
+    /**
+     * @title Width of the map in pixels
+     * @prop {number} [widthPx]
+     * @readonly
+     * @memberof Map
+     * @memberof RpgSceneMap
+     * */
+    get widthPx(): number;
+    /**
+    * @title Height of the map in pixels
+    * @prop {number} [heightPx]
+    * @readonly
+    * @memberof Map
+    * @memberof RpgSceneMap
+    * */
+    get heightPx(): number;
+    /**
+     * @title The depth of the map in pixels (this is the height of a tile ;))
+     * @prop {number} map.zTileHeight
+     * @readonly
+     * @memberof Map
+     * @memberof RpgSceneMap
+     * */
+    get zTileHeight(): number;
+    /**
+     * Find a layer by name. Returns `undefined` is the layer is not found
+
+     * @title Get Layer by name
+     * @method map.getLayerByName(name)
+     * @param {string} name layer name
+     * @returns {LayerInfo | undefined}
+     * @example
+     *  ```ts
+     *  const tiles = map.getLayerByName(0, 0)
+     *  ```
+     * @memberof Map
+     * @memberof RpgSceneMap
+     */
+    getLayerByName(name: string): TiledLayer | undefined;
+    /**
+    * Get the tile index on the tileset
+    *
+    * @title Get index of tile
+    * @method map.getTileIndex(x,y)
+    * @param {number} x Position X
+    * @param {number} x Position Y
+    * @returns {number}
+    * @memberof Map
+    * @memberof RpgSceneMap
+    */
+    getTileIndex(x: number, y: number, [z]?: [number]): number;
+    getTilePosition(index: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Find the point of origin (top left) of a tile. Of course, its position depends on the size of the tile
+
+     * @title Get origin position of tile
+     * @method map.getTileOriginPosition(x,y)
+     * @param {number} x Position X
+     * @param {number} x Position Y
+     * @returns { {x: number, y: number }}
+     * @example
+     *  ```ts
+     *  // If the size of a tile is 32x32px
+     *  const position = map.getTileOriginPosition(35, 12)
+     *  console.log(position) // { x: 32, y: 0 }
+     *  ```
+     * @memberof Map
+     * @memberof RpgSceneMap
+     */
+    getTileOriginPosition(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+    /**
+    * Recover tiles according to a position
+
+    * @title Get tile by position
+    * @method map.getTileByPosition(x,y)
+    * @param {number} x Position X
+    * @param {number} x Position Y
+    * @returns {TileInfo}
+    * @example
+    *  ```ts
+    *  const tiles = map.getTileByPosition(0, 0)
+    *  ```
+    * @memberof Map
+    * @memberof RpgSceneMap
+    */
+    getTileByPosition(x: number, y: number, z?: [number, number], options?: GetTileOptions): TileInfo;
+    /**
+     * Retrieves tiles according to its index
+
+     * @title Get tile by index
+     * @method map.getTileByIndex(tileIndex)
+     * @param {number} tileIndex tile index
+     * @returns {TileInfo}
+     * @example
+     *  ```ts
+     *  const index = map.getTileIndex(0, 0)
+     *  const tiles = map.getTileByIndex(index)
+     *  ```
+     * @memberof Map
+     * @memberof RpgSceneMap
+     */
+    getTileByIndex(tileIndex: number, zPlayer?: [number, number], options?: GetTileOptions): TileInfo;
+    getAllObjects(): TiledObjectClass[];
+    getData(): {
+        layers: Layer[];
+        type: "map";
+        version: number;
+        width: number;
+        height: number;
+        hexsidelength: number;
+        tileheight: number;
+        tilewidth: number;
+        backgroundcolor: string;
+        compressionlevel: number;
+        infinite: boolean;
+        nextlayerid: number;
+        nextobjectid: number;
+        orientation: "orthogonal" | "isometric" | "staggered" | "hexagonal";
+        properties: {
+            [key: string]: any;
+        };
+        tilesets: TiledTileset[];
+        renderorder: "right-down" | "right-up" | "left-down" | "left-up";
+        staggeraxis: "x" | "y";
+        staggerindex: "odd" | "even";
+        tiledversion: string;
+        class: string;
+    };
+    setTile(x: number, y: number, layerFilter: string | ((layer: any) => boolean), tileInfo: any): {
+        x: number;
+        y: number;
+        tiles: {
+            [tileIndex: number]: Tile;
+        };
+    } | never;
+    removeCacheTileset(name: string): void;
+    clearCacheTilesets(): void;
+    private mapTilesets;
+    private mapLayers;
+    private setTileIndex;
+    /**
+     * We multiply by 2 because 2 entries are stored for a tile: its GID and the Layer Index
+     *
+     * Example If I have 3 layers, The array will have the following form
+     *
+     * [
+     *  GID of Layer 3,
+     *  Layer Index of Layer 3,
+     *  GID of Layer 2,
+     *  Layer Index of Layer 2,
+     *  GID of Layer 1,
+     *  Layer Index of Layer 1,
+     * ... others tiles
+     * ]
+     *
+     * The size in memory of the map is therefore:
+     *
+     * `(map width * map height * number of layers * 4) bytes`
+     *
+     * > We multiply by 4, because an element takes 2 bytes and has 2 elements for a tile is 4 bytes in all
+     *
+     * Example (a 100x100 map with 5 layers)
+     *
+     * `100 * 100 * 5 * 4 = 200000 bytes = ~195 Kb`
+     *
+     * If we define on lowMemory then the calculation is the following
+     *
+     * `(map width * map height * 4) bytes`
+     *
+     * Example
+     *
+     * `100 * 100 * 4 = 40000 bytes = ~39 Kb`
+     */
+    private get realAllocateMemory();
+    /**
+     * We keep each tile in memory classified by z value. The values are ordered from the end to the beginning so that the first element of the array (when retrieved with getTileByIndex() is the tile on the highest layer. This way, the tile search is very fast for collisions
+     *
+     */
+    private addTileIndex;
+    private setTilesIndex;
+}
+export interface MapClass extends TiledMap {
+}

package/dist/classes/Object.d.ts

@@ -0,0 +1,8 @@
+import { TiledObject } from '../types/Objects';
+import { TileGid } from './Gid';
+export declare class TiledObjectClass extends TileGid {
+    layerName?: string;
+    constructor(object?: TiledObject);
+}
+export interface TiledObjectClass extends TiledObject {
+}

package/dist/classes/Properties.d.ts

@@ -0,0 +1,11 @@
+export declare class TiledProperties {
+    properties: {
+        [key: string]: any;
+    };
+    class: string;
+    constructor(data?: any);
+    getProperty<P, D = undefined>(name: string, defaultValue?: D): P | D;
+    hasProperty(name: string): boolean;
+    setProperty<T>(name: string, value: T): void;
+    getType(): string;
+}

package/dist/classes/Tile.d.ts

@@ -0,0 +1,19 @@
+import { TilesetTile } from '../types/Tile';
+import { TileGid } from './Gid';
+type TileInfo = TilesetTile & {
+    gid?: number;
+    index: number;
+    layerIndex?: number;
+};
+export declare class Tile extends TileGid {
+    tile: TileInfo | {
+        gid: number;
+    };
+    index: number;
+    constructor(tile: TileInfo | {
+        gid: number;
+    });
+}
+export interface Tile extends TileInfo {
+}
+export {};

package/dist/classes/Tileset.d.ts

@@ -0,0 +1,13 @@
+import { TilesetTile } from '../types/Tile';
+import { TiledTileset } from '../types/Tileset';
+import { TiledProperties } from './Properties';
+import { Tile } from './Tile';
+export declare class Tileset extends TiledProperties {
+    private tileset;
+    private cacheTileId;
+    constructor(tileset: TiledTileset);
+    addTile(tileObj: TilesetTile): Tile;
+    getTile(id: number): Tile | undefined;
+}
+export interface Tileset extends TiledTileset {
+}

package/dist/generate/tileset.d.ts

@@ -0,0 +1,11 @@
+import { default as builder } from 'xmlbuilder';
+export declare class Tileset {
+    protected nbTilesWidth: number;
+    protected nbTilesHeight: number;
+    constructor(nbTilesWidth: number, nbTilesHeight: number);
+    generate(attr: {
+        root: any;
+        image: any;
+    }): builder.XMLElement;
+    createTile(id: number, properties: any): builder.XMLElement;
+}

package/dist/generate/wangtile.d.ts

@@ -0,0 +1,21 @@
+import { default as builder } from 'xmlbuilder';
+import { Tileset } from './tileset';
+export declare class Autotile extends Tileset {
+    private nbGroupTilesWidth;
+    private nbGroupTilesHeight;
+    private nbAnimation;
+    static readonly HEIGHT_TILES: number;
+    static readonly WIDTH_TILES: number;
+    constructor(nbGroupTilesWidth: number, nbGroupTilesHeight: number, nbAnimation?: number);
+    static getWangTiles(id: number): [number, number, number, number, number, number, number, number][];
+    static getRandomColor(): string;
+    get hasAnimation(): boolean;
+    getIndex(x: number, y: number): number;
+    generate(attr: {
+        root: any;
+        image: any;
+        tile: any;
+    }): builder.XMLElement;
+    generateAnimationTile(tileId: number): builder.XMLElement;
+    generateWangTiles(tileId?: number, name?: string): builder.XMLElement;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export type { TiledWorld, TiledWorldMap } from './types/WorldMaps';
+export type { TiledTileset } from './types/Tileset';
+export type { TiledObject } from './types/Objects';
+export type { TiledImage } from './types/Types';
+export { type TiledLayer, TiledLayerType } from './types/Layer';
+export type { TiledText } from './types/Text';
+export type { TiledMap } from './types/Map';
+export { isTiledFormat } from './utils';
+export { TiledParser } from './parser/parser';
+export { TiledProperties } from './classes/Properties';
+export { Tile } from './classes/Tile';
+export { Layer } from './classes/Layer';
+export { Tileset } from './classes/Tileset';
+export { TiledObjectClass } from './classes/Object';
+export { TiledParserFile } from './parser/open-file';
+export { MapClass } from './classes/Map';