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

package/dist/client/index5.js

@@ -0,0 +1,50 @@
+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;
+  const tiledHitboxes = collectBlockedTileHitboxes(tiledMap);
+  mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
+  mapData.width = tiledMap.widthPx;
+  mapData.height = tiledMap.heightPx;
+}
+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++) {
+      const tileInfo = tiledMap.getTileByPosition(x * tileWidth, y * tileHeight, [0, 0], {
+        populateTiles: true
+      });
+      if (tileInfo.hasCollision) {
+        hitboxes.push({
+          id: createTiledHitboxId(x, y),
+          x: x * tileWidth,
+          y: y * tileHeight,
+          width: tileWidth,
+          height: tileHeight
+        });
+      }
+    }
+  }
+  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 createTiledHitboxId(x, y) {
+  return `${TILED_HITBOX_ID_PREFIX}${x},${y}`;
+}
+export {
+  prepareTiledPhysicsData
+};

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

@@ -9,7 +9,7 @@ function provideTiledMap(options) {
       server,
       client
     },
-    provideLoadMap == null ? void 0 : provideLoadMap()
+    provideLoadMap?.()
   ]);
 }
 export {

package/dist/server/index2.js

@@ -1,92 +1,14 @@
-import { MapClass } from "./index3.js";
 import { defineModule } from "@rpgjs/common";
+import { 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) {
+      prepareTiledPhysicsData(context?.mapData, map);
     }
   }
 });

package/dist/server/index3.js

@@ -5,9 +5,6 @@ var TiledLayerType = /* @__PURE__ */ ((TiledLayerType2) => {
   TiledLayerType2["Group"] = "group";
   return TiledLayerType2;
 })(TiledLayerType || {});
-function joinPath(...segments) {
-  return segments.filter((segment) => segment && segment.length > 0).join("/").replace(/\/+/g, "/");
-}
 function getAugmentedNamespace(n) {
   if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
   var f = n.default;
@@ -142,7 +139,6 @@ function requireBase64Js() {
   return base64Js;
 }
 var ieee754 = {};
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 var hasRequiredIeee754;
 function requireIeee754() {
   if (hasRequiredIeee754) return ieee754;
@@ -226,12 +222,6 @@ function requireIeee754() {
   };
   return ieee754;
 }
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
 var hasRequiredBuffer;
 function requireBuffer() {
   if (hasRequiredBuffer) return buffer;
@@ -1803,7 +1793,7 @@ function requireBuffer() {
     function numberIsNaN(obj) {
       return obj !== obj;
     }
-    const hexSliceLookupTable = function() {
+    const hexSliceLookupTable = (function() {
       const alphabet = "0123456789abcdef";
       const table = new Array(256);
       for (let i = 0; i < 16; ++i) {
@@ -1813,7 +1803,7 @@ function requireBuffer() {
         }
       }
       return table;
-    }();
+    })();
     function defineBigIntMethod(fn) {
       return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
     }
@@ -1823,7 +1813,6 @@ function requireBuffer() {
   })(buffer);
   return buffer;
 }
-/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 var hasRequiredSafeBuffer;
 function requireSafeBuffer() {
   if (hasRequiredSafeBuffer) return safeBuffer.exports;
@@ -3531,7 +3520,6 @@ function requireSax() {
         }
         return parser;
       }
-      /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
       if (!String.fromCodePoint) {
         (function() {
           var stringFromCharCode = String.fromCharCode;
@@ -4376,288 +4364,12 @@ function requireLib() {
   };
   return lib;
 }
-var libExports = requireLib();
-var bufferExports = requireBuffer();
-const _TiledParser = class _TiledParser {
-  constructor(xml, filePath = "", basePath = "") {
-    this.xml = xml;
-    this.filePath = filePath;
-    this.basePath = basePath;
-    this.layers = /* @__PURE__ */ new Map();
-    this.transform = (obj) => {
-      var _a, _b;
-      if (!obj) return;
-      const attr = obj.attributes || obj._attributes;
-      if (!attr) return obj;
-      let newObj = {
-        ...obj,
-        ...attr,
-        ..._TiledParser.propToNumber(attr, [
-          "version",
-          "width",
-          "height",
-          "tilewidth",
-          "tileheight",
-          "nextlayerid",
-          "nextobjectid",
-          "hexsidelength",
-          "opacity",
-          "x",
-          "y",
-          "offsetx",
-          "offsety",
-          "startx",
-          "starty",
-          "id",
-          "firstgid",
-          "imageheight",
-          "imagewidth",
-          "margin",
-          "columns",
-          "rows",
-          "tilecount",
-          "rotation",
-          "gid",
-          "tileid",
-          "duration",
-          "parallaxx",
-          "parallaxy",
-          "repeatx",
-          "repeaty",
-          "pixelsize"
-        ]),
-        ..._TiledParser.propToBool(attr, [
-          "visible",
-          "infinite",
-          "locked",
-          "bold",
-          "italic",
-          "kerning",
-          "strikeout",
-          "underline",
-          "wrap"
-        ])
-      };
-      if (newObj.properties) {
-        const properties = _TiledParser.toArray(newObj.properties.property);
-        const propObj = {};
-        for (let prop of properties) {
-          const attr2 = prop._attributes;
-          if (!attr2) continue;
-          let val;
-          switch (attr2.type) {
-            case "file":
-              val = this.getImagePath(attr2.value);
-              break;
-            case "object":
-            case "float":
-            case "int":
-              val = +attr2.value;
-              break;
-            case "bool":
-              val = attr2.value == "true" ? true : false;
-              break;
-            case "class":
-              val = {
-                ...((_a = this.transform(prop)) == null ? void 0 : _a.properties) ?? {},
-                _classname: attr2.propertytype
-              };
-              break;
-            default:
-              val = attr2.value;
-          }
-          propObj[attr2.name] = val;
-        }
-        newObj.properties = propObj;
-      }
-      if (newObj.polygon) {
-        newObj.polygon = this.transform(newObj.polygon);
-      }
-      if (newObj.polyline) {
-        newObj.polyline = this.transform(newObj.polyline);
-      }
-      if (newObj.points) {
-        newObj = newObj.points.split(" ").map((point) => {
-          const pos = point.split(",");
-          return { x: +pos[0], y: +pos[1] };
-        });
-      }
-      if (newObj.point) {
-        newObj.point = true;
-      }
-      if (newObj.ellipse) {
-        newObj.ellipse = true;
-      }
-      if (newObj.text) {
-        newObj.text = {
-          text: newObj.text._text,
-          ...this.transform(newObj.text)
-        };
-        delete newObj.text._text;
-      }
-      if (newObj.image) {
-        newObj.image = this.transform(newObj.image);
-      }
-      if (newObj.source) {
-        if (!this.isTilesetSource(newObj)) {
-          newObj.source = this.getImagePath(newObj.source);
-        }
-      }
-      const objectgroup = newObj.object || ((_b = newObj.objectgroup) == null ? void 0 : _b.object);
-      if (objectgroup) {
-        newObj.objects = _TiledParser.toArray(objectgroup).map((object) => {
-          return this.transform(object);
-        });
-      }
-      delete newObj._attributes;
-      delete newObj.attributes;
-      delete newObj.object;
-      delete newObj.objectgroup;
-      return newObj;
-    };
-  }
-  static toArray(prop) {
-    if (!prop) return [];
-    if (!Array.isArray(prop)) return [prop];
-    return prop;
-  }
-  getImagePath(image) {
-    if (this.filePath.startsWith("http")) return new URL(image, this.filePath).href;
-    return joinPath(this.basePath, image);
-  }
-  /**
-   * Check if the object is a tileset source reference
-   * Tileset sources should not have their paths transformed with getImagePath
-   */
-  isTilesetSource(obj) {
-    return obj.firstgid !== void 0 || obj.tilewidth !== void 0 || obj.tileheight !== void 0 || obj.tilecount !== void 0 || obj.columns !== void 0;
-  }
-  static unpackTileBytes(buffer2, size) {
-    const expectedCount = size * 4;
-    if (buffer2.length !== expectedCount) {
-      throw new Error("Expected " + expectedCount + " bytes of tile data; received " + buffer2.length);
-    }
-    let tileIndex = 0;
-    const array = [];
-    for (let i = 0; i < expectedCount; i += 4) {
-      array[tileIndex] = buffer2.readUInt32LE(i);
-      tileIndex++;
-    }
-    return array;
-  }
-  static decode(obj, size) {
-    const { encoding, data } = obj;
-    if (encoding == "base64") {
-      return _TiledParser.unpackTileBytes(bufferExports.Buffer.from(data.trim(), "base64"), size);
-    } else if (encoding == "csv") {
-      return data.trim().split(",").map((x) => +x);
-    }
-    return data;
-  }
-  parseMap() {
-    const json = libExports.xml2js(this.xml, { compact: true });
-    const jsonNoCompact = libExports.xml2js(this.xml);
-    const tileset = json.map.tileset;
-    json.map.group;
-    const recursiveObjectGroup = (obj) => {
-      const { objectgroup, group: group2, layer, imagelayer } = obj;
-      const setLayer = (type) => {
-        if (!type) return;
-        _TiledParser.toArray(type).forEach((val) => {
-          if (this.layers.has(+val._attributes.id)) {
-            throw new Error(`Tiled Parser Error: Layer with id ${val._attributes.id} already exists`);
-          }
-          this.layers.set(+val._attributes.id, val);
-        });
-      };
-      setLayer(objectgroup);
-      setLayer(layer);
-      setLayer(group2);
-      setLayer(imagelayer);
-      if (group2) {
-        recursiveObjectGroup(group2);
-      }
-    };
-    recursiveObjectGroup(json.map);
-    const recursiveLayer = (elements, array = []) => {
-      var _a;
-      if (!elements) return array;
-      for (let element of elements) {
-        const { name } = element;
-        if (!["layer", "group", "imagelayer", "objectgroup"].includes(name)) continue;
-        const data = (_a = element.elements) == null ? void 0 : _a.find((el) => el.name == "data");
-        element.layer = this.layers.get(+element.attributes.id);
-        const obj = {
-          ...this.transform(data) ?? {},
-          ...this.transform(element),
-          ...this.transform(element.layer),
-          layers: recursiveLayer(element.elements),
-          data: data ? data.elements[0].text : void 0,
-          type: name == "layer" ? "tilelayer" : name
-        };
-        delete obj.elements;
-        delete obj.layer;
-        if (obj.data) obj.data = _TiledParser.decode(obj, obj.width * obj.height);
-        array.push(obj);
-      }
-      return array;
-    };
-    const layers = recursiveLayer(jsonNoCompact.elements[0].elements);
-    const tilesets = _TiledParser.toArray(tileset).map((tileset2) => {
-      const obj = this.transform(tileset2);
-      return obj;
-    });
-    const ret = {
-      ...this.transform(json.map),
-      layers,
-      tilesets
-    };
-    delete ret.layer;
-    delete ret.tileset;
-    delete ret.group;
-    delete ret.imagelayer;
-    return ret;
-  }
-  parseTileset() {
-    const json = libExports.xml2js(this.xml, { compact: true });
-    const { tileset } = json;
-    const ret = {
-      ...this.transform(tileset),
-      image: this.transform(tileset.image),
-      tiles: _TiledParser.toArray(tileset.tile).map((tile) => {
-        const ret2 = this.transform(tile);
-        if (tile.animation) {
-          ret2.animations = _TiledParser.toArray(tile.animation.frame).map(this.transform);
-        }
-        delete ret2.animation;
-        return ret2;
-      })
-    };
-    delete ret.tile;
-    return ret;
-  }
-};
-_TiledParser.propToNumber = (obj, props) => {
-  for (let key of props) {
-    if (obj[key] !== void 0) {
-      obj[key] = +obj[key];
-    }
-  }
-  return obj;
-};
-_TiledParser.propToBool = (obj, props) => {
-  for (let key of props) {
-    if (obj[key] !== void 0) {
-      obj[key] = obj[key] == "true" || obj[key] == "1";
-    }
-  }
-  return obj;
-};
-let TiledParser = _TiledParser;
+requireLib();
+requireBuffer();
 class TiledProperties {
   constructor(data) {
     this.properties = {};
-    this.properties = (data == null ? void 0 : data.properties) ?? {};
+    this.properties = data?.properties ?? {};
   }
   getProperty(name, defaultValue) {
     const val = this.properties[name];
@@ -4684,7 +4396,7 @@ class TileGid extends TiledProperties {
   constructor(obj) {
     super(obj);
     this.obj = obj;
-    this._gid = obj == null ? void 0 : obj.gid;
+    this._gid = obj?.gid;
   }
   static getRealGid(gid) {
     return gid & 268435455;
@@ -4725,7 +4437,7 @@ class TiledObjectClass extends TileGid {
     super(object);
     this.layerName = "";
     Object.assign(this, object);
-    if (object == null ? void 0 : object.gid) {
+    if (object?.gid) {
       this.y -= this.height;
     }
   }
@@ -5226,7 +4938,6 @@ export {
   Tile,
   TiledLayerType,
   TiledObjectClass,
-  TiledParser,
   TiledProperties,
   Tileset
 };

package/dist/server/index4.js

@@ -0,0 +1,72 @@
+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;
+  const tiledHitboxes = collectBlockedTileHitboxes(tiledMap);
+  mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
+  mapData.width = tiledMap.widthPx;
+  mapData.height = tiledMap.heightPx;
+}
+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 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++) {
+      const tileInfo = tiledMap.getTileByPosition(x * tileWidth, y * tileHeight, [0, 0], {
+        populateTiles: true
+      });
+      if (tileInfo.hasCollision) {
+        hitboxes.push({
+          id: createTiledHitboxId(x, y),
+          x: x * tileWidth,
+          y: y * tileHeight,
+          width: tileWidth,
+          height: tileHeight
+        });
+      }
+    }
+  }
+  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 createTiledHitboxId(x, y) {
+  return `${TILED_HITBOX_ID_PREFIX}${x},${y}`;
+}
+export {
+  applyTiledPointEvents,
+  prepareTiledPhysicsData
+};

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 hitbox creation
- * based on collisions defined in Tiled
- *
- * ## Features
- *
- * - **Automatic parsing**: Parses TMX files from Tiled Map Editor
- * - **Collision detection**: Scans all tiles to detect collisions
- * - **Hitbox creation**: Automatically generates hitboxes for each collision tile
- * - **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;