@rpgjs/tiledmap 5.0.0-alpha.42 → 5.0.0-alpha.44

package/dist/client/index.js

@@ -3,6 +3,7 @@ import { createModule } from "@rpgjs/common";
 import { provideLoadMap } from "@rpgjs/client";
 import { TiledParser } from "./index3.js";
 import component from "./index4.js";
+import { prepareTiledPhysicsData } from "./index5.js";
 const server = null;
 function provideTiledMap(options) {
   return createModule("TiledMap", [
@@ -39,6 +40,7 @@ function provideTiledMap(options) {
           basePath: options.basePath
         }
       };
+      prepareTiledPhysicsData(obj, obj);
       if (options.onLoadMap) {
         await options.onLoadMap(map);
       }

package/dist/client/index2.js

@@ -1,19 +1,10 @@
 import { defineModule } from "@rpgjs/common";
-import { resetTiledCollisionHandlers, detachTiledCollisionFromEntity, attachTiledCollisionToEntity, prepareTiledPhysicsData } from "./index5.js";
+import { prepareTiledPhysicsData } from "./index5.js";
 const client = defineModule({
   componentAnimations: [],
   sceneMap: {
     onPhysicsInit(map, context) {
       prepareTiledPhysicsData(context?.mapData, map);
-    },
-    onPhysicsEntityAdd(map, context) {
-      attachTiledCollisionToEntity(context?.owner, map);
-    },
-    onPhysicsEntityRemove(map, context) {
-      detachTiledCollisionFromEntity(context?.owner, map);
-    },
-    onPhysicsReset(map) {
-      resetTiledCollisionHandlers(map);
     }
   }
 });

package/dist/client/index5.js

@@ -1,72 +1,18 @@
 import { MapClass } from "./index3.js";
+const TILED_HITBOX_ID_PREFIX = "__tiled_collision__:";
 function prepareTiledPhysicsData(mapData, map) {
   if (!mapData?.parsedMap) {
     return;
   }
   const tiledMap = new MapClass(mapData.parsedMap);
   map.tiled = tiledMap;
-  mapData.hitboxes = mapData.hitboxes || [];
+  const tiledHitboxes = collectBlockedTileHitboxes(tiledMap);
+  mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
   mapData.width = tiledMap.widthPx;
   mapData.height = tiledMap.heightPx;
-  map._tiledTileWidth = tiledMap.tilewidth;
-  map._tiledTileHeight = tiledMap.tileheight;
-  map._blockedTiles = collectBlockedTiles(tiledMap);
 }
-function attachTiledCollisionToEntity(owner, map) {
-  if (!owner?.id || !map?._blockedTiles) {
-    return;
-  }
-  const entity = map.physic?.getEntityByUUID(owner.id);
-  if (!entity || typeof entity.canEnterTile !== "function") {
-    return;
-  }
-  const unsubscribers = ensureUnsubscribers(map);
-  const previousUnsubscribe = unsubscribers.get(owner.id);
-  if (previousUnsubscribe) {
-    previousUnsubscribe();
-    unsubscribers.delete(owner.id);
-  }
-  const blockedTiles = map._blockedTiles;
-  const tiledTileWidth = map._tiledTileWidth ?? 32;
-  const tiledTileHeight = map._tiledTileHeight ?? 32;
-  const physicsTileWidth = 32;
-  const physicsTileHeight = 32;
-  const unsubscribe = entity.canEnterTile(({ x, y }) => {
-    const tiledX = Math.floor(x * physicsTileWidth / tiledTileWidth);
-    const tiledY = Math.floor(y * physicsTileHeight / tiledTileHeight);
-    return !blockedTiles.has(`${tiledX},${tiledY}`);
-  });
-  unsubscribers.set(owner.id, unsubscribe);
-}
-function detachTiledCollisionFromEntity(owner, map) {
-  if (!owner?.id) {
-    return;
-  }
-  const unsubscribers = map._tiledCollisionUnsubscribers;
-  if (!unsubscribers) {
-    return;
-  }
-  const unsubscribe = unsubscribers.get(owner.id);
-  if (!unsubscribe) {
-    return;
-  }
-  unsubscribe();
-  unsubscribers.delete(owner.id);
-}
-function resetTiledCollisionHandlers(map) {
-  const unsubscribers = map._tiledCollisionUnsubscribers;
-  if (unsubscribers) {
-    for (const unsubscribe of unsubscribers.values()) {
-      unsubscribe();
-    }
-    unsubscribers.clear();
-  }
-  map._blockedTiles = void 0;
-  map._tiledTileWidth = void 0;
-  map._tiledTileHeight = void 0;
-}
-function collectBlockedTiles(tiledMap) {
-  const blockedTiles = /* @__PURE__ */ new Set();
+function collectBlockedTileHitboxes(tiledMap) {
+  const hitboxes = [];
   const mapWidth = tiledMap.width;
   const mapHeight = tiledMap.height;
   const tileWidth = tiledMap.tilewidth;
@@ -77,19 +23,28 @@ function collectBlockedTiles(tiledMap) {
         populateTiles: true
       });
       if (tileInfo.hasCollision) {
-        blockedTiles.add(`${x},${y}`);
+        hitboxes.push({
+          id: createTiledHitboxId(x, y),
+          x: x * tileWidth,
+          y: y * tileHeight,
+          width: tileWidth,
+          height: tileHeight
+        });
       }
     }
   }
-  return blockedTiles;
+  return hitboxes;
+}
+function mergeTiledHitboxes(existingHitboxes, tiledHitboxes) {
+  const preservedHitboxes = Array.isArray(existingHitboxes) ? existingHitboxes.filter((hitbox) => !isGeneratedTiledHitbox(hitbox)) : [];
+  return [...preservedHitboxes, ...tiledHitboxes];
+}
+function isGeneratedTiledHitbox(hitbox) {
+  return typeof hitbox?.id === "string" && hitbox.id.startsWith(TILED_HITBOX_ID_PREFIX);
 }
-function ensureUnsubscribers(map) {
-  map._tiledCollisionUnsubscribers = map._tiledCollisionUnsubscribers || /* @__PURE__ */ new Map();
-  return map._tiledCollisionUnsubscribers;
+function createTiledHitboxId(x, y) {
+  return `${TILED_HITBOX_ID_PREFIX}${x},${y}`;
 }
 export {
-  attachTiledCollisionToEntity,
-  detachTiledCollisionFromEntity,
-  prepareTiledPhysicsData,
-  resetTiledCollisionHandlers
+  prepareTiledPhysicsData
 };

package/dist/physics.d.ts

@@ -1,17 +1,7 @@
 import { MapClass } from '@canvasengine/tiled';
 type AnyMap = {
     tiled?: MapClass;
-    physic?: {
-        getEntityByUUID(id: string): any;
-    };
-    _blockedTiles?: Set<string>;
-    _tiledTileWidth?: number;
-    _tiledTileHeight?: number;
-    _tiledCollisionUnsubscribers?: Map<string, () => void>;
 };
 export declare function prepareTiledPhysicsData(mapData: any, map: AnyMap): void;
 export declare function applyTiledPointEvents(mapData: any): void;
-export declare function attachTiledCollisionToEntity(owner: any, map: AnyMap): void;
-export declare function detachTiledCollisionFromEntity(owner: any, map: AnyMap): void;
-export declare function resetTiledCollisionHandlers(map: AnyMap): void;
 export {};

package/dist/server/index2.js

@@ -1,5 +1,5 @@
 import { defineModule } from "@rpgjs/common";
-import { resetTiledCollisionHandlers, detachTiledCollisionFromEntity, attachTiledCollisionToEntity, prepareTiledPhysicsData, applyTiledPointEvents } from "./index4.js";
+import { prepareTiledPhysicsData, applyTiledPointEvents } from "./index4.js";
 const server = defineModule({
   map: {
     onBeforeUpdate(mapData, map) {
@@ -8,18 +8,7 @@ const server = defineModule({
       return map;
     },
     onPhysicsInit(map, context) {
-      if (!map?._blockedTiles || !map?.tiled) {
-        prepareTiledPhysicsData(context?.mapData, map);
-      }
-    },
-    onPhysicsEntityAdd(map, context) {
-      attachTiledCollisionToEntity(context?.owner, map);
-    },
-    onPhysicsEntityRemove(map, context) {
-      detachTiledCollisionFromEntity(context?.owner, map);
-    },
-    onPhysicsReset(map) {
-      resetTiledCollisionHandlers(map);
+      prepareTiledPhysicsData(context?.mapData, map);
     }
   }
 });

package/dist/server/index4.js

@@ -1,16 +1,15 @@
 import { MapClass } from "./index3.js";
+const TILED_HITBOX_ID_PREFIX = "__tiled_collision__:";
 function prepareTiledPhysicsData(mapData, map) {
   if (!mapData?.parsedMap) {
     return;
   }
   const tiledMap = new MapClass(mapData.parsedMap);
   map.tiled = tiledMap;
-  mapData.hitboxes = mapData.hitboxes || [];
+  const tiledHitboxes = collectBlockedTileHitboxes(tiledMap);
+  mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
   mapData.width = tiledMap.widthPx;
   mapData.height = tiledMap.heightPx;
-  map._tiledTileWidth = tiledMap.tilewidth;
-  map._tiledTileHeight = tiledMap.tileheight;
-  map._blockedTiles = collectBlockedTiles(tiledMap);
 }
 function applyTiledPointEvents(mapData) {
   const objects = mapData?.parsedMap?.objects;
@@ -33,61 +32,8 @@ function applyTiledPointEvents(mapData) {
     }).filter((eventEntry) => eventEntry !== null);
   }
 }
-function attachTiledCollisionToEntity(owner, map) {
-  if (!owner?.id || !map?._blockedTiles) {
-    return;
-  }
-  const entity = map.physic?.getEntityByUUID(owner.id);
-  if (!entity || typeof entity.canEnterTile !== "function") {
-    return;
-  }
-  const unsubscribers = ensureUnsubscribers(map);
-  const previousUnsubscribe = unsubscribers.get(owner.id);
-  if (previousUnsubscribe) {
-    previousUnsubscribe();
-    unsubscribers.delete(owner.id);
-  }
-  const blockedTiles = map._blockedTiles;
-  const tiledTileWidth = map._tiledTileWidth ?? 32;
-  const tiledTileHeight = map._tiledTileHeight ?? 32;
-  const physicsTileWidth = 32;
-  const physicsTileHeight = 32;
-  const unsubscribe = entity.canEnterTile(({ x, y }) => {
-    const tiledX = Math.floor(x * physicsTileWidth / tiledTileWidth);
-    const tiledY = Math.floor(y * physicsTileHeight / tiledTileHeight);
-    return !blockedTiles.has(`${tiledX},${tiledY}`);
-  });
-  unsubscribers.set(owner.id, unsubscribe);
-}
-function detachTiledCollisionFromEntity(owner, map) {
-  if (!owner?.id) {
-    return;
-  }
-  const unsubscribers = map._tiledCollisionUnsubscribers;
-  if (!unsubscribers) {
-    return;
-  }
-  const unsubscribe = unsubscribers.get(owner.id);
-  if (!unsubscribe) {
-    return;
-  }
-  unsubscribe();
-  unsubscribers.delete(owner.id);
-}
-function resetTiledCollisionHandlers(map) {
-  const unsubscribers = map._tiledCollisionUnsubscribers;
-  if (unsubscribers) {
-    for (const unsubscribe of unsubscribers.values()) {
-      unsubscribe();
-    }
-    unsubscribers.clear();
-  }
-  map._blockedTiles = void 0;
-  map._tiledTileWidth = void 0;
-  map._tiledTileHeight = void 0;
-}
-function collectBlockedTiles(tiledMap) {
-  const blockedTiles = /* @__PURE__ */ new Set();
+function collectBlockedTileHitboxes(tiledMap) {
+  const hitboxes = [];
   const mapWidth = tiledMap.width;
   const mapHeight = tiledMap.height;
   const tileWidth = tiledMap.tilewidth;
@@ -98,20 +44,29 @@ function collectBlockedTiles(tiledMap) {
         populateTiles: true
       });
       if (tileInfo.hasCollision) {
-        blockedTiles.add(`${x},${y}`);
+        hitboxes.push({
+          id: createTiledHitboxId(x, y),
+          x: x * tileWidth,
+          y: y * tileHeight,
+          width: tileWidth,
+          height: tileHeight
+        });
       }
     }
   }
-  return blockedTiles;
+  return hitboxes;
+}
+function mergeTiledHitboxes(existingHitboxes, tiledHitboxes) {
+  const preservedHitboxes = Array.isArray(existingHitboxes) ? existingHitboxes.filter((hitbox) => !isGeneratedTiledHitbox(hitbox)) : [];
+  return [...preservedHitboxes, ...tiledHitboxes];
+}
+function isGeneratedTiledHitbox(hitbox) {
+  return typeof hitbox?.id === "string" && hitbox.id.startsWith(TILED_HITBOX_ID_PREFIX);
 }
-function ensureUnsubscribers(map) {
-  map._tiledCollisionUnsubscribers = map._tiledCollisionUnsubscribers || /* @__PURE__ */ new Map();
-  return map._tiledCollisionUnsubscribers;
+function createTiledHitboxId(x, y) {
+  return `${TILED_HITBOX_ID_PREFIX}${x},${y}`;
 }
 export {
   applyTiledPointEvents,
-  attachTiledCollisionToEntity,
-  detachTiledCollisionFromEntity,
-  prepareTiledPhysicsData,
-  resetTiledCollisionHandlers
+  prepareTiledPhysicsData
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/tiledmap",
-  "version": "5.0.0-alpha.42",
+  "version": "5.0.0-alpha.44",
   "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-alpha.42",
-    "@rpgjs/common": "5.0.0-alpha.42",
-    "@rpgjs/server": "5.0.0-alpha.42",
-    "@rpgjs/vite": "5.0.0-alpha.42",
+    "@rpgjs/client": "5.0.0-alpha.44",
+    "@rpgjs/common": "5.0.0-alpha.44",
+    "@rpgjs/server": "5.0.0-alpha.44",
+    "@rpgjs/vite": "5.0.0-alpha.44",
     "canvasengine": "*"
   },
   "publishConfig": {

package/src/client.ts

@@ -1,11 +1,6 @@
 import { RpgClient } from "@rpgjs/client";
 import { defineModule } from "@rpgjs/common";
-import {
-  attachTiledCollisionToEntity,
-  detachTiledCollisionFromEntity,
-  prepareTiledPhysicsData,
-  resetTiledCollisionHandlers,
-} from "./physics";
+import { prepareTiledPhysicsData } from "./physics";
 
 export default defineModule<RpgClient>({
   componentAnimations: [],
@@ -13,14 +8,5 @@ export default defineModule<RpgClient>({
     onPhysicsInit(map: any, context: { mapData: any }) {
       prepareTiledPhysicsData(context?.mapData, map);
     },
-    onPhysicsEntityAdd(map: any, context: { owner: any }) {
-      attachTiledCollisionToEntity(context?.owner, map);
-    },
-    onPhysicsEntityRemove(map: any, context: { owner: any }) {
-      detachTiledCollisionFromEntity(context?.owner, map);
-    },
-    onPhysicsReset(map: any) {
-      resetTiledCollisionHandlers(map);
-    },
   },
 });

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);
       }

package/src/physics.spec.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@canvasengine/tiled", () => {
+  class MapClass {
+    width: number;
+    height: number;
+    tilewidth: number;
+    tileheight: number;
+    widthPx: number;
+    heightPx: number;
+    private blockedTiles: Set<string>;
+
+    constructor(parsedMap: any) {
+      this.width = parsedMap.width ?? 0;
+      this.height = parsedMap.height ?? 0;
+      this.tilewidth = parsedMap.tilewidth ?? 32;
+      this.tileheight = parsedMap.tileheight ?? 32;
+      this.widthPx = this.width * this.tilewidth;
+      this.heightPx = this.height * this.tileheight;
+      this.blockedTiles = new Set(parsedMap.blockedTiles ?? []);
+    }
+
+    getTileByPosition(x: number, y: number) {
+      const tileX = Math.floor(x / this.tilewidth);
+      const tileY = Math.floor(y / this.tileheight);
+      return {
+        hasCollision: this.blockedTiles.has(`${tileX},${tileY}`),
+      };
+    }
+  }
+
+  return { MapClass };
+});
+
+import { prepareTiledPhysicsData } from "./physics";
+
+describe("prepareTiledPhysicsData", () => {
+  it("adds tiled collision hitboxes without duplicating them on repeated preparation", () => {
+    const mapData = {
+      parsedMap: {
+        width: 3,
+        height: 2,
+        tilewidth: 16,
+        tileheight: 20,
+        blockedTiles: ["1,0", "2,1"],
+      },
+      hitboxes: [{ id: "custom-hitbox", x: 4, y: 5, width: 6, height: 7 }],
+    };
+    const map: any = {};
+    const expectedHitboxes = [
+      { id: "custom-hitbox", x: 4, y: 5, width: 6, height: 7 },
+      { id: "__tiled_collision__:1,0", x: 16, y: 0, width: 16, height: 20 },
+      { id: "__tiled_collision__:2,1", x: 32, y: 20, width: 16, height: 20 },
+    ];
+
+    prepareTiledPhysicsData(mapData, map);
+
+    expect(mapData.width).toBe(48);
+    expect(mapData.height).toBe(40);
+    expect(mapData.hitboxes).toEqual(expectedHitboxes);
+
+    prepareTiledPhysicsData(mapData, map);
+
+    expect(mapData.hitboxes).toEqual(expectedHitboxes);
+  });
+
+  it("removes stale generated tiled hitboxes when blocked tiles change", () => {
+    const mapData = {
+      parsedMap: {
+        width: 2,
+        height: 1,
+        tilewidth: 32,
+        tileheight: 32,
+        blockedTiles: ["0,0"],
+      },
+      hitboxes: [],
+    };
+    const map: any = {};
+
+    prepareTiledPhysicsData(mapData, map);
+    expect(mapData.hitboxes).toEqual([
+      { id: "__tiled_collision__:0,0", x: 0, y: 0, width: 32, height: 32 },
+    ]);
+
+    mapData.parsedMap.blockedTiles = [];
+    prepareTiledPhysicsData(mapData, map);
+
+    expect(mapData.hitboxes).toEqual([]);
+  });
+});

package/src/physics.ts

@@ -2,15 +2,18 @@ import { MapClass } from "@canvasengine/tiled";
 
 type AnyMap = {
   tiled?: MapClass;
-  physic?: {
-    getEntityByUUID(id: string): any;
-  };
-  _blockedTiles?: Set<string>;
-  _tiledTileWidth?: number;
-  _tiledTileHeight?: number;
-  _tiledCollisionUnsubscribers?: Map<string, () => void>;
 };
 
+type RectHitbox = {
+  id: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+const TILED_HITBOX_ID_PREFIX = "__tiled_collision__:";
+
 export function prepareTiledPhysicsData(mapData: any, map: AnyMap): void {
   if (!mapData?.parsedMap) {
     return;
@@ -19,13 +22,10 @@ export function prepareTiledPhysicsData(mapData: any, map: AnyMap): void {
   const tiledMap = new MapClass(mapData.parsedMap);
   map.tiled = tiledMap;
 
-  mapData.hitboxes = mapData.hitboxes || [];
+  const tiledHitboxes = collectBlockedTileHitboxes(tiledMap);
+  mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
   mapData.width = tiledMap.widthPx;
   mapData.height = tiledMap.heightPx;
-
-  map._tiledTileWidth = tiledMap.tilewidth;
-  map._tiledTileHeight = tiledMap.tileheight;
-  map._blockedTiles = collectBlockedTiles(tiledMap);
 }
 
 export function applyTiledPointEvents(mapData: any): void {
@@ -54,70 +54,8 @@ export function applyTiledPointEvents(mapData: any): void {
   }
 }
 
-export function attachTiledCollisionToEntity(owner: any, map: AnyMap): void {
-  if (!owner?.id || !map?._blockedTiles) {
-    return;
-  }
-
-  const entity = map.physic?.getEntityByUUID(owner.id);
-  if (!entity || typeof entity.canEnterTile !== "function") {
-    return;
-  }
-
-  const unsubscribers = ensureUnsubscribers(map);
-  const previousUnsubscribe = unsubscribers.get(owner.id);
-  if (previousUnsubscribe) {
-    previousUnsubscribe();
-    unsubscribers.delete(owner.id);
-  }
-
-  const blockedTiles = map._blockedTiles;
-  const tiledTileWidth = map._tiledTileWidth ?? 32;
-  const tiledTileHeight = map._tiledTileHeight ?? 32;
-  const physicsTileWidth = 32;
-  const physicsTileHeight = 32;
-
-  const unsubscribe = entity.canEnterTile(({ x, y }) => {
-    const tiledX = Math.floor((x * physicsTileWidth) / tiledTileWidth);
-    const tiledY = Math.floor((y * physicsTileHeight) / tiledTileHeight);
-    return !blockedTiles.has(`${tiledX},${tiledY}`);
-  });
-
-  unsubscribers.set(owner.id, unsubscribe);
-}
-
-export function detachTiledCollisionFromEntity(owner: any, map: AnyMap): void {
-  if (!owner?.id) {
-    return;
-  }
-  const unsubscribers = map._tiledCollisionUnsubscribers;
-  if (!unsubscribers) {
-    return;
-  }
-  const unsubscribe = unsubscribers.get(owner.id);
-  if (!unsubscribe) {
-    return;
-  }
-  unsubscribe();
-  unsubscribers.delete(owner.id);
-}
-
-export function resetTiledCollisionHandlers(map: AnyMap): void {
-  const unsubscribers = map._tiledCollisionUnsubscribers;
-  if (unsubscribers) {
-    for (const unsubscribe of unsubscribers.values()) {
-      unsubscribe();
-    }
-    unsubscribers.clear();
-  }
-
-  map._blockedTiles = undefined;
-  map._tiledTileWidth = undefined;
-  map._tiledTileHeight = undefined;
-}
-
-function collectBlockedTiles(tiledMap: MapClass): Set<string> {
-  const blockedTiles = new Set<string>();
+function collectBlockedTileHitboxes(tiledMap: MapClass): RectHitbox[] {
+  const hitboxes: RectHitbox[] = [];
   const mapWidth = tiledMap.width;
   const mapHeight = tiledMap.height;
   const tileWidth = tiledMap.tilewidth;
@@ -129,15 +67,32 @@ function collectBlockedTiles(tiledMap: MapClass): Set<string> {
         populateTiles: true,
       });
       if (tileInfo.hasCollision) {
-        blockedTiles.add(`${x},${y}`);
+        hitboxes.push({
+          id: createTiledHitboxId(x, y),
+          x: x * tileWidth,
+          y: y * tileHeight,
+          width: tileWidth,
+          height: tileHeight,
+        });
       }
     }
   }
 
-  return blockedTiles;
+  return hitboxes;
+}
+
+function mergeTiledHitboxes(existingHitboxes: any, tiledHitboxes: RectHitbox[]): any[] {
+  const preservedHitboxes = Array.isArray(existingHitboxes)
+    ? existingHitboxes.filter((hitbox) => !isGeneratedTiledHitbox(hitbox))
+    : [];
+
+  return [...preservedHitboxes, ...tiledHitboxes];
+}
+
+function isGeneratedTiledHitbox(hitbox: any): boolean {
+  return typeof hitbox?.id === "string" && hitbox.id.startsWith(TILED_HITBOX_ID_PREFIX);
 }
 
-function ensureUnsubscribers(map: AnyMap): Map<string, () => void> {
-  map._tiledCollisionUnsubscribers = map._tiledCollisionUnsubscribers || new Map();
-  return map._tiledCollisionUnsubscribers;
+function createTiledHitboxId(x: number, y: number): string {
+  return `${TILED_HITBOX_ID_PREFIX}${x},${y}`;
 }

package/src/server.ts

@@ -1,13 +1,7 @@
 import { RpgMap, RpgServer } from "@rpgjs/server";
 import { MapClass } from "@canvasengine/tiled";
 import { defineModule } from "@rpgjs/common";
-import {
-  applyTiledPointEvents,
-  attachTiledCollisionToEntity,
-  detachTiledCollisionFromEntity,
-  prepareTiledPhysicsData,
-  resetTiledCollisionHandlers,
-} from "./physics";
+import { applyTiledPointEvents, prepareTiledPhysicsData } from "./physics";
 
 declare module "@rpgjs/server" {
   interface RpgMap {
@@ -27,18 +21,7 @@ export default defineModule<RpgServer>({
       return map;
     },
     onPhysicsInit(map: any, context: { mapData: any }) {
-      if (!map?._blockedTiles || !map?.tiled) {
-        prepareTiledPhysicsData(context?.mapData, map);
-      }
-    },
-    onPhysicsEntityAdd(map: any, context: { owner: any }) {
-      attachTiledCollisionToEntity(context?.owner, map);
-    },
-    onPhysicsEntityRemove(map: any, context: { owner: any }) {
-      detachTiledCollisionFromEntity(context?.owner, map);
-    },
-    onPhysicsReset(map: any) {
-      resetTiledCollisionHandlers(map);
+      prepareTiledPhysicsData(context?.mapData, map);
     },
   },
 });