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

package/dist/physics.d.ts

@@ -0,0 +1,17 @@
+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,149 +1,28 @@
-import { MapClass } from "./index3.js";
 import { defineModule } from "@rpgjs/common";
+import { resetTiledCollisionHandlers, detachTiledCollisionFromEntity, attachTiledCollisionToEntity, prepareTiledPhysicsData, applyTiledPointEvents } from "./index4.js";
 const server = defineModule({
   map: {
-    /**
-     * Hook called before map update
-     *
-     * @description Parses Tiled data and sets up tile-based collision detection
-     * using the physics engine's tile grid system instead of individual hitboxes.
-     *
-     * This method:
-     * 1. Parses TMX data with TiledParser
-     * 2. Creates a MapClass instance with parsed data
-     * 3. Attaches the Tiled instance to the RpgMap
-     * 4. Scans all tiles to detect collisions
-     * 5. Stores blocked tiles in a Set for use with the physics engine tile grid
-     * 6. Configures tile dimensions for proper coordinate conversion
-     *
-     * The blocked tiles are used by the physics engine's `canEnterTile` hook
-     * to prevent entities from entering collision tiles, which is more efficient
-     * than creating individual hitboxes for each tile.
-     *
-     * @param mapData - Map data containing TMX information
-     * @param map - RpgMap instance to extend
-     * @returns The modified map instance with tiled property
-     *
-     * @example
-     * ```ts
-     * // Blocked tiles are stored as a Set with keys "x,y" (tile coordinates)
-     * // The physics engine will automatically check these tiles when entities
-     * // try to move, using the canEnterTile hook applied to all entities
-     * ```
-     */
     onBeforeUpdate(mapData, map) {
-      const tiledMap = new MapClass(mapData.parsedMap);
-      map.tiled = tiledMap;
-      mapData.hitboxes = mapData.hitboxes || [];
-      mapData.width = tiledMap.widthPx;
-      mapData.height = tiledMap.heightPx;
-      const tileWidth = tiledMap.tilewidth;
-      const tileHeight = tiledMap.tileheight;
-      map._tiledTileWidth = tileWidth;
-      map._tiledTileHeight = tileHeight;
-      const blockedTiles = /* @__PURE__ */ new Set();
-      const mapWidth = tiledMap.width;
-      const mapHeight = tiledMap.height;
-      for (let y = 0; y < mapHeight; y++) {
-        for (let x = 0; x < mapWidth; x++) {
-          const pixelX = x * tileWidth;
-          const pixelY = y * tileHeight;
-          const tileInfo = tiledMap.getTileByPosition(pixelX, pixelY, [0, 0], {
-            populateTiles: true
-          });
-          if (tileInfo.hasCollision) {
-            blockedTiles.add(`${x},${y}`);
-          }
-        }
-      }
-      map._blockedTiles = blockedTiles;
-      for (let obj of mapData.parsedMap.objects) {
-        if (obj.point) {
-          mapData.events = mapData.events.map((e) => {
-            if (e.name === obj.name) {
-              return {
-                event: e,
-                x: obj.x,
-                y: obj.y
-              };
-            }
-            return e;
-          }).filter((e) => e !== null);
-        }
-      }
-      setTimeout(() => {
-        applyTileCollisionToEntities(map);
-      }, 0);
+      prepareTiledPhysicsData(mapData, map);
+      applyTiledPointEvents(mapData);
       return map;
-    }
-  },
-  player: {
-    /**
-     * Hook called when a player joins a map
-     *
-     * @description Applies tile-based collision detection to the player's physics entity
-     * using the blocked tiles stored on the map
-     *
-     * @param player - The player instance
-     * @param map - The map instance
-     */
-    onJoinMap(player, map) {
-      setTimeout(() => {
-        applyTileCollisionToEntity(player, map);
-      }, 0);
-    }
-  }
-});
-function applyTileCollisionToEntity(owner, map) {
-  if (!owner?.id || !map?._blockedTiles) {
-    return;
-  }
-  const entity = map.physic?.getEntityByUUID(owner.id);
-  if (!entity) {
-    return;
-  }
-  const blockedTiles = map._blockedTiles;
-  const tiledTileWidth = map._tiledTileWidth ?? 32;
-  const tiledTileHeight = map._tiledTileHeight ?? 32;
-  const physicsTileWidth = 32;
-  const physicsTileHeight = 32;
-  entity.canEnterTile(({ x, y }) => {
-    const tiledX = Math.floor(x * physicsTileWidth / tiledTileWidth);
-    const tiledY = Math.floor(y * physicsTileHeight / tiledTileHeight);
-    const tileKey = `${tiledX},${tiledY}`;
-    if (blockedTiles.has(tileKey)) {
-      return false;
-    }
-    return true;
-  });
-}
-function applyTileCollisionToEntities(map) {
-  if (!map?._blockedTiles) {
-    return;
-  }
-  if (map.players && typeof map.players === "function") {
-    const players = map.players();
-    if (players && typeof players === "object") {
-      for (const playerId in players) {
-        const player = players[playerId];
-        if (player) {
-          applyTileCollisionToEntity(player, 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);
     }
   }
-  if (map.events && typeof map.events === "function") {
-    const events = map.events();
-    if (events && typeof events === "object") {
-      for (const eventId in events) {
-        const event = events[eventId];
-        if (event) {
-          applyTileCollisionToEntity(event, map);
-        }
-      }
-    }
-  }
-}
+});
 export {
   server as default
 };

package/dist/server/index4.js

@@ -0,0 +1,117 @@
+import { MapClass } from "./index3.js";
+function prepareTiledPhysicsData(mapData, map) {
+  if (!mapData?.parsedMap) {
+    return;
+  }
+  const tiledMap = new MapClass(mapData.parsedMap);
+  map.tiled = tiledMap;
+  mapData.hitboxes = mapData.hitboxes || [];
+  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;
+  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 (eventEntry?.name === obj.name) {
+        return {
+          event: eventEntry,
+          x: obj.x,
+          y: obj.y
+        };
+      }
+      return eventEntry;
+    }).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();
+  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++) {
+      const tileInfo = tiledMap.getTileByPosition(x * tileWidth, y * tileHeight, [0, 0], {
+        populateTiles: true
+      });
+      if (tileInfo.hasCollision) {
+        blockedTiles.add(`${x},${y}`);
+      }
+    }
+  }
+  return blockedTiles;
+}
+function ensureUnsubscribers(map) {
+  map._tiledCollisionUnsubscribers = map._tiledCollisionUnsubscribers || /* @__PURE__ */ new Map();
+  return map._tiledCollisionUnsubscribers;
+}
+export {
+  applyTiledPointEvents,
+  attachTiledCollisionToEntity,
+  detachTiledCollisionFromEntity,
+  prepareTiledPhysicsData,
+  resetTiledCollisionHandlers
+};

package/dist/server.d.ts

@@ -5,61 +5,8 @@ declare module "@rpgjs/server" {
         tiled?: MapClass;
     }
 }
-/**
- * Interface for an RpgMap extended with Tiled functionality
- *
- * @description This interface combines RpgMap with MapClass to enable
- * the use of Tiled methods on RPG maps
- */
 export interface RpgTiledMap extends RpgMap {
     tiled: MapClass;
 }
-/**
- * Tiled Module for RPGJS
- *
- * @description This module extends RPGJS maps with Tiled functionality,
- * allowing TMX map parsing and automatic tile-based collision detection
- * using the physics engine's tile grid system
- *
- * ## Features
- *
- * - **Automatic parsing**: Parses TMX files from Tiled Map Editor
- * - **Collision detection**: Scans all tiles to detect collisions
- * - **Tile grid system**: Uses physics engine tile grid to block movement on collision tiles
- * - **RpgMap extension**: Adds the `tiled` property to all RpgMap instances
- *
- * ## Usage
- *
- * Once this module is activated, you can use Tiled methods on your maps:
- *
- * @example
- * ```ts
- * // In a map class
- * class MyMap extends RpgMap {
- *     onLoad() {
- *         // Access Tiled functionality
- *         const tiles = this.tiled.getTileByPosition(100, 100);
- *
- *         if (tiles.hasCollision) {
- *             console.log('This position has a collision');
- *         }
- *
- *         // Iterate through all tiles by index
- *         for (let i = 0; i < this.tiled.width * this.tiled.height; i++) {
- *             const tileInfo = this.tiled.getTileByIndex(i);
- *             if (tileInfo.hasCollision) {
- *                 console.log(`Tile ${i} has collision`);
- *             }
- *         }
- *
- *         // Get information about a specific layer
- *         const layer = this.tiled.getLayerByName('Collision');
- *         if (layer) {
- *             console.log('Collision layer found:', layer);
- *         }
- *     }
- * }
- * ```
- */
 declare const _default: any;
 export default _default;

package/package.json

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

package/src/client.ts

@@ -1,6 +1,26 @@
-import { RpgClient, RpgClientEngine } from "@rpgjs/client";
+import { RpgClient } from "@rpgjs/client";
 import { defineModule } from "@rpgjs/common";
+import {
+  attachTiledCollisionToEntity,
+  detachTiledCollisionFromEntity,
+  prepareTiledPhysicsData,
+  resetTiledCollisionHandlers,
+} from "./physics";
 
 export default defineModule<RpgClient>({
-    componentAnimations: []
-})
+  componentAnimations: [],
+  sceneMap: {
+    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/physics.ts

@@ -0,0 +1,143 @@
+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 function prepareTiledPhysicsData(mapData: any, map: AnyMap): void {
+  if (!mapData?.parsedMap) {
+    return;
+  }
+
+  const tiledMap = new MapClass(mapData.parsedMap);
+  map.tiled = tiledMap;
+
+  mapData.hitboxes = mapData.hitboxes || [];
+  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 {
+  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: any) => {
+        if (eventEntry?.name === obj.name) {
+          return {
+            event: eventEntry,
+            x: obj.x,
+            y: obj.y,
+          };
+        }
+        return eventEntry;
+      })
+      .filter((eventEntry: any) => eventEntry !== null);
+  }
+}
+
+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>();
+  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++) {
+      const tileInfo = tiledMap.getTileByPosition(x * tileWidth, y * tileHeight, [0, 0], {
+        populateTiles: true,
+      });
+      if (tileInfo.hasCollision) {
+        blockedTiles.add(`${x},${y}`);
+      }
+    }
+  }
+
+  return blockedTiles;
+}
+
+function ensureUnsubscribers(map: AnyMap): Map<string, () => void> {
+  map._tiledCollisionUnsubscribers = map._tiledCollisionUnsubscribers || new Map();
+  return map._tiledCollisionUnsubscribers;
+}