@rpgjs/tiledmap 5.0.0-alpha.9 → 5.0.0-beta.10

package/dist/server/index4.js

@@ -0,0 +1,93 @@
+import { MapClass } from "./index2.js";
+import { applyTiledMapCompat } from "./index3.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);
+	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));
+}
+function applyTiledPointEvents(mapData) {
+	const objects = mapData?.parsedMap?.objects;
+	if (!Array.isArray(objects) || !Array.isArray(mapData?.events)) return;
+	for (const obj of objects) {
+		if (!obj?.point) continue;
+		mapData.events = mapData.events.map((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
+			};
+			return eventEntry;
+		}).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;
+	const mapHeight = tiledMap.height;
+	const tileWidth = tiledMap.tilewidth;
+	const tileHeight = tiledMap.tileheight;
+	for (let y = 0; y < mapHeight; y++) for (let x = 0; x < mapWidth; x++) if (tiledMap.getTileByPosition(x * tileWidth, y * tileHeight, [0, 0], { populateTiles: true }).hasCollision) hitboxes.push({
+		id: createTiledHitboxId(x, y),
+		x: x * tileWidth,
+		y: y * tileHeight,
+		width: tileWidth,
+		height: tileHeight
+	});
+	return hitboxes;
+}
+function mergeTiledHitboxes(existingHitboxes, tiledHitboxes) {
+	return [...Array.isArray(existingHitboxes) ? existingHitboxes.filter((hitbox) => !isGeneratedTiledHitbox(hitbox)) : [], ...tiledHitboxes];
+}
+function isGeneratedTiledHitbox(hitbox) {
+	return typeof hitbox?.id === "string" && hitbox.id.startsWith(TILED_HITBOX_ID_PREFIX);
+}
+function createTiledHitboxId(x, y) {
+	return `${TILED_HITBOX_ID_PREFIX}${x},${y}`;
+}
+//#endregion
+export { applyTiledPointEvents, prepareTiledPhysicsData };

package/dist/server/index5.js

@@ -0,0 +1,15 @@
+import { applyTiledPointEvents, prepareTiledPhysicsData } from "./index4.js";
+import { defineModule } from "@rpgjs/common";
+//#region src/server.ts
+var server_default = defineModule({ map: {
+	onBeforeUpdate(mapData, map) {
+		prepareTiledPhysicsData(mapData, map);
+		applyTiledPointEvents(mapData);
+		return map;
+	},
+	onPhysicsInit(map, context) {
+		prepareTiledPhysicsData(context?.mapData, map);
+	}
+} });
+//#endregion
+export { server_default as default };

package/dist/server/physics.d.ts

@@ -0,0 +1,7 @@
+import { MapClass } from '@canvasengine/tiled';
+type AnyMap = {
+    tiled?: MapClass;
+};
+export declare function prepareTiledPhysicsData(mapData: any, map: AnyMap): void;
+export declare function applyTiledPointEvents(mapData: any): void;
+export {};

package/dist/server/server.d.ts

@@ -0,0 +1,54 @@
+import { RpgMap, RpgServer } from '@rpgjs/server';
+import { MapClass } from '@canvasengine/tiled';
+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;
+    }
+}
+export interface RpgTiledMap extends RpgMap {
+    tiled: MapClass;
+}
+declare const _default: RpgServer;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/tiledmap",
-  "version": "5.0.0-alpha.9",
+  "version": "5.0.0-beta.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -22,24 +22,24 @@
   "license": "MIT",
   "description": "RPGJS is a framework for creating RPG/MMORPG games",
   "peerDependencies": {
-    "@canvasengine/presets": "2.0.0-beta.25",
-    "@rpgjs/client": "5.0.0-alpha.9",
-    "@rpgjs/common": "5.0.0-alpha.9",
-    "@rpgjs/server": "5.0.0-alpha.9",
-    "@rpgjs/vite": "5.0.0-alpha.9",
-    "canvasengine": "2.0.0-beta.25"
+    "@canvasengine/presets": "^2.0.0-rc.1",
+    "@rpgjs/client": "5.0.0-beta.10",
+    "@rpgjs/common": "5.0.0-beta.10",
+    "@rpgjs/server": "5.0.0-beta.10",
+    "@rpgjs/vite": "5.0.0-beta.10",
+    "canvasengine": "^2.0.0-rc.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@canvasengine/compiler": "2.0.0-beta.21",
-    "vite": "^6.2.5",
-    "vite-plugin-dts": "^4.5.3"
+    "@canvasengine/compiler": "^2.0.0-beta.58",
+    "vite": "^8.0.10",
+    "vite-plugin-dts": "^4.5.4"
   },
   "type": "module",
   "dependencies": {
-    "@canvasengine/tiled": "2.0.0-beta.25"
+    "@canvasengine/tiled": "^2.0.0-beta.58"
   },
   "scripts": {
     "dev": "vite build --watch",

package/src/client.ts

@@ -1,6 +1,12 @@
-import { RpgClient, RpgClientEngine } from "@rpgjs/client";
+import { RpgClient } from "@rpgjs/client";
 import { defineModule } from "@rpgjs/common";
+import { prepareTiledPhysicsData } from "./physics";
 
 export default defineModule<RpgClient>({
-    effects: []
-})
+  componentAnimations: [],
+  sceneMap: {
+    onPhysicsInit(map: any, context: { mapData: any }) {
+      prepareTiledPhysicsData(context?.mapData, map);
+    },
+  },
+});

package/src/compat.ts

@@ -0,0 +1,221 @@
+import { MapClass } from "@canvasengine/tiled";
+
+type AnyMap = {
+  tiled?: MapClass;
+  [key: string]: any;
+};
+
+type ParsedTiledMap = {
+  width?: number;
+  height?: number;
+  tilewidth?: number;
+  tileheight?: number;
+  layers?: any[];
+  tilesets?: any[];
+  [key: string]: any;
+};
+
+type TileLayer = {
+  name?: string;
+  data?: any[];
+  [key: string]: any;
+};
+
+const COMPAT_MARKER = "__rpgjsTiledMapCompat";
+
+/**
+ * Adds v4-style map helpers backed by CanvasEngine Tiled.
+ */
+export function applyTiledMapCompat(map: AnyMap, parsedMap: ParsedTiledMap): void {
+  if (!map?.tiled) {
+    return;
+  }
+
+  const state = (map as any)[COMPAT_MARKER] ?? { parsedMap };
+  state.parsedMap = parsedMap;
+
+  if (!(map as any)[COMPAT_MARKER]) {
+    Object.defineProperty(map, COMPAT_MARKER, {
+      value: state,
+      configurable: true,
+    });
+  }
+
+  defineGetter(map, "layers", () => getLayers(map, state.parsedMap));
+  defineGetter(map, "zTileHeight", () => getNumber(map.tiled, state.parsedMap, "zTileHeight", "tileheight"));
+
+  defineMethod(map, "getLayerByName", (name: string) => {
+    const tiled = map.tiled as any;
+    if (typeof tiled?.getLayerByName === "function") {
+      return tiled.getLayerByName(name);
+    }
+    return getLayers(map, state.parsedMap).find((layer: any) => layer?.name === name);
+  });
+
+  defineMethod(map, "getTileIndex", (x: number, y: number) => {
+    const tiled = map.tiled as any;
+    if (typeof tiled?.getTileIndex === "function") {
+      return tiled.getTileIndex(x, y);
+    }
+    return y * getNumber(map.tiled, state.parsedMap, "width") + x;
+  });
+
+  defineMethod(map, "getTileOriginPosition", (x: number, y: number) => {
+    const tiled = map.tiled as any;
+    if (typeof tiled?.getTileOriginPosition === "function") {
+      return tiled.getTileOriginPosition(x, y);
+    }
+    return {
+      x: x * getNumber(map.tiled, state.parsedMap, "tilewidth"),
+      y: y * getNumber(map.tiled, state.parsedMap, "tileheight"),
+    };
+  });
+
+  defineMethod(map, "getTileByPosition", (x: number, y: number, z?: number) => {
+    const tiled = map.tiled as any;
+    if (typeof tiled?.getTileByPosition === "function") {
+      const layerRange = typeof z === "number" ? [z, z] : undefined;
+      return tiled.getTileByPosition(x, y, layerRange, { populateTiles: true });
+    }
+    const tileX = Math.floor(x / getNumber(map.tiled, state.parsedMap, "tilewidth"));
+    const tileY = Math.floor(y / getNumber(map.tiled, state.parsedMap, "tileheight"));
+    return map.getTileByIndex(map.getTileIndex(tileX, tileY));
+  });
+
+  defineMethod(map, "getTileByIndex", (tileIndex: number) => {
+    const tiled = map.tiled as any;
+    if (typeof tiled?.getTileByIndex === "function") {
+      return tiled.getTileByIndex(tileIndex);
+    }
+    return getTileByIndexFromLayers(getLayers(map, state.parsedMap), tileIndex);
+  });
+
+  defineMethod(map, "setTile", (x: number, y: number, layer: string | number, tileInfo: any) => {
+    const tiled = map.tiled as any;
+    if (typeof tiled?.setTile === "function") {
+      return tiled.setTile(x, y, layer, tileInfo);
+    }
+
+    const targetLayer = getTargetLayer(getLayers(map, state.parsedMap), layer);
+    if (!targetLayer?.data) {
+      return undefined;
+    }
+
+    const tileIndex = map.getTileIndex(x, y);
+    targetLayer.data[tileIndex] = getTileGid(tileInfo);
+    return tileInfo;
+  });
+
+  defineMethod(map, "updateTileset", (tileset: any) => {
+    const tiled = map.tiled as any;
+    if (typeof tiled?.updateTileset === "function") {
+      return tiled.updateTileset(tileset);
+    }
+
+    const nextTilesets = updateTilesets(getTilesets(map, state.parsedMap), tileset);
+    tiled.tilesets = nextTilesets;
+    state.parsedMap.tilesets = nextTilesets;
+    return tileset;
+  });
+}
+
+function defineGetter(target: AnyMap, name: string, get: () => any): void {
+  Object.defineProperty(target, name, {
+    configurable: true,
+    enumerable: true,
+    get,
+  });
+}
+
+function defineMethod(target: AnyMap, name: string, value: (...args: any[]) => any): void {
+  if (typeof target[name] === "function") {
+    return;
+  }
+
+  Object.defineProperty(target, name, {
+    configurable: true,
+    enumerable: false,
+    value,
+  });
+}
+
+function getLayers(map: AnyMap, parsedMap: ParsedTiledMap): any[] {
+  const tiled = map.tiled as any;
+  return Array.isArray(tiled?.layers) ? tiled.layers : Array.isArray(parsedMap?.layers) ? parsedMap.layers : [];
+}
+
+function getTilesets(map: AnyMap, parsedMap: ParsedTiledMap): any[] {
+  const tiled = map.tiled as any;
+  return Array.isArray(tiled?.tilesets)
+    ? tiled.tilesets
+    : Array.isArray(parsedMap?.tilesets)
+      ? parsedMap.tilesets
+      : [];
+}
+
+function getNumber(tiled: any, parsedMap: ParsedTiledMap, property: string, fallbackProperty = property): number {
+  const value = typeof tiled?.[property] === "number" ? tiled[property] : parsedMap?.[property];
+  if (typeof value === "number") {
+    return value;
+  }
+  const fallback = typeof tiled?.[fallbackProperty] === "number" ? tiled[fallbackProperty] : parsedMap?.[fallbackProperty];
+  return typeof fallback === "number" ? fallback : 0;
+}
+
+function getTileByIndexFromLayers(layers: any[], tileIndex: number): any {
+  for (let i = layers.length - 1; i >= 0; i--) {
+    const layer = layers[i] as TileLayer;
+    const gid = layer?.data?.[tileIndex];
+    if (gid) {
+      return {
+        id: gid,
+        gid,
+        index: tileIndex,
+        layer,
+      };
+    }
+  }
+  return undefined;
+}
+
+function getTargetLayer(layers: any[], layer: string | number): TileLayer | undefined {
+  if (typeof layer === "number") {
+    return layers[layer];
+  }
+  return layers.find((currentLayer: any) => currentLayer?.name === layer);
+}
+
+function getTileGid(tileInfo: any): any {
+  if (tileInfo && typeof tileInfo === "object") {
+    return tileInfo.gid ?? tileInfo.id ?? tileInfo.tileId ?? 0;
+  }
+  return tileInfo;
+}
+
+function updateTilesets(currentTilesets: any[], tileset: any): any[] {
+  if (Array.isArray(tileset)) {
+    return tileset;
+  }
+
+  const nextTilesets = [...currentTilesets];
+  const index = nextTilesets.findIndex((currentTileset) => isSameTileset(currentTileset, tileset));
+  if (index >= 0) {
+    nextTilesets[index] = {
+      ...nextTilesets[index],
+      ...tileset,
+    };
+  } else {
+    nextTilesets.push(tileset);
+  }
+  return nextTilesets;
+}
+
+function isSameTileset(a: any, b: any): boolean {
+  return (
+    a &&
+    b &&
+    ((a.name && a.name === b.name) ||
+      (a.source && a.source === b.source) ||
+      (a.firstgid !== undefined && a.firstgid === b.firstgid))
+  );
+}

package/src/index.ts

@@ -4,6 +4,7 @@ import { createModule } from "@rpgjs/common";
 import { provideLoadMap } from "@rpgjs/client";
 import { TiledParser } from "@canvasengine/tiled";
 import Tiled from "./tiled.ce";
+import { prepareTiledPhysicsData } from "./physics";
 
 export function provideTiledMap(options: {
   basePath: string;
@@ -35,7 +36,7 @@ export function provideTiledMap(options: {
       }
       parsedMap.tilesets = tilesets;
 
-      const obj = {
+      const obj: any = {
         data: mapData,
         component: Tiled,
         parsedMap,
@@ -45,6 +46,9 @@ export function provideTiledMap(options: {
         },
       };
 
+      // Populate dimensions and static hitboxes before the first loadPhysic() call.
+      prepareTiledPhysicsData(obj, obj);
+
       if (options.onLoadMap) {
         await options.onLoadMap(map);
       }