@canvasengine/tiled 2.0.0-beta.25

package/src/types/Tileset.ts

@@ -0,0 +1,99 @@
+import { TilesetTile } from "./Tile";
+import { TiledGrid, TiledMapTerrain, TiledProperty, TiledTileOffset, TiledWangSet } from "./Types";
+
+export interface TiledTileset {
+    type: 'tileset';
+    /**
+     * The JSON format version
+     */
+    version: number;
+ 
+    /**
+     * GID corresponding to the first tile in the set
+     */
+    firstgid: number;
+    /**
+     * Image used for tiles in this set
+     */
+    image: {
+        source: string
+        height: number
+        width: number
+    }
+    /**
+     * Height of source image in pixels
+     */
+    imageheight: number;
+    /**
+     * Width of source image in pixels
+     */
+    imagewidth: number;
+    /**
+     * (optional)
+     */
+    grid: TiledGrid;
+    /**
+     * Buffer between image edge and first tile (pixels)
+     */
+    margin: number;
+    /**
+     * Alignment to use for tile objects (unspecified (default), topleft, top, topright, left, center, right, bottomleft, bottom or bottomright) (since 1.4)
+     */
+    objectalignment: 'unspecified' | 'topleft' | 'top' | 'topright' | 'left' | 'center' | 'right' | 'bottomleft' | 'bottom' | 'bottomright';
+    /**
+     * Refers to external tileset file (should be JSON)
+     */
+    source: string;
+    /**
+     * Spacing between adjacent tiles in image (pixels)
+     */
+    spacing: number;
+ 
+    columns: number;
+    rows: number;
+    /**
+     * Maximum height of tiles in this set
+     */
+    tileheight: number;
+    tilewidth: number;
+ 
+    /**
+     * Array of Tiles (optional)
+     */
+    tiles: TilesetTile[];
+ 
+    name: string;
+    properties: {
+        [key: string]: any
+    }
+    /**
+     * The number of tiles in this tileset
+     */
+    tilecount: number;
+    /**
+     * Optional
+     */
+    tileoffset: TiledTileOffset;
+ 
+    /**
+     * The Tiled version used to save the file
+     */
+    tiledversion: string;
+    /**
+     * Hex-formatted color (#RRGGBB or #AARRGGBB) (optional)
+     */
+    backgroundcolor: string;
+    /**
+     * Hex-formatted color (#RRGGBB) (optional)
+     */
+    transparentcolor: string;
+    /**
+     * Array of Terrains (optional)
+     */
+    terrains: TiledMapTerrain[];
+ 
+    /**
+     * Array of Wang sets (since 1.1.5)
+     */
+    wangsets: TiledWangSet[];
+ }

package/src/types/Types.ts

@@ -0,0 +1,157 @@
+export interface TiledProperty<T = unknown> {
+    /**
+     * Name of the property
+     */
+    name: string;
+    /**
+     * Type of the property (string (default), int, float, bool, color or file (since 0.16, with color and file added in 0.17))
+     */
+    type: 'string' | 'int' | 'float' | 'bool' | 'color' | 'file';
+    /**
+     * Value of the property
+     */
+    value: T;
+ }
+ 
+ export type TiledEncoding = 'csv' | 'base64';
+ export type TiledCompression = 'zlib' | 'gzip' | 'zstd';
+ 
+ export interface TiledChunk {
+    /**
+     * Array of unsigned int (GIDs) or base64-encoded data
+     */
+    data: number[] | string;
+    /**
+     * Height in tiles
+     */
+    height: number;
+    /**
+     * Width in tiles
+     */
+    width: number;
+    /**
+     * X coordinate in tiles
+     */
+    x: number;
+    /**
+     * Y coordinate in tiles
+     */
+    y: number;
+ }
+ 
+ export interface TiledTileOffset {
+    /**
+     * Horizontal offset in pixels
+     */
+    x: number;
+    /**
+     * Vertical offset in pixels (positive is down)
+     */
+    y: number;
+ }
+ 
+ export interface TiledWangSet {
+    /**
+     * Array of Wang colors
+     */
+    cornercolors: TiledWangColor[];
+    /**
+     * Array of Wang colors
+     */
+    edgecolors: TiledWangColor[];
+    name: string;
+    properties: TiledProperty[];
+    /**
+     * Local ID of tile representing the Wang set
+     */
+    tile: number;
+    wangtiles: TiledWangTile[];
+ }
+ 
+ export interface TiledWangTile {
+    /**
+     * Array of Wang color indexes (uchar[8]
+     */
+    wangid: number[];
+    /**
+     * Tile is flipped diagonally (default: false)
+     */
+    dflip: boolean;
+    /**
+     * Tile is flipped horizontally (default: false)
+     */
+    hflip: boolean;
+    /**
+     * Local ID of tile
+     */
+    tileid: number;
+    /**
+     * Tile is flipped vertically (default: false)
+     */
+    vflip: boolean;
+ }
+ 
+ export interface TiledWangColor {
+    /**
+     * Hex-formatted color (#RRGGBB or #AARRGGBB)
+     */
+    color: string;
+    /**
+     * Name of the Wang color
+     */
+    name: string;
+    /**
+     * Probability used when randomizing
+     */
+    probability: number;
+    /**
+     * Local ID of tile representing the Wang color
+     */
+    tile: number;
+ }
+ 
+ export interface TiledGrid {
+    /**
+     *	orthogonal (default) or isometric
+     */
+    orientation: 'orthogonal' | 'isometric';
+    /**
+     * Cell width of tile grid
+     */
+    width: number;
+    /**
+     * Cell height of tile grid
+     */
+    height: number;
+ }
+ 
+ export interface TiledFrame {
+    /**
+     * Frame duration in milliseconds
+     */
+    duration: number;
+    /**
+     * 	Local tile ID representing this frame
+     */
+    tileid: number;
+ }
+ export interface TiledMapTerrain {
+    name: string;
+    /**
+     * Local ID of tile representing terrain
+     */
+    tile: number;
+    properties: TiledProperty[];
+ }
+ 
+ export interface TiledPoint {
+    x: number;
+    y: number;
+ }
+
+ export interface TiledImage {
+   source: string,
+   width: number, 
+   height: number
+   trans?: string
+ }

package/src/types/WorldMaps.ts

@@ -0,0 +1,13 @@
+export interface TiledWorldMap {
+    fileName: string
+    height: number
+    width: number
+    x: number
+    y: number
+}
+
+export interface TiledWorld {
+    maps: TiledWorldMap[]
+    onlyShowAdjacentMaps: boolean,
+    type: 'world'
+}

package/src/utils.ts

@@ -0,0 +1,22 @@
+export function isTiledFormat(val: any): boolean {
+    return typeof val == 'object' && val.version && val.orientation
+}
+/**
+ * Join path segments with forward slashes
+ * @param {...string} segments - Path segments to join
+ * @returns {string} Joined path
+ * @example
+ * joinPath('base', 'static', 'file.json') // returns 'base/static/file.json'
+ */
+
+export function joinPath(...segments: string[]): string {
+    return segments
+        .filter(segment => segment && segment.length > 0)
+        .join('/')
+        .replace(/\/+/g, '/') // Replace multiple slashes with single slash
+}
+
+
+export function getBaseName(path: string): string {
+    return path.substring(0, path.lastIndexOf('/') + 1)
+}

package/tests/class.spec.ts

@@ -0,0 +1,88 @@
+import { TiledParser } from "../src/parser/parser"
+import { tileset, xmlObjectImage, xmlTile } from "./data"
+import { Tileset } from '../src/classes/Tileset'
+import { Layer, Tile, TiledLayerType, TiledObjectClass } from '../src'
+import { test, expect, describe, beforeEach } from 'vitest'
+
+let layer: Layer
+
+function setLayer(xml) {
+    const parser = new TiledParser(xml)
+    const map = parser.parseMap()
+    const parserTileset = new TiledParser(tileset)
+    const tilesetData = parserTileset.parseTileset()
+    const tilesetInstance = new Tileset(tilesetData)
+    map.layers[0].properties = {}
+    map.layers[0].properties['cache-tiles'] = true
+    layer = new Layer(map.layers[0], [tilesetInstance])
+}
+
+describe('Tests classes', () => {
+
+    beforeEach(() => {
+        setLayer(xmlTile)
+    })
+
+    test('Verify tiles array', () => {
+        expect(layer.tiles).toBeDefined()
+    })
+
+    test('tiles is not empty', () => {
+        expect(layer.tiles).toHaveLength(layer.width * layer.height)
+    })
+
+    test('tile is Tile instance', () => {
+        expect(layer.tiles[0]).toBeInstanceOf(Tile)
+    })
+
+    test('Get Gid', () => {
+        const tile = layer.tiles[0]
+        expect(tile?.gid).toBe(9)
+    })
+
+    test('Get Gid Flip', () => {
+        const tile = layer.tiles[1]
+        expect(tile?.horizontalFlip).toBe(true)
+        expect(tile?.verticalFlip).toBe(false)
+        expect(tile?.diagonalFlip).toBe(true)
+    })
+
+})
+
+
+describe('Tests classes for objectgroup', () => {
+
+    beforeEach(() => {
+        setLayer(xmlObjectImage)
+    })
+
+    test('Verify Type', () => {
+       expect(layer.type).toBe(TiledLayerType.ObjectGroup)
+    })
+
+    test('has objects property', () => {
+        expect(layer).toHaveProperty('objects')
+        expect(layer.objects).toHaveLength(1)
+    })
+
+    test('TiledObjectClass instance', () => {
+        const object = layer.objects[0]
+        expect(object).toBeInstanceOf(TiledObjectClass)
+        expect(object).toHaveProperty('x')
+        expect(object).toHaveProperty('y')
+        expect(object).toHaveProperty('width')
+        expect(object).toHaveProperty('height')
+    })
+
+    test('get gid', () => {
+        const object = layer.objects[0]
+        expect(object.gid).toBe(1)
+    })
+
+    test('test flip', () => {
+        const object = layer.objects[0]
+        expect(object?.horizontalFlip).toBe(true)
+        expect(object?.verticalFlip).toBe(false)
+        expect(object?.diagonalFlip).toBe(false)
+    })
+})