@rpgjs/tiledmap 5.0.0-alpha.4 → 5.0.0-alpha.41

package/dist/client/index4.js

@@ -0,0 +1,18 @@
+import { useProps, useDefineProps, signal, effect, h, Container } from "canvasengine";
+import { EventLayerComponent } from "@rpgjs/client";
+import { TiledMap } from "@canvasengine/presets";
+function component($$props) {
+  useProps($$props);
+  const defineProps = useDefineProps($$props);
+  var _a = defineProps(), data = _a.data, params = _a.params;
+  var map = signal(data());
+  var basePath = signal(params().basePath);
+  effect(function() {
+    map.set(data());
+  });
+  let $this = h(Container, null, h(TiledMap, { map, basePath, createLayersPerTilesZ: true, objectLayer: () => h(EventLayerComponent) }));
+  return $this;
+}
+export {
+  component as default
+};

package/dist/client/index5.js

@@ -0,0 +1,95 @@
+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 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 {
+  attachTiledCollisionToEntity,
+  detachTiledCollisionFromEntity,
+  prepareTiledPhysicsData,
+  resetTiledCollisionHandlers
+};

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export declare function provideTiledMap(options: {
     basePath: string;
+    onLoadMap?: (map: string) => Promise<void>;
 }): any;

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/index.js

@@ -1,6 +1,6 @@
 import server from "./index2.js";
 import { createModule } from "@rpgjs/common";
-import "@rpgjs/tiled";
+import "./index3.js";
 const client = null;
 const provideLoadMap = null;
 function provideTiledMap(options) {
@@ -9,7 +9,7 @@ function provideTiledMap(options) {
       server,
       client
     },
-    provideLoadMap == null ? void 0 : provideLoadMap()
+    provideLoadMap?.()
   ]);
 }
 export {

package/dist/server/index2.js

@@ -1,92 +1,25 @@
-import { MapClass } from "@rpgjs/tiled";
 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 creates collision hitboxes
-     * automatically by iterating through all tiles on the map.
-     *
-     * 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. Automatically creates hitboxes for each collision tile
-     *
-     * @param mapData - Map data containing TMX information
-     * @param map - RpgMap instance to extend
-     * @returns The modified map instance with tiled property
-     *
-     * @example
-     * ```ts
-     * // Created hitboxes will have this structure:
-     * {
-     *     id: 'collision_x_y',           // Unique identifier
-     *     x: x * tileWidth,              // X position in pixels
-     *     y: y * tileHeight,             // Y position in pixels
-     *     width: tileWidth,              // Tile width
-     *     height: tileHeight,            // Tile height
-     *     properties: {
-     *         type: 'collision',         // Hitbox type
-     *         tileX: x,                  // X position in tiles
-     *         tileY: y,                  // Y position in tiles
-     *         tileIndex: tileIndex       // Tile index
-     *     }
-     * }
-     * ```
-     */
     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 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 pixelX = x * tileWidth;
-          const pixelY = y * tileHeight;
-          const tileInfo = tiledMap.getTileByPosition(pixelX, pixelY, [0, 0], {
-            populateTiles: true
-          });
-          if (tileInfo.hasCollision) {
-            const hitbox = {
-              id: `collision_${x}_${y}`,
-              x: pixelX,
-              y: pixelY,
-              width: tileWidth,
-              height: tileHeight,
-              properties: {
-                type: "collision",
-                tileX: x,
-                tileY: y,
-                tileIndex: tileInfo.tileIndex
-              }
-            };
-            mapData.hitboxes.push(hitbox);
-          }
-        }
-      }
-      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);
-        }
-      }
+      prepareTiledPhysicsData(mapData, map);
+      applyTiledPointEvents(mapData);
       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);
     }
   }
 });