@rpgjs/tiledmap 5.0.0-beta.7 → 5.0.0-beta.8

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @rpgjs/tiledmap
+
+## 5.0.0-beta.8
+
+### Major Changes
+
+- 35e7fa4: beta.8
+
+### Patch Changes
+
+- Updated dependencies [35e7fa4]
+  - @rpgjs/client@5.0.0-beta.8
+  - @rpgjs/common@5.0.0-beta.8
+  - @rpgjs/server@5.0.0-beta.8
+  - @rpgjs/vite@5.0.0-beta.8

package/dist/client/index3.js

@@ -1,6 +1,7 @@
 import { MapClass } from "./index2.js";
 //#region src/physics.ts
 var TILED_HITBOX_ID_PREFIX = "__tiled_collision__:";
+var START_POSITION_NAME = "start";
 function prepareTiledPhysicsData(mapData, map) {
 	if (!mapData?.parsedMap) return;
 	const tiledMap = new MapClass(mapData.parsedMap);
@@ -9,6 +10,29 @@ function prepareTiledPhysicsData(mapData, map) {
 	mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
 	mapData.width = tiledMap.widthPx;
 	mapData.height = tiledMap.heightPx;
+	mapData.positions = mergeTiledPositions(mapData.positions, collectTiledPointPositions(mapData.parsedMap.objects));
+}
+function collectTiledPointPositions(objects) {
+	if (!Array.isArray(objects)) return {};
+	const positions = {};
+	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, tiledPositions) {
+	return {
+		...existingPositions && typeof existingPositions === "object" ? existingPositions : {},
+		...tiledPositions
+	};
 }
 function collectBlockedTileHitboxes(tiledMap) {
 	const hitboxes = [];

package/dist/server/index3.js

@@ -1,6 +1,7 @@
 import { MapClass } from "./index2.js";
 //#region src/physics.ts
 var TILED_HITBOX_ID_PREFIX = "__tiled_collision__:";
+var START_POSITION_NAME = "start";
 function prepareTiledPhysicsData(mapData, map) {
 	if (!mapData?.parsedMap) return;
 	const tiledMap = new MapClass(mapData.parsedMap);
@@ -9,6 +10,7 @@ function prepareTiledPhysicsData(mapData, map) {
 	mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
 	mapData.width = tiledMap.widthPx;
 	mapData.height = tiledMap.heightPx;
+	mapData.positions = mergeTiledPositions(mapData.positions, collectTiledPointPositions(mapData.parsedMap.objects));
 }
 function applyTiledPointEvents(mapData) {
 	const objects = mapData?.parsedMap?.objects;
@@ -16,8 +18,8 @@ function applyTiledPointEvents(mapData) {
 	for (const obj of objects) {
 		if (!obj?.point) continue;
 		mapData.events = mapData.events.map((eventEntry) => {
-			if (eventEntry?.name === obj.name) return {
-				event: eventEntry,
+			if (obj.name && eventEntry?.x === void 0 && eventEntry?.y === void 0 && getEventName(eventEntry) === obj.name) return {
+				...eventEntry && typeof eventEntry === "object" && "event" in eventEntry ? eventEntry : { event: eventEntry },
 				x: obj.x,
 				y: obj.y
 			};
@@ -25,6 +27,42 @@ function applyTiledPointEvents(mapData) {
 		}).filter((eventEntry) => eventEntry !== null);
 	}
 }
+function collectTiledPointPositions(objects) {
+	if (!Array.isArray(objects)) return {};
+	const positions = {};
+	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, tiledPositions) {
+	return {
+		...existingPositions && typeof existingPositions === "object" ? existingPositions : {},
+		...tiledPositions
+	};
+}
+function getEventName(eventEntry) {
+	const event = eventEntry?.event ?? eventEntry;
+	if (typeof event === "function") {
+		const staticEventName = event._name;
+		const prototypeEventName = event.prototype?._name;
+		const staticName = event.name;
+		const prototypeName = event.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;
+}
 function collectBlockedTileHitboxes(tiledMap) {
 	const hitboxes = [];
 	const mapWidth = tiledMap.width;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/tiledmap",
-  "version": "5.0.0-beta.7",
+  "version": "5.0.0-beta.8",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -23,10 +23,10 @@
   "description": "RPGJS is a framework for creating RPG/MMORPG games",
   "peerDependencies": {
     "@canvasengine/presets": "*",
-    "@rpgjs/client": "5.0.0-beta.7",
-    "@rpgjs/common": "5.0.0-beta.7",
-    "@rpgjs/server": "5.0.0-beta.7",
-    "@rpgjs/vite": "5.0.0-beta.7",
+    "@rpgjs/client": "5.0.0-beta.8",
+    "@rpgjs/common": "5.0.0-beta.8",
+    "@rpgjs/server": "5.0.0-beta.8",
+    "@rpgjs/vite": "5.0.0-beta.8",
     "canvasengine": "*"
   },
   "publishConfig": {

package/src/physics.spec.ts

@@ -32,7 +32,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", () => {
@@ -88,3 +88,158 @@ describe("prepareTiledPhysicsData", () => {
     expect(mapData.hitboxes).toEqual([]);
   });
 });
+
+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

@@ -13,6 +13,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) {
@@ -26,6 +27,7 @@ export function prepareTiledPhysicsData(mapData: any, map: AnyMap): void {
   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 +43,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 +62,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;