@rpgjs/server 5.0.0-alpha.25 → 5.0.0-alpha.26

package/dist/index.js

@@ -7743,12 +7743,30 @@ var Server = class {
       load(instance, tmpObject, true);
     }, "loadMemory");
     instance.$memoryAll = {};
+    instance.$autoSync = instance["autoSync"] !== false;
+    instance.$pendingSync = /* @__PURE__ */ new Map();
     instance.$send = (conn, obj) => {
       return this.send(conn, obj, instance);
     };
     instance.$broadcast = (obj) => {
       return this.broadcast(obj, instance);
     };
+    instance.$applySync = () => {
+      let packet;
+      if (instance.$pendingSync.size > 0) {
+        if (options.getMemoryAll) {
+          buildObject(instance.$pendingSync, instance.$memoryAll);
+        }
+        packet = buildObject(instance.$pendingSync, instance.$memoryAll);
+        instance.$pendingSync.clear();
+      } else {
+        packet = instance.$memoryAll;
+      }
+      this.broadcast({
+        type: "sync",
+        value: packet
+      }, instance);
+    };
     instance.$sessionTransfer = async (conn, targetRoomId) => {
       let user;
       const signal2 = this.getUsersProperty(instance);
@@ -7815,6 +7833,13 @@ var Server = class {
         init = false;
         return;
       }
+      if (!instance.$autoSync) {
+        for (const [path, value] of values) {
+          instance.$pendingSync.set(path, value);
+        }
+        values.clear();
+        return;
+      }
       const packet = buildObject(values, instance.$memoryAll);
       this.broadcast({
         type: "sync",
@@ -7839,11 +7864,12 @@ var Server = class {
       values.clear();
     }, "persistCb");
     syncClass(instance, {
-      onSync: throttle(syncCb, instance["throttleSync"] ?? 500),
-      onPersist: throttle(persistCb, instance["throttleStorage"] ?? 2e3)
+      onSync: instance["throttleSync"] ? throttle(syncCb, instance["throttleSync"]) : syncCb,
+      onPersist: instance["throttleStorage"] ? throttle(persistCb, instance["throttleStorage"]) : persistCb
     });
     await loadMemory();
     initPersist = false;
+    init = false;
     return instance;
   }
   /**
@@ -8049,13 +8075,15 @@ var Server = class {
       publicId
     });
     await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
-    this.send(conn, {
-      type: "sync",
-      value: {
-        pId: publicId,
-        ...subRoom.$memoryAll
-      }
-    }, subRoom);
+    if (subRoom.$autoSync) {
+      this.send(conn, {
+        type: "sync",
+        value: {
+          pId: publicId,
+          ...subRoom.$memoryAll
+        }
+      }, subRoom);
+    }
   }
   /**
   * @method onConnect
@@ -9777,10 +9805,10 @@ class Item {
     this.quantity = signal(1);
     this.onAdd = () => {
     };
-    this.description.set(data.description);
-    this.price.set(data.price);
-    this.name.set(data.name);
-    this.onAdd = data.onAdd?.bind(this) ?? (() => {
+    this.description.set(data?.description ?? "");
+    this.price.set(data?.price ?? 0);
+    this.name.set(data?.name ?? "");
+    this.onAdd = data?.onAdd?.bind(this) ?? (() => {
     });
   }
 }
@@ -15777,6 +15805,10 @@ class RpgCommonMap {
     });
     this.moveManager = new MovementManager(() => this.physic);
     this.speedScalar = 50;
+    // Default speed scalar for movement
+    // World Maps properties
+    this.tileWidth = 32;
+    this.tileHeight = 32;
     this.physicsAccumulatorMs = 0;
     this.physicsSyncDepth = 0;
     /**
@@ -15831,6 +15863,88 @@ class RpgCommonMap {
   get isStandalone() {
     return typeof window !== "undefined";
   }
+  /**
+   * Get the width of the map in pixels
+   * 
+   * @returns The width of the map in pixels, or 0 if not loaded
+   * 
+   * @example
+   * ```ts
+   * const width = map.widthPx;
+   * console.log(`Map width: ${width}px`);
+   * ```
+   */
+  get widthPx() {
+    return this.data()?.width ?? 0;
+  }
+  /**
+   * Get the height of the map in pixels
+   * 
+   * @returns The height of the map in pixels, or 0 if not loaded
+   * 
+   * @example
+   * ```ts
+   * const height = map.heightPx;
+   * console.log(`Map height: ${height}px`);
+   * ```
+   */
+  get heightPx() {
+    return this.data()?.height ?? 0;
+  }
+  /**
+   * Get the unique identifier of the map
+   * 
+   * @returns The map ID, or empty string if not loaded
+   * 
+   * @example
+   * ```ts
+   * const mapId = map.id;
+   * console.log(`Current map: ${mapId}`);
+   * ```
+   */
+  get id() {
+    return this.data()?.id ?? "";
+  }
+  /**
+  * Get the X position of this map in the world coordinate system
+  * 
+  * This is used when maps are part of a larger world map. The world position
+  * indicates where this map is located relative to other maps.
+  * 
+  * @returns The X position in world coordinates, or 0 if not in a world
+  * 
+  * @example
+  * ```ts
+  * const worldX = map.worldX;
+  * console.log(`Map is at world position (${worldX}, ${map.worldY})`);
+  * ```
+  */
+  get worldX() {
+    const worldMaps = this.getWorldMapsManager?.();
+    if (!worldMaps) return 0;
+    const mapId = this.id.startsWith("map-") ? this.id.slice(4) : this.id;
+    return worldMaps.getMapInfo(mapId)?.worldX ?? 0;
+  }
+  /**
+   * Get the Y position of this map in the world coordinate system
+   * 
+   * This is used when maps are part of a larger world map. The world position
+   * indicates where this map is located relative to other maps.
+   * 
+   * @returns The Y position in world coordinates, or 0 if not in a world
+   * 
+   * @example
+   * ```ts
+   * const worldY = map.worldY;
+   * console.log(`Map is at world position (${map.worldX}, ${worldY})`);
+   * ```
+   */
+  get worldY() {
+    const worldMaps = this.getWorldMapsManager?.();
+    if (!worldMaps) return 0;
+    const mapId = this.id.startsWith("map-") ? this.id.slice(4) : this.id;
+    return worldMaps.getMapInfo(mapId)?.worldY ?? 0;
+  }
   /**
    * Clear all physics content and reset to initial state
    * 
@@ -16922,17 +17036,19 @@ class WorldMapsManager {
     if (typeof search === "number") {
       const src = map;
       return maps.filter((m) => {
-        const horizontallyOverlaps = Math.max(src.worldX, m.worldX) < Math.min(src.worldX + src.width, m.worldX + m.width);
-        const verticallyOverlaps = Math.max(src.worldY, m.worldY) < Math.min(src.worldY + src.height, m.worldY + m.height);
+        const horizontallyOverlapsOrTouches = Math.max(src.worldX, m.worldX) <= Math.min(src.worldX + src.widthPx, m.worldX + m.widthPx);
+        const verticallyOverlapsOrTouches = Math.max(src.worldY, m.worldY) <= Math.min(src.worldY + src.heightPx, m.worldY + m.heightPx);
+        const marginLeftRight = src.tileWidth / 2;
+        const marginTopDown = src.tileHeight / 2;
         switch (search) {
           case 0:
-            return verticallyOverlaps && m.worldY + m.height === src.worldY;
+            return verticallyOverlapsOrTouches && m.worldY + m.heightPx - marginTopDown === src.worldY;
           case 1:
-            return verticallyOverlaps && m.worldY === src.worldY + src.height;
+            return verticallyOverlapsOrTouches && m.worldY + marginTopDown === src.worldY + src.heightPx;
           case 2:
-            return horizontallyOverlaps && m.worldX + m.width === src.worldX;
+            return horizontallyOverlapsOrTouches && m.worldX + m.widthPx - marginLeftRight === src.worldX;
           case 3:
-            return horizontallyOverlaps && m.worldX === src.worldX + src.width;
+            return horizontallyOverlapsOrTouches && m.worldX + marginLeftRight === src.worldX + src.widthPx;
           default:
             return false;
         }
@@ -16940,7 +17056,7 @@ class WorldMapsManager {
     }
     if ("x" in search && "y" in search) {
       const found = maps.find(
-        (m) => search.x >= m.worldX && search.x < m.worldX + m.width && search.y >= m.worldY && search.y < m.worldY + m.height
+        (m) => search.x >= m.worldX && search.x < m.worldX + m.widthPx && search.y >= m.worldY && search.y < m.worldY + m.heightPx
       );
       return found ? [found] : [];
     }
@@ -16948,9 +17064,9 @@ class WorldMapsManager {
       const { minX, minY, maxX, maxY } = search;
       return maps.filter((m) => {
         const aLeft = m.worldX;
-        const aRight = m.worldX + m.width;
+        const aRight = m.worldX + m.widthPx;
         const aTop = m.worldY;
-        const aBottom = m.worldY + m.height;
+        const aBottom = m.worldY + m.heightPx;
         const bLeft = minX;
         const bRight = maxX;
         const bTop = minY;
@@ -19361,8 +19477,8 @@ function WithItemManager(Base) {
       });
     }
     addItem(item, nb = 1) {
-      const map = this.getCurrentMap();
-      if (!map) {
+      const map = this.getCurrentMap() || this.map;
+      if (!map || !map.database) {
         throw new Error("Player must be on a map to add items");
       }
       let itemId;
@@ -19371,11 +19487,6 @@ function WithItemManager(Base) {
       if (isString(item)) {
         itemId = item;
         data = this.databaseById(itemId);
-        if (!data) {
-          throw new Error(
-            `The ID=${itemId} data is not found in the database. Add the data in the property "database"`
-          );
-        }
       } else if (typeof item === "function" || item.prototype) {
         itemId = item.name;
         const existingData = map.database()[itemId];
@@ -19404,6 +19515,21 @@ function WithItemManager(Base) {
       if (existingItem) {
         instance = existingItem;
         instance.quantity.update((it) => it + nb);
+        if (data.name !== void 0) {
+          instance.name.set(data.name);
+        }
+        if (data.description !== void 0) {
+          instance.description.set(data.description);
+        }
+        if (data.price !== void 0) {
+          instance.price.set(data.price);
+        }
+        if (itemInstance && typeof itemInstance === "object" && !(itemInstance instanceof Function)) {
+          instance._itemInstance = itemInstance;
+          if (itemInstance.onAdd) {
+            instance.onAdd = itemInstance.onAdd.bind(itemInstance);
+          }
+        }
       } else {
         instance = new Item(data);
         instance.id.set(itemId);
@@ -19488,7 +19614,11 @@ function WithItemManager(Base) {
     getParamItem(name) {
       let nb = 0;
       for (let item of this.equipments()) {
-        nb += item[name] || 0;
+        try {
+          const itemData = this.databaseById(item.id());
+          nb += itemData[name] || 0;
+        } catch {
+        }
       }
       const modifier = this.paramsModifier?.[name];
       if (modifier) {
@@ -19515,19 +19645,23 @@ function WithItemManager(Base) {
       if (!inventory) {
         throw ItemLog.notInInventory(itemId);
       }
-      const item = inventory;
-      if (item.consumable === false) {
+      const itemData = this.databaseById(itemId);
+      const consumable = itemData?.consumable;
+      if (consumable === false) {
         throw ItemLog.notUseItem(itemId);
       }
-      const hitRate = item.hitRate ?? 1;
-      const hookTarget = item._itemInstance || item;
+      if (consumable === void 0 && itemData?._type && itemData._type !== "item") {
+        throw ItemLog.notUseItem(itemId);
+      }
+      const hitRate = itemData?.hitRate ?? 1;
+      const hookTarget = inventory._itemInstance || inventory;
       if (Math.random() > hitRate) {
         this.removeItem(itemClass);
         this["execMethod"]("onUseFailed", [this], hookTarget);
         throw ItemLog.chanceToUseFailed(itemId);
       }
-      this.applyEffect?.(item);
-      this.applyStates?.(this, item);
+      this.applyEffect?.(itemData);
+      this.applyStates?.(this, itemData);
       this["execMethod"]("onUse", [this], hookTarget);
       this.removeItem(itemClass);
       return inventory;
@@ -19972,7 +20106,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     this.map = null;
     this.conn = null;
     this.touchSide = false;
-    // Protection against map change loops
+    this._worldPositionSignals = /* @__PURE__ */ new WeakMap();
     /** Internal: Shapes attached to this player */
     this._attachedShapes = /* @__PURE__ */ new Map();
     /** Internal: Shapes where this player is currently located */
@@ -20021,6 +20155,56 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       }
     });
   }
+  // Protection against map change loops
+  /**
+   * Computed signal for world X position
+   * 
+   * Calculates the absolute world X position from the map's world position
+   * plus the player's local X position. Returns 0 if no map is assigned.
+   * 
+   * @example
+   * ```ts
+   * const worldX = player.worldX();
+   * console.log(`Player is at world X: ${worldX}`);
+   * ```
+   */
+  get worldPositionX() {
+    return this._getComputedWorldPosition("x");
+  }
+  /**
+   * Computed signal for world Y position
+   * 
+   * Calculates the absolute world Y position from the map's world position
+   * plus the player's local Y position. Returns 0 if no map is assigned.
+   * 
+   * @example
+   * ```ts
+   * const worldY = player.worldY();
+   * console.log(`Player is at world Y: ${worldY}`);
+   * ```
+   */
+  get worldPositionY() {
+    return this._getComputedWorldPosition("y");
+  }
+  _getComputedWorldPosition(axis) {
+    if (!this._worldPositionSignals) {
+      this._worldPositionSignals = /* @__PURE__ */ new WeakMap();
+    }
+    const key = axis;
+    let signals = this._worldPositionSignals.get(this);
+    if (!signals) {
+      signals = {};
+      this._worldPositionSignals.set(this, signals);
+    }
+    if (!signals[key]) {
+      signals[key] = computed(() => {
+        const map2 = this.map;
+        const mapWorldPos = map2 ? map2[axis === "x" ? "worldX" : "worldY"] ?? 0 : 0;
+        return mapWorldPos + this[axis]();
+      });
+    }
+    return signals[key];
+  }
   _onInit() {
     this.hooks.callHooks("server-playerProps-load", this).subscribe();
   }
@@ -20031,6 +20215,9 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   get server() {
     return this.map;
   }
+  setMap(map2) {
+    this.map = map2;
+  }
   applyFrames() {
     this._frames.set(this.frames);
     this.frames = [];
@@ -20080,76 +20267,55 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     });
     return true;
   }
-  /**
-   * Auto change map when player touches map borders
-   * 
-   * This method checks if the player touches the current map borders
-   * and automatically performs a change to the adjacent map if it exists.
-   * 
-   * @param nextPosition - The next position of the player
-   * @returns Promise<boolean> - true if a map change occurred
-   * 
-   * @example
-   * ```ts
-   * // Called automatically by the movement system
-   * const changed = await player.autoChangeMap({ x: newX, y: newY });
-   * if (changed) {
-   *   console.log('Player changed map automatically');
-   * }
-   * ```
-   */
-  async autoChangeMap(nextPosition, forcedDirection) {
+  async autoChangeMap(nextPosition) {
     const map2 = this.getCurrentMap();
-    if (!map2) return false;
-    const worldMaps = map2.getWorldMapsManager?.();
+    const worldMaps = map2?.getInWorldMaps();
     let ret = false;
     if (worldMaps && map2) {
-      const direction = forcedDirection ?? this.getDirection();
-      const marginLeftRight = (map2.tileWidth ?? 32) / 2;
-      const marginTopDown = (map2.tileHeight ?? 32) / 2;
-      (map2.worldX ?? 0) + this.x();
-      (map2.worldY ?? 0) + this.y();
-      const changeMap = async (directionNumber, positionCalculator) => {
+      const direction = this.getDirection();
+      const marginLeftRight = map2.tileWidth / 2;
+      const marginTopDown = map2.tileHeight / 2;
+      const changeMap = async (adjacent, to) => {
         if (this.touchSide) {
           return false;
         }
         this.touchSide = true;
-        const [nextMap] = worldMaps.getAdjacentMaps(map2, directionNumber);
-        if (!nextMap) {
-          this.touchSide = false;
-          return false;
-        }
+        const [nextMap] = worldMaps.getAdjacentMaps(map2, adjacent);
+        if (!nextMap) return false;
         const id = nextMap.id;
         const nextMapInfo = worldMaps.getMapInfo(id);
-        if (!nextMapInfo) {
-          this.touchSide = false;
-          return false;
-        }
-        const newPosition = positionCalculator(nextMapInfo);
-        const success = await this.changeMap(id, newPosition);
-        setTimeout(() => {
-          this.touchSide = false;
-        }, 100);
-        return !!success;
+        return !!await this.changeMap(id, to(nextMapInfo));
       };
-      if (nextPosition.x < marginLeftRight && direction === Direction.Left) {
-        ret = await changeMap(2, (nextMapInfo) => ({
+      if (nextPosition.x < marginLeftRight && direction == Direction.Left) {
+        ret = await changeMap({
+          x: map2.worldX - 1,
+          y: this.worldPositionY() + 1
+        }, (nextMapInfo) => ({
           x: nextMapInfo.width - this.hitbox().w - marginLeftRight,
-          y: (map2.worldY ?? 0) - (nextMapInfo.y ?? 0) + nextPosition.y
+          y: map2.worldY - nextMapInfo.y + nextPosition.y
         }));
-      } else if (nextPosition.x > map2.widthPx - this.hitbox().w - marginLeftRight && direction === Direction.Right) {
-        ret = await changeMap(3, (nextMapInfo) => ({
+      } else if (nextPosition.x > map2.widthPx - this.hitbox().w - marginLeftRight && direction == Direction.Right) {
+        ret = await changeMap({
+          x: map2.worldX + map2.widthPx + 1,
+          y: this.worldPositionY() + 1
+        }, (nextMapInfo) => ({
           x: marginLeftRight,
-          y: (map2.worldY ?? 0) - (nextMapInfo.y ?? 0) + nextPosition.y
+          y: map2.worldY - nextMapInfo.y + nextPosition.y
         }));
-      } else if (nextPosition.y < marginTopDown && direction === Direction.Up) {
-        ret = await changeMap(0, (nextMapInfo) => ({
-          x: (map2.worldX ?? 0) - (nextMapInfo.x ?? 0) + nextPosition.x,
+      } else if (nextPosition.y < marginTopDown && direction == Direction.Up) {
+        ret = await changeMap({
+          x: this.worldPositionX() + 1,
+          y: map2.worldY - 1
+        }, (nextMapInfo) => ({
+          x: map2.worldX - nextMapInfo.x + nextPosition.x,
           y: nextMapInfo.height - this.hitbox().h - marginTopDown
         }));
-      } else if (nextPosition.y > map2.heightPx - this.hitbox().h - marginTopDown && direction === Direction.Down) {
-        ret = await changeMap(1, (nextMapInfo) => ({
-          x: (map2.worldX ?? 0) - (nextMapInfo.x ?? 0) + nextPosition.x,
+      } else if (nextPosition.y > map2.heightPx - this.hitbox().h - marginTopDown && direction == Direction.Down) {
+        ret = await changeMap({
+          x: this.worldPositionX() + 1,
+          y: map2.worldY + map2.heightPx + 1
+        }, (nextMapInfo) => ({
+          x: map2.worldX - nextMapInfo.x + nextPosition.x,
           y: marginTopDown
         }));
       } else {
@@ -20160,15 +20326,14 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   }
   async teleport(positions) {
     if (!this.map) return false;
-    if (this.map.physic) {
+    if (this.map && this.map.physic) {
       const entity = this.map.physic.getEntityByUUID(this.id);
       if (entity) {
         this.map.physic.teleport(entity, { x: positions.x, y: positions.y });
       }
-    } else {
-      this.x.set(positions.x);
-      this.y.set(positions.y);
     }
+    this.x.set(positions.x);
+    this.y.set(positions.y);
     queueMicrotask(() => {
       this.applyFrames();
     });
@@ -20250,8 +20415,8 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     this._eventChanges();
   }
   databaseById(id) {
-    const map2 = this.getCurrentMap();
-    if (!map2) return;
+    const map2 = this.map;
+    if (!map2 || !map2.database) return;
     const data = map2.database()[id];
     if (!data)
       throw new Error(
@@ -24318,6 +24483,99 @@ function superRefine(fn) {
     return _superRefine(fn);
 }
 
+class BaseRoom {
+  constructor() {
+    /**
+     * Signal containing the room's database of items, classes, and other game data
+     * 
+     * This database can be dynamically populated using `addInDatabase()` and
+     * `removeInDatabase()` methods. It's used to store game entities like items,
+     * classes, skills, etc. that are available in this room.
+     * 
+     * @example
+     * ```ts
+     * // Add data to database
+     * room.addInDatabase('Potion', PotionClass);
+     * 
+     * // Access database
+     * const potion = room.database()['Potion'];
+     * ```
+     */
+    this.database = signal({});
+  }
+  /**
+   * Add data to the room's database
+   * 
+   * Adds an item, class, or other game entity to the room's database.
+   * If the ID already exists and `force` is not enabled, the addition is ignored.
+   * 
+   * ## Architecture
+   * 
+   * This method is used by the item management system to store item definitions
+   * in the room's database. When a player adds an item, the system first checks
+   * if the item exists in the database, and if not, adds it using this method.
+   * 
+   * @param id - Unique identifier for the data
+   * @param data - The data to add (can be a class, object, etc.)
+   * @param options - Optional configuration
+   * @param options.force - If true, overwrites existing data with the same ID
+   * @returns `true` if data was added, `false` if it was ignored (ID already exists)
+   * 
+   * @example
+   * ```ts
+   * // Add a class to the database
+   * room.addInDatabase('Potion', PotionClass);
+   * 
+   * // Add an item object to the database
+   * room.addInDatabase('custom-item', {
+   *   name: 'Custom Item',
+   *   price: 100
+   * });
+   * 
+   * // Force overwrite existing data
+   * room.addInDatabase('Potion', UpdatedPotionClass, { force: true });
+   * ```
+   */
+  addInDatabase(id, data, options) {
+    const database = this.database();
+    if (database[id] !== void 0 && !options?.force) {
+      return false;
+    }
+    database[id] = data;
+    this.database.set(database);
+    return true;
+  }
+  /**
+   * Remove data from the room's database
+   * 
+   * This method allows you to remove items or data from the room's database.
+   * 
+   * @param id - Unique identifier of the data to remove
+   * @returns `true` if data was removed, `false` if ID didn't exist
+   * 
+   * @example
+   * ```ts
+   * // Remove an item from the database
+   * room.removeInDatabase('Potion');
+   * 
+   * // Check if removal was successful
+   * const removed = room.removeInDatabase('custom-item');
+   * if (removed) {
+   *   console.log('Item removed successfully');
+   * }
+   * ```
+   */
+  removeInDatabase(id) {
+    const database = this.database();
+    if (database[id] === void 0) {
+      return false;
+    }
+    delete database[id];
+    this.database.set(database);
+    return true;
+  }
+}
+
 var __defProp$1 = Object.defineProperty;
 var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
 var __decorateClass$1 = (decorators, target, key, kind) => {
@@ -24341,7 +24599,7 @@ const MapUpdateSchema = object({
   height: number()
 });
 let RpgMap = class extends RpgCommonMap {
-  constructor() {
+  constructor(room) {
     super();
     this.players = signal({});
     this.events = signal({});
@@ -24418,9 +24676,18 @@ let RpgMap = class extends RpgCommonMap {
     this._shapeEntities = /* @__PURE__ */ new Map();
     /** Enable/disable automatic tick processing (useful for unit tests) */
     this._autoTickEnabled = true;
+    this.autoSync = true;
     this.hooks.callHooks("server-map-onStart", this).subscribe();
-    this.throttleSync = this.isStandalone ? 0 : 50;
-    this.throttleStorage = this.isStandalone ? 0 : 1e3;
+    const isTest = room.env.TEST === "true" ? true : false;
+    if (isTest) {
+      this.autoSync = false;
+      this.setAutoTick(false);
+      this.throttleSync = 0;
+      this.throttleStorage = 0;
+    } else {
+      this.throttleSync = this.isStandalone ? 1 : 50;
+      this.throttleStorage = this.isStandalone ? 1 : 50;
+    }
     this.sessionExpiryTime = 1e3 * 60 * 5;
     this.setupCollisionDetection();
     if (this._autoTickEnabled) {
@@ -24617,7 +24884,11 @@ let RpgMap = class extends RpgCommonMap {
    * ```
    */
   onJoin(player, conn) {
-    player.map = this;
+    if (player.setMap) {
+      player.setMap(this);
+    } else {
+      player.map = this;
+    }
     player.context = context$1;
     player.conn = conn;
     player._onInit();
@@ -24683,85 +24954,8 @@ let RpgMap = class extends RpgCommonMap {
   get hooks() {
     return inject$1(context$1, ModulesToken);
   }
-  /**
-   * Get the width of the map in pixels
-   * 
-   * @returns The width of the map in pixels, or 0 if not loaded
-   * 
-   * @example
-   * ```ts
-   * const width = map.widthPx;
-   * console.log(`Map width: ${width}px`);
-   * ```
-   */
-  get widthPx() {
-    return this.data()?.width ?? 0;
-  }
-  /**
-   * Get the height of the map in pixels
-   * 
-   * @returns The height of the map in pixels, or 0 if not loaded
-   * 
-   * @example
-   * ```ts
-   * const height = map.heightPx;
-   * console.log(`Map height: ${height}px`);
-   * ```
-   */
-  get heightPx() {
-    return this.data()?.height ?? 0;
-  }
-  /**
-   * Get the unique identifier of the map
-   * 
-   * @returns The map ID, or empty string if not loaded
-   * 
-   * @example
-   * ```ts
-   * const mapId = map.id;
-   * console.log(`Current map: ${mapId}`);
-   * ```
-   */
-  get id() {
-    return this.data()?.id ?? "";
-  }
-  /**
-   * Get the X position of this map in the world coordinate system
-   * 
-   * This is used when maps are part of a larger world map. The world position
-   * indicates where this map is located relative to other maps.
-   * 
-   * @returns The X position in world coordinates, or 0 if not in a world
-   * 
-   * @example
-   * ```ts
-   * const worldX = map.worldX;
-   * console.log(`Map is at world position (${worldX}, ${map.worldY})`);
-   * ```
-   */
-  get worldX() {
-    const worldMaps = this.getWorldMapsManager?.();
-    return worldMaps?.getMapInfo(this.id)?.worldX ?? 0;
-  }
-  /**
-   * Get the Y position of this map in the world coordinate system
-   * 
-   * This is used when maps are part of a larger world map. The world position
-   * indicates where this map is located relative to other maps.
-   * 
-   * @returns The Y position in world coordinates, or 0 if not in a world
-   * 
-   * @example
-   * ```ts
-   * const worldY = map.worldY;
-   * console.log(`Map is at world position (${map.worldX}, ${worldY})`);
-   * ```
-   */
-  get worldY() {
-    const worldMaps = this.getWorldMapsManager?.();
-    return worldMaps?.getMapInfo(this.id)?.worldY ?? 0;
-  }
   guiInteraction(player, value) {
+    this.hooks.callHooks("server-player-guiInteraction", player, value);
     player.syncChanges();
   }
   guiExit(player, { guiId, data }) {
@@ -24804,6 +24998,7 @@ let RpgMap = class extends RpgCommonMap {
     };
     await lastValueFrom(this.hooks.callHooks("server-maps-load", this));
     await lastValueFrom(this.hooks.callHooks("server-worldMaps-load", this));
+    await lastValueFrom(this.hooks.callHooks("server-databaseHooks-load", this));
     map.events = map.events ?? [];
     if (map.id) {
       const mapFound = this.maps.find((m) => m.id === map.id);
@@ -25151,8 +25346,7 @@ let RpgMap = class extends RpgCommonMap {
   /**
    * Add data to the map's database
    * 
-   * This method allows you to dynamically add items, classes, or any data to the map's database.
-   * By default, if an ID already exists, the operation is ignored to prevent overwriting existing data.
+   * This method delegates to BaseRoom's implementation to avoid code duplication.
    * 
    * @param id - Unique identifier for the data
    * @param data - The data to store (can be a class, object, or any value)
@@ -25176,17 +25370,12 @@ let RpgMap = class extends RpgCommonMap {
    * ```
    */
   addInDatabase(id, data, options) {
-    const database = this.database();
-    if (database[id] !== void 0 && !options?.force) {
-      return false;
-    }
-    database[id] = data;
-    return true;
+    return BaseRoom.prototype.addInDatabase.call(this, id, data, options);
   }
   /**
    * Remove data from the map's database
    * 
-   * This method allows you to remove items or data from the map's database.
+   * This method delegates to BaseRoom's implementation to avoid code duplication.
    * 
    * @param id - Unique identifier of the data to remove
    * @returns true if data was removed, false if ID didn't exist
@@ -25204,12 +25393,7 @@ let RpgMap = class extends RpgCommonMap {
    * ```
    */
   removeInDatabase(id) {
-    const database = this.database();
-    if (database[id] === void 0) {
-      return false;
-    }
-    delete database[id];
-    return true;
+    return BaseRoom.prototype.removeInDatabase.call(this, id);
   }
   /**
    * Creates a dynamic event on the map
@@ -25577,6 +25761,19 @@ let RpgMap = class extends RpgCommonMap {
       }, holder);
     }
   }
+  /**
+   * Apply sync to the client
+   * 
+   * This method applies sync to the client by calling the `$applySync()` method.
+   * 
+   * @example
+   * ```ts
+   * map.applySyncToClient();
+   * ```
+   */
+  applySyncToClient() {
+    this.$applySync();
+  }
   /**
    * Create a shape dynamically on the map
    * 
@@ -25983,9 +26180,15 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
-let LobbyRoom = class {
-  constructor() {
+let LobbyRoom = class extends BaseRoom {
+  constructor(room) {
+    super();
     this.players = signal({});
+    this.autoSync = true;
+    const isTest = room.env.TEST === "true" ? true : false;
+    if (isTest) {
+      this.autoSync = false;
+    }
   }
   onJoin(player, conn) {
     player.map = this;
@@ -26338,6 +26541,19 @@ function provideServerModules(modules) {
           }
         };
       }
+      if (module.database && typeof module.database === "object") {
+        const database = { ...module.database };
+        module = {
+          ...module,
+          databaseHooks: {
+            load: (engine) => {
+              for (const key in database) {
+                engine.addInDatabase(key, database[key]);
+              }
+            }
+          }
+        };
+      }
       return module;
     });
     return modules2;