@rpgjs/tiledmap 5.0.0-beta.1 → 5.0.0-beta.10

package/src/physics.spec.ts

@@ -8,6 +8,8 @@ vi.mock("@canvasengine/tiled", () => {
     tileheight: number;
     widthPx: number;
     heightPx: number;
+    layers: any[];
+    tilesets: any[];
     private blockedTiles: Set<string>;
 
     constructor(parsedMap: any) {
@@ -17,6 +19,8 @@ vi.mock("@canvasengine/tiled", () => {
       this.tileheight = parsedMap.tileheight ?? 32;
       this.widthPx = this.width * this.tilewidth;
       this.heightPx = this.height * this.tileheight;
+      this.layers = parsedMap.layers;
+      this.tilesets = parsedMap.tilesets;
       this.blockedTiles = new Set(parsedMap.blockedTiles ?? []);
     }
 
@@ -32,7 +36,7 @@ vi.mock("@canvasengine/tiled", () => {
   return { MapClass };
 });
 
-import { prepareTiledPhysicsData } from "./physics";
+import { applyTiledPointEvents, prepareTiledPhysicsData } from "./physics";
 
 describe("prepareTiledPhysicsData", () => {
   it("adds tiled collision hitboxes without duplicating them on repeated preparation", () => {
@@ -87,4 +91,195 @@ describe("prepareTiledPhysicsData", () => {
 
     expect(mapData.hitboxes).toEqual([]);
   });
+
+  it("adds v4 map helpers backed by Tiled data", () => {
+    const groundLayer = { name: "Ground", data: [1, 0, 2, 3] };
+    const mapData = {
+      parsedMap: {
+        width: 2,
+        height: 2,
+        tilewidth: 16,
+        tileheight: 20,
+        layers: [groundLayer],
+        tilesets: [{ firstgid: 1, name: "base" }],
+      },
+    };
+    const map: any = {};
+
+    prepareTiledPhysicsData(mapData, map);
+
+    expect(map.layers).toBe(mapData.parsedMap.layers);
+    expect(map.zTileHeight).toBe(20);
+    expect(map.getLayerByName("Ground")).toBe(groundLayer);
+    expect(map.getTileIndex(1, 1)).toBe(3);
+    expect(map.getTileOriginPosition(1, 1)).toEqual({ x: 16, y: 20 });
+    expect(map.getTileByPosition(16, 20)).toEqual({ hasCollision: false });
+    expect(map.getTileByIndex(2)).toMatchObject({ gid: 2, id: 2, index: 2, layer: groundLayer });
+
+    expect(map.setTile(1, 0, "Ground", { gid: 8 })).toEqual({ gid: 8 });
+    expect(groundLayer.data[1]).toBe(8);
+
+    expect(map.updateTileset({ firstgid: 1, name: "base", tilecount: 4 })).toEqual({
+      firstgid: 1,
+      name: "base",
+      tilecount: 4,
+    });
+    expect(map.tiled.tilesets).toEqual([{ firstgid: 1, name: "base", tilecount: 4 }]);
+    expect(mapData.parsedMap.tilesets).toEqual([{ firstgid: 1, name: "base", tilecount: 4 }]);
+  });
+});
+
+describe("tiled point positions", () => {
+  it("extracts named point objects as map positions", () => {
+    const mapData = {
+      parsedMap: {
+        width: 1,
+        height: 1,
+        objects: [
+          { point: true, name: "start", x: 10, y: 20 },
+          { point: true, name: "entrance", x: 30, y: 40 },
+        ],
+      },
+    };
+
+    prepareTiledPhysicsData(mapData, {});
+
+    expect(mapData.positions).toEqual({
+      start: { x: 10, y: 20 },
+      entrance: { x: 30, y: 40 },
+    });
+  });
+
+  it("uses class or type as a fallback for the special start position", () => {
+    const mapData = {
+      parsedMap: {
+        width: 1,
+        height: 1,
+        objects: [
+          { point: true, class: "start", x: 10, y: 20 },
+          { point: true, type: "start", x: 30, y: 40 },
+        ],
+      },
+    };
+
+    prepareTiledPhysicsData(mapData, {});
+
+    expect(mapData.positions).toEqual({
+      start: { x: 10, y: 20 },
+    });
+  });
+
+  it("keeps explicitly named start before class or type fallback", () => {
+    const mapData = {
+      parsedMap: {
+        width: 1,
+        height: 1,
+        objects: [
+          { point: true, name: "start", x: 10, y: 20 },
+          { point: true, class: "start", x: 30, y: 40 },
+        ],
+      },
+    };
+
+    prepareTiledPhysicsData(mapData, {});
+
+    expect(mapData.positions).toEqual({
+      start: { x: 10, y: 20 },
+    });
+  });
+});
+
+describe("applyTiledPointEvents", () => {
+  it("places direct object events by matching their name with a tiled point", () => {
+    const mapData = {
+      parsedMap: {
+        objects: [
+          { point: true, name: "EV-1", x: 10, y: 20 },
+        ],
+      },
+      events: [
+        { name: "EV-1", onInit() {} },
+      ],
+    };
+
+    applyTiledPointEvents(mapData);
+
+    expect(mapData.events).toEqual([
+      {
+        event: { name: "EV-1", onInit: expect.any(Function) },
+        x: 10,
+        y: 20,
+      },
+    ]);
+  });
+
+  it("places wrapped object events by matching the wrapped event name", () => {
+    const mapData = {
+      parsedMap: {
+        objects: [
+          { point: true, name: "EV-1", x: 10, y: 20 },
+        ],
+      },
+      events: [
+        { id: "event-id", event: { name: "EV-1", onInit() {} } },
+      ],
+    };
+
+    applyTiledPointEvents(mapData);
+
+    expect(mapData.events).toEqual([
+      {
+        id: "event-id",
+        event: { name: "EV-1", onInit: expect.any(Function) },
+        x: 10,
+        y: 20,
+      },
+    ]);
+  });
+
+  it("places class events decorated with EventData metadata", () => {
+    class NpcEvent {}
+    (NpcEvent as any)._name = "EV-1";
+    (NpcEvent as any).prototype._name = "EV-1";
+
+    const mapData = {
+      parsedMap: {
+        objects: [
+          { point: true, name: "EV-1", x: 10, y: 20 },
+        ],
+      },
+      events: [
+        { event: NpcEvent },
+      ],
+    };
+
+    applyTiledPointEvents(mapData);
+
+    expect(mapData.events).toEqual([
+      {
+        event: NpcEvent,
+        x: 10,
+        y: 20,
+      },
+    ]);
+  });
+
+  it("does not override explicit event coordinates", () => {
+    const mapData = {
+      parsedMap: {
+        objects: [
+          { point: true, name: "EV-1", x: 10, y: 20 },
+        ],
+      },
+      events: [
+        { x: 50, y: 60, event: { name: "EV-1" } },
+      ],
+    };
+
+    applyTiledPointEvents(mapData);
+
+    expect(mapData.events).toEqual([
+      { x: 50, y: 60, event: { name: "EV-1" } },
+    ]);
+  });
 });

package/src/physics.ts

@@ -1,4 +1,5 @@
 import { MapClass } from "@canvasengine/tiled";
+import { applyTiledMapCompat } from "./compat";
 
 type AnyMap = {
   tiled?: MapClass;
@@ -13,6 +14,7 @@ type RectHitbox = {
 };
 
 const TILED_HITBOX_ID_PREFIX = "__tiled_collision__:";
+const START_POSITION_NAME = "start";
 
 export function prepareTiledPhysicsData(mapData: any, map: AnyMap): void {
   if (!mapData?.parsedMap) {
@@ -21,11 +23,13 @@ export function prepareTiledPhysicsData(mapData: any, map: AnyMap): void {
 
   const tiledMap = new MapClass(mapData.parsedMap);
   map.tiled = tiledMap;
+  applyTiledMapCompat(map, mapData.parsedMap);
 
   const tiledHitboxes = collectBlockedTileHitboxes(tiledMap);
   mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
   mapData.width = tiledMap.widthPx;
   mapData.height = tiledMap.heightPx;
+  mapData.positions = mergeTiledPositions(mapData.positions, collectTiledPointPositions(mapData.parsedMap.objects));
 }
 
 export function applyTiledPointEvents(mapData: any): void {
@@ -41,9 +45,15 @@ export function applyTiledPointEvents(mapData: any): void {
 
     mapData.events = mapData.events
       .map((eventEntry: any) => {
-        if (eventEntry?.name === obj.name) {
+        if (
+          obj.name &&
+          eventEntry?.x === undefined &&
+          eventEntry?.y === undefined &&
+          getEventName(eventEntry) === obj.name
+        ) {
+          const isWrappedEvent = eventEntry && typeof eventEntry === "object" && "event" in eventEntry;
           return {
-            event: eventEntry,
+            ...(isWrappedEvent ? eventEntry : { event: eventEntry }),
             x: obj.x,
             y: obj.y,
           };
@@ -54,6 +64,69 @@ export function applyTiledPointEvents(mapData: any): void {
   }
 }
 
+function collectTiledPointPositions(objects: any): Record<string, { x: number; y: number }> {
+  if (!Array.isArray(objects)) {
+    return {};
+  }
+
+  const positions: Record<string, { x: number; y: number }> = {};
+
+  for (const obj of objects) {
+    if (!obj?.point || typeof obj.x !== "number" || typeof obj.y !== "number") {
+      continue;
+    }
+
+    if (typeof obj.name === "string" && obj.name.length > 0) {
+      positions[obj.name] = { x: obj.x, y: obj.y };
+    }
+
+    if (
+      !positions[START_POSITION_NAME] &&
+      (obj.class === START_POSITION_NAME || obj.type === START_POSITION_NAME)
+    ) {
+      positions[START_POSITION_NAME] = { x: obj.x, y: obj.y };
+    }
+  }
+
+  return positions;
+}
+
+function mergeTiledPositions(existingPositions: any, tiledPositions: Record<string, { x: number; y: number }>) {
+  return {
+    ...(existingPositions && typeof existingPositions === "object" ? existingPositions : {}),
+    ...tiledPositions,
+  };
+}
+
+function getEventName(eventEntry: any): string | undefined {
+  const event = eventEntry?.event ?? eventEntry;
+
+  if (typeof event === "function") {
+    const staticEventName = (event as any)._name;
+    const prototypeEventName = (event as any).prototype?._name;
+    const staticName = (event as any).name;
+    const prototypeName = (event as any).prototype?.name;
+    if (typeof prototypeEventName === "string") {
+      return prototypeEventName;
+    }
+    if (typeof staticEventName === "string") {
+      return staticEventName;
+    }
+    if (typeof prototypeName === "string") {
+      return prototypeName;
+    }
+    if (typeof staticName === "string") {
+      return staticName;
+    }
+  }
+
+  if (typeof event?.name === "string") {
+    return event.name;
+  }
+
+  return undefined;
+}
+
 function collectBlockedTileHitboxes(tiledMap: MapClass): RectHitbox[] {
   const hitboxes: RectHitbox[] = [];
   const mapWidth = tiledMap.width;

package/src/server.ts

@@ -5,7 +5,46 @@ import { applyTiledPointEvents, prepareTiledPhysicsData } from "./physics";
 
 declare module "@rpgjs/server" {
   interface RpgMap {
+    /**
+     * CanvasEngine Tiled map instance attached by `@rpgjs/tiledmap`.
+     */
     tiled?: MapClass;
+    /**
+     * Tiled layers from the parsed map.
+     */
+    layers?: any[];
+    /**
+     * Height used by tile depth calculations. Defaults to the Tiled tile height.
+     */
+    zTileHeight?: number;
+    /**
+     * v4 compatibility helper. Returns a Tiled layer by its name.
+     */
+    getLayerByName?(name: string): any;
+    /**
+     * v4 compatibility helper. Returns the one-dimensional tile index for tile coordinates.
+     */
+    getTileIndex?(x: number, y: number): number;
+    /**
+     * v4 compatibility helper. Returns the pixel origin of a tile coordinate.
+     */
+    getTileOriginPosition?(x: number, y: number): { x: number; y: number };
+    /**
+     * v4 compatibility helper. Returns Tiled tile information from pixel coordinates.
+     */
+    getTileByPosition?(x: number, y: number, z?: number): any;
+    /**
+     * v4 compatibility helper. Returns Tiled tile information from a one-dimensional index.
+     */
+    getTileByIndex?(tileIndex: number): any;
+    /**
+     * v4 compatibility helper. Updates a tile in a Tiled tile layer.
+     */
+    setTile?(x: number, y: number, layer: string | number, tileInfo: any): any;
+    /**
+     * v4 compatibility helper. Updates the parsed Tiled tileset list.
+     */
+    updateTileset?(tileset: any): any;
   }
 }
 

package/dist/client.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/server.d.ts

@@ -1,12 +0,0 @@
-import { RpgMap } from '@rpgjs/server';
-import { MapClass } from '@canvasengine/tiled';
-declare module "@rpgjs/server" {
-    interface RpgMap {
-        tiled?: MapClass;
-    }
-}
-export interface RpgTiledMap extends RpgMap {
-    tiled: MapClass;
-}
-declare const _default: any;
-export default _default;