@flighthq/tilemap-formats 0.2.0 → 0.2.1-next.410.a23f189

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/tilemap-formats",
-  "version": "0.2.0",
+  "version": "0.2.1-next.410.a23f189",
   "repository": {
     "type": "git",
     "url": "https://github.com/flighthq/flight.git",
@@ -32,9 +32,9 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/sprite": "0.2.0",
-    "@flighthq/types": "0.2.0",
-    "@flighthq/xml": "0.2.0"
+    "@flighthq/sprite": "0.2.1-next.410.a23f189",
+    "@flighthq/types": "0.2.1-next.410.a23f189",
+    "@flighthq/xml": "0.2.1-next.410.a23f189"
   },
   "devDependencies": {
     "@flighthq/tileset": "*",

package/src/tiledJsonParse.test.ts

@@ -130,6 +130,150 @@ describe('parseTiledTmj', () => {
     expect(Array.from(decodedLayer.data)).toEqual([1, 5, 2147483649, 6]);
   });
 
+  it('parses a group layer and its nested children', () => {
+    const tmj = JSON.stringify({
+      height: 2,
+      layers: [
+        {
+          id: 1,
+          name: 'top',
+          type: 'group',
+          layers: [
+            { data: [1, 2, 3, 4], height: 2, id: 2, name: 'inner-tiles', type: 'tilelayer', width: 2 },
+            { id: 3, image: 'bg.png', name: 'inner-image', type: 'imagelayer' },
+          ],
+        },
+      ],
+      tileheight: 32,
+      tilewidth: 32,
+      type: 'map',
+      version: '1.10',
+      width: 2,
+    });
+    const map = parseTiledTmj(tmj)!;
+    expect(map.layers).toHaveLength(1);
+    const group = map.layers[0];
+    if (group.type !== 'group') throw new Error('expected a group layer');
+    expect(group.name).toBe('top');
+    expect(group.layers).toHaveLength(2);
+
+    const tileChild = group.layers[0];
+    if (tileChild.type !== 'tilelayer') throw new Error('expected a tile layer');
+    expect(tileChild.name).toBe('inner-tiles');
+    expect(Array.from(tileChild.data)).toEqual([1, 2, 3, 4]);
+
+    const imageChild = group.layers[1];
+    if (imageChild.type !== 'imagelayer') throw new Error('expected an image layer');
+    expect(imageChild.name).toBe('inner-image');
+    expect(imageChild.image).toBe('bg.png');
+  });
+
+  it('parses a multi-tileset map with two tilesets at different firstgid values', () => {
+    const tmj = JSON.stringify({
+      height: 1,
+      layers: [{ data: [1, 5], height: 1, id: 1, name: 'g', type: 'tilelayer', width: 2 }],
+      tileheight: 32,
+      tilesets: [
+        {
+          columns: 2,
+          firstgid: 1,
+          image: 'terrain.png',
+          imageheight: 64,
+          imagewidth: 64,
+          name: 'terrain',
+          tilecount: 4,
+          tileheight: 32,
+          tilewidth: 32,
+        },
+        {
+          columns: 3,
+          firstgid: 5,
+          image: 'items.png',
+          imageheight: 64,
+          imagewidth: 96,
+          name: 'items',
+          tilecount: 6,
+          tileheight: 32,
+          tilewidth: 32,
+        },
+      ],
+      tilewidth: 32,
+      type: 'map',
+      version: '1.10',
+      width: 2,
+    });
+    const map = parseTiledTmj(tmj)!;
+    expect(map.tilesets).toHaveLength(2);
+    expect(map.tilesets[0].firstGid).toBe(1);
+    expect(map.tilesets[0].tileset!.name).toBe('terrain');
+    expect(map.tilesets[1].firstGid).toBe(5);
+    expect(map.tilesets[1].tileset!.name).toBe('items');
+    expect(map.tilesets[1].tileset!.columns).toBe(3);
+  });
+
+  it('parses an object group with ellipse and polygon objects', () => {
+    const tmj = JSON.stringify({
+      height: 1,
+      layers: [
+        {
+          id: 1,
+          name: 'objects',
+          objects: [
+            { ellipse: true, height: 40, id: 1, name: 'circle', type: 'trigger', width: 40, x: 10, y: 20 },
+            {
+              height: 0,
+              id: 2,
+              name: 'region',
+              polygon: [
+                { x: 0, y: 0 },
+                { x: 64, y: 0 },
+                { x: 64, y: 64 },
+                { x: 0, y: 64 },
+              ],
+              type: 'zone',
+              width: 0,
+              x: 100,
+              y: 200,
+            },
+          ],
+          type: 'objectgroup',
+        },
+      ],
+      tileheight: 32,
+      tilewidth: 32,
+      type: 'map',
+      version: '1.10',
+      width: 1,
+    });
+    const map = parseTiledTmj(tmj)!;
+    const layer = map.layers[0];
+    if (layer.type !== 'objectgroup') throw new Error('expected an object group');
+    expect(layer.objects).toHaveLength(2);
+
+    const ellipseObj = layer.objects[0];
+    expect(ellipseObj.ellipse).toBe(true);
+    expect(ellipseObj.name).toBe('circle');
+    expect(ellipseObj.type).toBe('trigger');
+    expect(ellipseObj.width).toBe(40);
+    expect(ellipseObj.height).toBe(40);
+    expect(ellipseObj.x).toBe(10);
+    expect(ellipseObj.y).toBe(20);
+    expect(ellipseObj.polygon).toBeNull();
+
+    const polygonObj = layer.objects[1];
+    expect(polygonObj.ellipse).toBe(false);
+    expect(polygonObj.name).toBe('region');
+    expect(polygonObj.type).toBe('zone');
+    expect(polygonObj.x).toBe(100);
+    expect(polygonObj.y).toBe(200);
+    expect(polygonObj.polygon).toEqual([
+      { x: 0, y: 0 },
+      { x: 64, y: 0 },
+      { x: 64, y: 64 },
+      { x: 0, y: 64 },
+    ]);
+  });
+
   it('returns null on malformed JSON', () => {
     expect(parseTiledTmj('{ not json')).toBeNull();
     expect(parseTiledTmj('42')).toBeNull();