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

package/dist/index.js

@@ -5608,13 +5608,13 @@ function fromIterable(iterable) {
 }
 function fromAsyncIterable(asyncIterable) {
     return new Observable(function (subscriber) {
-        process$1(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
+        process$2(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
     });
 }
 function fromReadableStreamLike(readableStream) {
     return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
 }
-function process$1(asyncIterable, subscriber) {
+function process$2(asyncIterable, subscriber) {
     var asyncIterable_1, asyncIterable_1_1;
     var e_2, _a;
     return __awaiter(this, void 0, void 0, function () {
@@ -6065,7 +6065,7 @@ function toArray() {
     });
 }
 
-function finalize(callback) {
+function finalize$1(callback) {
     return operate(function (source, subscriber) {
         try {
             source.subscribe(subscriber);
@@ -6517,7 +6517,7 @@ function computed(computeFunction, disposableFn) {
     }
     return dep.observable;
   });
-  const computedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
+  const computedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => computeFunction()), finalize$1(() => disposableFn?.()));
   const fn = /* @__PURE__ */ __name$2(function() {
     trackDependency(fn);
     return lastComputedValue;
@@ -7743,12 +7743,46 @@ var Server = class {
       load(instance, tmpObject, true);
     }, "loadMemory");
     instance.$memoryAll = {};
+    instance.$autoSync = instance["autoSync"] !== false;
+    instance.$pendingSync = /* @__PURE__ */ new Map();
+    instance.$pendingInitialSync = /* @__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;
+      }
+      const pendingConnections = new Set(instance.$pendingInitialSync.keys());
+      for (const [conn, publicId] of instance.$pendingInitialSync) {
+        this.send(conn, {
+          type: "sync",
+          value: {
+            pId: publicId,
+            ...packet
+          }
+        }, instance);
+      }
+      instance.$pendingInitialSync.clear();
+      for (const conn of this.room.getConnections()) {
+        if (!pendingConnections.has(conn)) {
+          this.send(conn, {
+            type: "sync",
+            value: packet
+          }, instance);
+        }
+      }
+    };
     instance.$sessionTransfer = async (conn, targetRoomId) => {
       let user;
       const signal2 = this.getUsersProperty(instance);
@@ -7815,6 +7849,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 +7880,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 +8091,17 @@ 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);
+    } else {
+      subRoom.$pendingInitialSync.set(conn, publicId);
+    }
   }
   /**
   * @method onConnect
@@ -8340,6 +8386,9 @@ var Server = class {
     if (!subRoom) {
       return;
     }
+    if (subRoom.$pendingInitialSync) {
+      subRoom.$pendingInitialSync.delete(conn);
+    }
     const signal2 = this.getUsersProperty(subRoom);
     if (!conn.state) {
       return;
@@ -9777,10 +9826,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) ?? (() => {
     });
   }
 }
@@ -9934,6 +9983,9 @@ __decorateClass$3([
 __decorateClass$3([
   sync()
 ], RpgCommonPlayer.prototype, "_gold");
+__decorateClass$3([
+  sync()
+], RpgCommonPlayer.prototype, "animationName");
 __decorateClass$3([
   sync()
 ], RpgCommonPlayer.prototype, "hpSignal");
@@ -15236,29 +15288,6 @@ class Knockback {
   }
 }
 
-class LinearMove {
-  /**
-   * Creates a linear movement strategy.
-   *
-   * @param velocity - Velocity to apply (units per second)
-   * @param duration - Optional duration in seconds (undefined for infinite)
-   */
-  constructor(velocity, duration) {
-    this.velocity = velocity;
-    this.duration = duration;
-    this.elapsed = 0;
-  }
-  update(body, dt) {
-    if (this.duration !== void 0) {
-      this.elapsed += dt;
-    }
-    body.setVelocity(this.velocity);
-  }
-  isFinished() {
-    return this.duration !== void 0 && this.elapsed >= this.duration;
-  }
-}
-
 class LinearRepulsion {
   /**
    * @param engine - Physics engine used for spatial queries
@@ -15777,8 +15806,17 @@ 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;
+    /**
+     * Whether to automatically subscribe to tick$ for physics updates
+     * Set to false in test environments for manual control with nextTick()
+     */
+    this.autoTickEnabled = true;
     /**
      * Observable representing the game loop tick
      * 
@@ -15831,6 +15869,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
    * 
@@ -15930,9 +16050,11 @@ class RpgCommonMap {
         this.updateCharacterHitbox(event);
       }
     });
-    this.tickSubscription = this.tick$.subscribe(({ delta }) => {
-      this.runFixedTicks(delta);
-    });
+    if (this.autoTickEnabled) {
+      this.tickSubscription = this.tick$.subscribe(({ delta }) => {
+        this.runFixedTicks(delta);
+      });
+    }
   }
   async movePlayer(player, direction) {
     const currentX = player.x();
@@ -15954,12 +16076,8 @@ class RpgCommonMap {
         nextY = currentY + speed;
         break;
     }
-    if (typeof player.setIntendedDirection === "function") {
-      player.setIntendedDirection(direction);
-    } else if (typeof player.changeDirection === "function") {
-      player.changeDirection(direction);
-    }
-    if (typeof player.autoChangeMap === "function") {
+    player.changeDirection(direction);
+    if (typeof player.autoChangeMap === "function" && !player.isEvent()) {
       const mapChanged = await player.autoChangeMap({ x: nextX, y: nextY }, direction);
       if (mapChanged) {
         this.stopMovement(player);
@@ -16043,6 +16161,46 @@ class RpgCommonMap {
     }
     return executed;
   }
+  /**
+   * Manually trigger a single game tick
+   * 
+   * This method allows you to manually advance the game by one tick (16ms at 60fps).
+   * It's primarily useful for testing where you need precise control over when
+   * physics updates occur, rather than relying on the automatic tick$ subscription.
+   * 
+   * ## Use Cases
+   * 
+   * - **Testing**: Control exactly when physics steps occur in unit tests
+   * - **Manual control**: Step through game state manually for debugging
+   * - **Deterministic testing**: Ensure consistent timing in test scenarios
+   * 
+   * ## Important
+   * 
+   * This method should NOT be used in production code alongside the automatic `tick$`
+   * subscription, as it will cause double-stepping. Use either:
+   * - Automatic ticks (via `loadPhysic()` which subscribes to `tick$`)
+   * - Manual ticks (via `nextTick()` without `loadPhysic()` subscription)
+   * 
+   * @param deltaMs - Optional delta time in milliseconds (default: 16ms for 60fps)
+   * @returns Number of physics ticks executed
+   * 
+   * @example
+   * ```ts
+   * // In tests: manually advance game by one tick
+   * map.nextTick(); // Advances by 16ms (one frame at 60fps)
+   * 
+   * // With custom delta
+   * map.nextTick(32); // Advances by 32ms (two frames at 60fps)
+   * 
+   * // In a test loop
+   * for (let i = 0; i < 60; i++) {
+   *   map.nextTick(); // Simulate 1 second of game time
+   * }
+   * ```
+   */
+  nextTick(deltaMs = 16) {
+    return this.runFixedTicks(deltaMs);
+  }
   /**
    * Force a single physics tick outside of the normal game loop
    * 
@@ -16092,19 +16250,12 @@ class RpgCommonMap {
     const hitbox = typeof owner.hitbox === "function" ? owner.hitbox() : owner.hitbox;
     const width = hitbox?.w ?? 32;
     const height = hitbox?.h ?? 32;
-    const topLeftX = this.resolveNumeric(owner.x);
-    const topLeftY = this.resolveNumeric(owner.y);
-    const centerX = topLeftX + width / 2;
-    const centerY = topLeftY + height / 2;
     const radius = Math.max(width, height) / 2;
-    const speedValue = typeof owner.speed === "function" ? owner.speed() : typeof owner.speed === "number" ? owner.speed : void 0;
     this.addCharacter({
       owner,
-      x: centerX,
-      y: centerY,
       radius,
       kind,
-      maxSpeed: speedValue,
+      maxSpeed: owner.speed(),
       collidesWithCharacters: !this.shouldDisableCharacterCollisions(owner),
       isStatic: options?.isStatic,
       mass: options?.mass
@@ -16476,11 +16627,24 @@ class RpgCommonMap {
       owner2.changeDirection(cardinalDirection);
     });
     entity.onMovementChange(({ isMoving, intensity }) => {
+      const owner2 = entity.owner;
+      if (!owner2) return;
       const LOW_INTENSITY_THRESHOLD = 10;
+      const hasSetAnimation = typeof owner2.setAnimation === "function";
+      const animationNameSignal = owner2.animationName;
+      const ownerHasAnimationName = animationNameSignal && typeof animationNameSignal === "object" && typeof animationNameSignal.set === "function";
       if (isMoving && intensity > LOW_INTENSITY_THRESHOLD) {
-        owner.animationName.set("walk");
+        if (hasSetAnimation) {
+          owner2.setAnimation("walk");
+        } else if (ownerHasAnimationName) {
+          animationNameSignal.set("walk");
+        }
       } else if (!isMoving) {
-        owner.animationName.set("stand");
+        if (hasSetAnimation) {
+          owner2.setAnimation("stand");
+        } else if (ownerHasAnimationName) {
+          animationNameSignal.set("stand");
+        }
       }
     });
     const entityWidth = width;
@@ -16555,10 +16719,7 @@ class RpgCommonMap {
   moveBody(player, direction) {
     const entity = this.physic.getEntityByUUID(player.id);
     if (!entity) return false;
-    const speedValue = typeof player.speed === "function" ? Number(player.speed()) : 0;
-    if (typeof player.setIntendedDirection === "function") {
-      player.setIntendedDirection(direction);
-    }
+    const speedValue = player.speed();
     let vx = 0, vy = 0;
     switch (direction) {
       case Direction.Left:
@@ -16610,9 +16771,6 @@ class RpgCommonMap {
     const entity = this.physic.getEntityByUUID(player.id);
     if (!entity) return false;
     this.moveManager.stopMovement(player.id);
-    if (typeof player.setIntendedDirection === "function") {
-      player.setIntendedDirection(null);
-    }
     player.pendingInputs = [];
     return true;
   }
@@ -16922,17 +17080,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 +17100,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 +17108,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;
@@ -17193,6 +17353,204 @@ var PrebuiltGui = /* @__PURE__ */ ((PrebuiltGui2) => {
   return PrebuiltGui2;
 })(PrebuiltGui || {});
 
+class PerlinNoise2D {
+  /**
+   * Creates a new Perlin noise generator
+   * 
+   * @param seed - Optional seed for deterministic noise generation. If not provided, uses a default seed.
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D(12345);
+   * const value = noise.get(10, 20);
+   * ```
+   */
+  constructor(seed = 0) {
+    this.permutation = this.generatePermutation(seed);
+    this.p = [...this.permutation, ...this.permutation];
+  }
+  /**
+   * Generates a permutation table based on seed
+   * 
+   * @param seed - Seed value for permutation generation
+   * @returns Array of 256 shuffled values
+   */
+  generatePermutation(seed) {
+    const p = [];
+    for (let i = 0; i < 256; i++) {
+      p[i] = i;
+    }
+    let state = seed;
+    const lcg = () => {
+      state = state * 1103515245 + 12345 & 2147483647;
+      return state;
+    };
+    for (let i = 255; i > 0; i--) {
+      const j = lcg() % (i + 1);
+      [p[i], p[j]] = [p[j], p[i]];
+    }
+    return p;
+  }
+  /**
+   * Fade function for smooth interpolation (ease curve)
+   * 
+   * @param t - Value between 0 and 1
+   * @returns Smoothed value between 0 and 1
+   */
+  fade(t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+  /**
+   * Linear interpolation
+   * 
+   * @param a - Start value
+   * @param b - End value
+   * @param t - Interpolation factor (0 to 1)
+   * @returns Interpolated value
+   */
+  lerp(a, b, t) {
+    return a + t * (b - a);
+  }
+  /**
+   * Gradient function - generates a pseudo-random gradient vector
+   * 
+   * @param hash - Hash value from permutation table
+   * @param x - X component
+   * @param y - Y component
+   * @returns Dot product of gradient and position
+   */
+  grad(hash, x, y) {
+    const h = hash & 3;
+    switch (h) {
+      case 0:
+        return x + y;
+      // (1, 1)
+      case 1:
+        return -x + y;
+      // (-1, 1)
+      case 2:
+        return x - y;
+      // (1, -1)
+      case 3:
+        return -x - y;
+      // (-1, -1)
+      default:
+        return 0;
+    }
+  }
+  /**
+   * Gets the noise value at the specified 2D coordinates
+   * 
+   * Returns a value between approximately -1 and 1, though values near the edges
+   * are less common. For practical use, you may want to clamp or normalize the result.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param scale - Optional scale factor (default: 0.1). Lower values create smoother, larger patterns.
+   * @returns Noise value between approximately -1 and 1
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const value = noise.get(10, 20); // Basic usage
+   * const scaled = noise.get(10, 20, 0.05); // Smoother pattern
+   * ```
+   */
+  get(x, y, scale = 0.1) {
+    x *= scale;
+    y *= scale;
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    x -= Math.floor(x);
+    y -= Math.floor(y);
+    const u = this.fade(x);
+    const v = this.fade(y);
+    const A = this.p[X] + Y;
+    const AA = this.p[A];
+    const AB = this.p[A + 1];
+    const B = this.p[X + 1] + Y;
+    const BA = this.p[B];
+    const BB = this.p[B + 1];
+    return this.lerp(
+      this.lerp(
+        this.grad(this.p[AA], x, y),
+        this.grad(this.p[BA], x - 1, y),
+        u
+      ),
+      this.lerp(
+        this.grad(this.p[AB], x, y - 1),
+        this.grad(this.p[BB], x - 1, y - 1),
+        u
+      ),
+      v
+    );
+  }
+  /**
+   * Gets a normalized noise value between 0 and 1
+   * 
+   * Convenience method that normalizes the noise output to a 0-1 range.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param scale - Optional scale factor (default: 0.1)
+   * @returns Noise value between 0 and 1
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const normalized = noise.getNormalized(10, 20);
+   * // Returns value between 0 and 1
+   * ```
+   */
+  getNormalized(x, y, scale = 0.1) {
+    return (this.get(x, y, scale) + 1) * 0.5;
+  }
+  /**
+   * Gets a noise value mapped to a specific range
+   * 
+   * Maps the noise output to a custom min-max range.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param min - Minimum output value
+   * @param max - Maximum output value
+   * @param scale - Optional scale factor (default: 0.1)
+   * @returns Noise value between min and max
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const direction = noise.getRange(10, 20, 0, 3); // Returns 0, 1, 2, or 3
+   * ```
+   */
+  getRange(x, y, min, max, scale = 0.1) {
+    const normalized = this.getNormalized(x, y, scale);
+    return min + normalized * (max - min);
+  }
+  /**
+   * Gets an integer noise value in a specific range (inclusive)
+   * 
+   * Useful for selecting discrete values like array indices or enum values.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param min - Minimum integer value (inclusive)
+   * @param max - Maximum integer value (inclusive)
+   * @param scale - Optional scale factor (default: 0.1)
+   * @returns Integer noise value between min and max (inclusive)
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const directionIndex = noise.getInt(10, 20, 0, 3); // Returns 0, 1, 2, or 3
+   * ```
+   */
+  getInt(x, y, min, max, scale = 0.1) {
+    const value = this.getRange(x, y, min, max + 1, scale);
+    return Math.floor(value);
+  }
+}
+
 function WithComponentManager(Base) {
   return class extends Base {
     setGraphic(graphic) {
@@ -17900,6 +18258,63 @@ var Speed = /* @__PURE__ */ ((Speed2) => {
   return Speed2;
 })(Speed || {});
 class MoveList {
+  static {
+    // Shared Perlin noise instance for smooth random movement
+    this.perlinNoise = new PerlinNoise2D();
+  }
+  static {
+    this.randomCounter = 0;
+  }
+  static {
+    // Instance counter for each call to ensure variation
+    this.callCounter = 0;
+  }
+  /**
+   * Gets a random direction index (0-3) using a hybrid approach for balanced randomness
+   * 
+   * Uses a combination of hash-based pseudo-randomness and Perlin noise to ensure
+   * fair distribution of directions while maintaining smooth, natural-looking movement patterns.
+   * The hash function guarantees uniform distribution, while Perlin noise adds spatial/temporal coherence.
+   * 
+   * @param player - Optional player instance for coordinate-based noise
+   * @param index - Optional index for array-based calls to ensure variation
+   * @returns Direction index (0-3) corresponding to Right, Left, Up, Down
+   */
+  getRandomDirectionIndex(player, index) {
+    MoveList.callCounter++;
+    let seed;
+    const time = Date.now() * 1e-3;
+    if (player) {
+      const playerX = typeof player.x === "function" ? player.x() : player.x;
+      const playerY = typeof player.y === "function" ? player.y() : player.y;
+      seed = Math.floor(
+        playerX * 0.1 + playerY * 0.1 + time * 1e3 + MoveList.callCounter * 17 + (index ?? 0) * 31
+      );
+    } else {
+      MoveList.randomCounter++;
+      seed = Math.floor(
+        MoveList.randomCounter * 17 + time * 1e3 + MoveList.callCounter * 31 + (index ?? 0) * 47
+      );
+    }
+    let hash1 = (seed * 1103515245 + 12345 & 2147483647) >>> 0;
+    let hash2 = seed * 2654435761 >>> 0;
+    let hash3 = seed ^ seed >>> 16;
+    hash3 = hash3 * 2246822507 >>> 0;
+    let combinedHash = (hash1 ^ hash2 ^ hash3) >>> 0;
+    const hashValue = combinedHash % 1e6 / 1e6;
+    const perlinX = seed * 1e-3;
+    const perlinY = seed * 1.618 * 1e-3;
+    const perlinValue = MoveList.perlinNoise.getNormalized(perlinX, perlinY, 0.3);
+    const finalValue = hashValue * 0.9 + perlinValue * 0.1;
+    const clampedValue = Math.max(0, Math.min(0.999999, finalValue));
+    let directionIndex = Math.floor(clampedValue * 4);
+    directionIndex = Math.max(0, Math.min(3, directionIndex));
+    if (!Number.isFinite(directionIndex) || directionIndex < 0 || directionIndex > 3) {
+      const fallbackIndex = Math.floor(hashValue * 4) % 4;
+      return Math.max(0, Math.min(3, fallbackIndex));
+    }
+    return directionIndex;
+  }
   repeatMove(direction, repeat) {
     if (!Number.isFinite(repeat) || repeat < 0 || repeat > 1e4) {
       console.warn("Invalid repeat value:", repeat, "using default value 1");
@@ -17967,12 +18382,16 @@ class MoveList {
       repeat = 1;
     }
     try {
-      return new Array(repeat).fill(null).map(() => [
-        Direction.Right,
-        Direction.Left,
-        Direction.Up,
-        Direction.Down
-      ][random(0, 3)]);
+      MoveList.randomCounter += repeat;
+      return new Array(repeat).fill(null).map((_, index) => {
+        const directionIndex = this.getRandomDirectionIndex(void 0, index);
+        return [
+          Direction.Right,
+          Direction.Left,
+          Direction.Up,
+          Direction.Down
+        ][directionIndex];
+      });
     } catch (error) {
       console.error("Error creating random array with repeat:", repeat, error);
       return [Direction.Down];
@@ -17998,13 +18417,23 @@ class MoveList {
       }
       repeat = Math.floor(repeat);
       let directions = [];
+      const directionFunctions = [
+        this.tileRight(),
+        this.tileLeft(),
+        this.tileUp(),
+        this.tileDown()
+      ];
       for (let i = 0; i < repeat; i++) {
-        const randFn = [
-          this.tileRight(),
-          this.tileLeft(),
-          this.tileUp(),
-          this.tileDown()
-        ][random(0, 3)];
+        let directionIndex = this.getRandomDirectionIndex(player, i);
+        if (!Number.isInteger(directionIndex) || directionIndex < 0 || directionIndex > 3) {
+          console.warn("Invalid directionIndex in tileRandom:", directionIndex, "using fallback");
+          directionIndex = Math.floor(Math.random() * 4) % 4;
+        }
+        const randFn = directionFunctions[directionIndex];
+        if (typeof randFn !== "function") {
+          console.warn("randFn is not a function in tileRandom, skipping iteration");
+          continue;
+        }
         try {
           const newDirections = randFn(player, map);
           if (Array.isArray(newDirections)) {
@@ -18114,12 +18543,13 @@ class MoveList {
     return "turn-" + Direction.Down;
   }
   turnRandom() {
+    const directionIndex = this.getRandomDirectionIndex();
     return [
       this.turnRight(),
       this.turnLeft(),
       this.turnUp(),
       this.turnDown()
-    ][random(0, 3)];
+    ][directionIndex];
   }
   turnAwayFromPlayer(otherPlayer) {
     return (player) => {
@@ -18263,115 +18693,369 @@ function WithMoveManager(Base) {
       };
       this.addMovement(new ProjectileMovement(type, config));
     }
-    moveRoutes(routes) {
-      let count = 0;
-      let frequence = 0;
+    moveRoutes(routes, options) {
       const player = this;
       this.clearMovements();
       return new Promise(async (resolve) => {
         this._finishRoute = resolve;
-        const processedRoutes = routes.map((route) => {
-          if (typeof route === "function") {
-            const map = player.getCurrentMap();
-            if (!map) {
-              return void 0;
+        const processedRoutes = await Promise.all(
+          routes.map(async (route) => {
+            if (typeof route === "function") {
+              const map = player.getCurrentMap();
+              if (!map) {
+                return void 0;
+              }
+              return route.apply(route, [player, map]);
             }
-            return route.apply(route, [player, map]);
-          }
-          return route;
-        });
-        const flatRoutes = this.flattenRoutes(processedRoutes);
-        let routeIndex = 0;
-        const executeNextRoute = async () => {
-          if (!player || !player.getCurrentMap()) {
-            this._finishRoute = null;
-            resolve(false);
-            return;
+            return route;
+          })
+        );
+        const finalRoutes = this.flattenRoutes(processedRoutes);
+        class RouteMovementStrategy {
+          constructor(routes2, player2, onComplete, options2) {
+            this.routeIndex = 0;
+            this.currentTarget = null;
+            // Center position for physics
+            this.currentTargetTopLeft = null;
+            // Top-left position for player.x() comparison
+            this.currentDirection = { x: 0, y: 0 };
+            this.finished = false;
+            this.waitingForPromise = false;
+            this.promiseStartTime = 0;
+            this.promiseDuration = 0;
+            // Frequency wait state
+            this.waitingForFrequency = false;
+            this.frequencyWaitStartTime = 0;
+            this.ratioFrequency = 15;
+            // Stuck detection state
+            this.lastPosition = null;
+            this.lastPositionTime = 0;
+            this.stuckCheckStartTime = 0;
+            this.lastDistanceToTarget = null;
+            this.isCurrentlyStuck = false;
+            this.stuckCheckInitialized = false;
+            this.routes = routes2;
+            this.player = player2;
+            this.onComplete = onComplete;
+            this.tileSize = player2.nbPixelInTile || 32;
+            this.tolerance = 0.5;
+            this.onStuck = options2?.onStuck;
+            this.stuckTimeout = options2?.stuckTimeout ?? 500;
+            this.stuckThreshold = options2?.stuckThreshold ?? 1;
+            this.processNextRoute();
           }
-          if (count >= (player.nbPixelInTile || 32)) {
-            if (frequence < (player.frequency || 0)) {
-              frequence++;
-              setTimeout(executeNextRoute, 16);
+          processNextRoute() {
+            this.waitingForFrequency = false;
+            this.frequencyWaitStartTime = 0;
+            if (this.routeIndex >= this.routes.length) {
+              this.finished = true;
+              this.onComplete(true);
               return;
             }
-          }
-          frequence = 0;
-          count++;
-          if (routeIndex >= flatRoutes.length) {
-            this._finishRoute = null;
-            resolve(true);
-            return;
-          }
-          const currentRoute = flatRoutes[routeIndex];
-          routeIndex++;
-          if (currentRoute === void 0) {
-            executeNextRoute();
-            return;
-          }
-          try {
-            if (typeof currentRoute === "object" && "then" in currentRoute) {
-              await currentRoute;
-              executeNextRoute();
-            } else if (typeof currentRoute === "string" && currentRoute.startsWith("turn-")) {
-              const directionStr = currentRoute.replace("turn-", "");
-              let direction = Direction.Down;
-              switch (directionStr) {
-                case "up":
-                case Direction.Up:
-                  direction = Direction.Up;
-                  break;
-                case "down":
-                case Direction.Down:
-                  direction = Direction.Down;
-                  break;
-                case "left":
-                case Direction.Left:
-                  direction = Direction.Left;
-                  break;
-                case "right":
-                case Direction.Right:
-                  direction = Direction.Right;
-                  break;
-              }
-              if (player.changeDirection) {
-                player.changeDirection(direction);
-              }
-              executeNextRoute();
-            } else if (typeof currentRoute === "number") {
-              if (player.moveByDirection) {
-                await player.moveByDirection(currentRoute, 1);
-              } else {
-                let vx = 0, vy = 0;
-                const direction = currentRoute;
-                switch (direction) {
+            const currentRoute = this.routes[this.routeIndex];
+            this.routeIndex++;
+            if (currentRoute === void 0) {
+              this.processNextRoute();
+              return;
+            }
+            try {
+              if (typeof currentRoute === "object" && "then" in currentRoute) {
+                this.waitingForPromise = true;
+                this.promiseStartTime = Date.now();
+                this.promiseDuration = 1e3;
+                currentRoute.then(() => {
+                  this.waitingForPromise = false;
+                  this.processNextRoute();
+                }).catch(() => {
+                  this.waitingForPromise = false;
+                  this.processNextRoute();
+                });
+              } else if (typeof currentRoute === "string" && currentRoute.startsWith("turn-")) {
+                const directionStr = currentRoute.replace("turn-", "");
+                let direction = Direction.Down;
+                switch (directionStr) {
+                  case "up":
+                  case Direction.Up:
+                    direction = Direction.Up;
+                    break;
+                  case "down":
+                  case Direction.Down:
+                    direction = Direction.Down;
+                    break;
+                  case "left":
+                  case Direction.Left:
+                    direction = Direction.Left;
+                    break;
+                  case "right":
+                  case Direction.Right:
+                    direction = Direction.Right;
+                    break;
+                }
+                if (this.player.changeDirection) {
+                  this.player.changeDirection(direction);
+                }
+                this.processNextRoute();
+              } else if (typeof currentRoute === "number" || typeof currentRoute === "string") {
+                const moveDirection = currentRoute;
+                const map = this.player.getCurrentMap();
+                if (!map) {
+                  this.finished = true;
+                  this.onComplete(false);
+                  return;
+                }
+                const currentTopLeftX = typeof this.player.x === "function" ? this.player.x() : this.player.x;
+                const currentTopLeftY = typeof this.player.y === "function" ? this.player.y() : this.player.y;
+                let playerSpeed = this.player.speed();
+                let distance = playerSpeed;
+                const initialDistance = distance;
+                const initialRouteIndex = this.routeIndex;
+                while (this.routeIndex < this.routes.length) {
+                  const nextRoute = this.routes[this.routeIndex];
+                  if (nextRoute === currentRoute) {
+                    distance += playerSpeed;
+                    this.routeIndex++;
+                  } else {
+                    break;
+                  }
+                }
+                let targetTopLeftX = currentTopLeftX;
+                let targetTopLeftY = currentTopLeftY;
+                switch (moveDirection) {
                   case Direction.Right:
-                    vx = 1;
+                  case "right":
+                    targetTopLeftX = currentTopLeftX + distance;
                     break;
                   case Direction.Left:
-                    vx = -1;
+                  case "left":
+                    targetTopLeftX = currentTopLeftX - distance;
                     break;
                   case Direction.Down:
-                    vy = 1;
+                  case "down":
+                    targetTopLeftY = currentTopLeftY + distance;
                     break;
                   case Direction.Up:
-                    vy = -1;
+                  case "up":
+                    targetTopLeftY = currentTopLeftY - distance;
                     break;
                 }
-                const speed = player.speed?.() ?? 3;
-                this.addMovement(new LinearMove({ x: vx * speed, y: vy * speed }, 0.1));
-                setTimeout(executeNextRoute, 100);
+                const entity = map.physic.getEntityByUUID(this.player.id);
+                if (!entity) {
+                  this.finished = true;
+                  this.onComplete(false);
+                  return;
+                }
+                const hitbox = this.player.hitbox();
+                const hitboxWidth = hitbox?.w ?? 32;
+                const hitboxHeight = hitbox?.h ?? 32;
+                const targetX = targetTopLeftX + hitboxWidth / 2;
+                const targetY = targetTopLeftY + hitboxHeight / 2;
+                this.currentTarget = { x: targetX, y: targetY };
+                this.currentTargetTopLeft = { x: targetTopLeftX, y: targetTopLeftY };
+                this.currentDirection = { x: 0, y: 0 };
+                this.lastPosition = null;
+                this.isCurrentlyStuck = false;
+                this.stuckCheckStartTime = 0;
+                this.lastDistanceToTarget = null;
+                this.stuckCheckInitialized = false;
+                this.waitingForFrequency = false;
+                this.frequencyWaitStartTime = 0;
+              } else if (Array.isArray(currentRoute)) {
+                for (let i = currentRoute.length - 1; i >= 0; i--) {
+                  this.routes.splice(this.routeIndex, 0, currentRoute[i]);
+                }
+                this.processNextRoute();
+              } else {
+                this.processNextRoute();
+              }
+            } catch (error) {
+              console.warn("Error processing route:", error);
+              this.processNextRoute();
+            }
+          }
+          update(body, dt) {
+            if (this.waitingForPromise) {
+              body.setVelocity({ x: 0, y: 0 });
+              if (Date.now() - this.promiseStartTime > this.promiseDuration) {
+                this.waitingForPromise = false;
+                this.processNextRoute();
+              }
+              return;
+            }
+            if (this.waitingForFrequency) {
+              body.setVelocity({ x: 0, y: 0 });
+              const playerFrequency = this.player.frequency;
+              const frequencyMs = playerFrequency || 0;
+              if (frequencyMs > 0 && Date.now() - this.frequencyWaitStartTime >= frequencyMs * this.ratioFrequency) {
+                this.waitingForFrequency = false;
+                this.processNextRoute();
+              }
+              return;
+            }
+            if (!this.currentTarget) {
+              if (!this.finished) {
+                this.processNextRoute();
+              }
+              if (!this.currentTarget) {
+                body.setVelocity({ x: 0, y: 0 });
+                this.lastPosition = null;
+                this.isCurrentlyStuck = false;
+                this.lastDistanceToTarget = null;
+                this.stuckCheckInitialized = false;
+                this.currentTargetTopLeft = null;
+                return;
+              }
+            }
+            const entity = body.getEntity?.();
+            if (!entity) {
+              this.finished = true;
+              this.onComplete(false);
+              return;
+            }
+            const currentPosition = { x: entity.position.x, y: entity.position.y };
+            const currentTime = Date.now();
+            const currentTopLeftX = this.player.x();
+            const currentTopLeftY = this.player.y();
+            let dx, dy, distance;
+            if (this.currentTargetTopLeft) {
+              dx = this.currentTargetTopLeft.x - currentTopLeftX;
+              dy = this.currentTargetTopLeft.y - currentTopLeftY;
+              distance = Math.hypot(dx, dy);
+              if (distance <= this.tolerance) {
+                this.currentTarget = null;
+                this.currentTargetTopLeft = null;
+                this.currentDirection = { x: 0, y: 0 };
+                body.setVelocity({ x: 0, y: 0 });
+                this.lastPosition = null;
+                this.isCurrentlyStuck = false;
+                this.lastDistanceToTarget = null;
+                this.stuckCheckInitialized = false;
+                if (!this.finished) {
+                  const playerFrequency = this.player.frequency;
+                  if (playerFrequency && playerFrequency > 0) {
+                    this.waitingForFrequency = true;
+                    this.frequencyWaitStartTime = Date.now();
+                  } else {
+                    this.processNextRoute();
+                  }
+                }
+                return;
+              }
+            } else {
+              dx = this.currentTarget.x - currentPosition.x;
+              dy = this.currentTarget.y - currentPosition.y;
+              distance = Math.hypot(dx, dy);
+              if (distance <= this.tolerance) {
+                this.currentTarget = null;
+                this.currentTargetTopLeft = null;
+                this.currentDirection = { x: 0, y: 0 };
+                body.setVelocity({ x: 0, y: 0 });
+                this.lastPosition = null;
+                this.isCurrentlyStuck = false;
+                this.lastDistanceToTarget = null;
+                this.stuckCheckInitialized = false;
+                if (!this.finished) {
+                  const playerFrequency = player.frequency;
+                  if (playerFrequency && playerFrequency > 0) {
+                    this.waitingForFrequency = true;
+                    this.frequencyWaitStartTime = Date.now();
+                  } else {
+                    this.processNextRoute();
+                  }
+                }
                 return;
               }
-              executeNextRoute();
+            }
+            if (this.onStuck && this.currentTarget) {
+              if (!this.stuckCheckInitialized) {
+                this.lastPosition = { ...currentPosition };
+                this.lastDistanceToTarget = distance;
+                this.stuckCheckInitialized = true;
+                this.lastPositionTime = currentTime;
+              } else if (this.lastPosition && this.lastDistanceToTarget !== null) {
+                const positionChanged = Math.hypot(
+                  currentPosition.x - this.lastPosition.x,
+                  currentPosition.y - this.lastPosition.y
+                ) > this.stuckThreshold;
+                const distanceImproved = distance < this.lastDistanceToTarget - this.stuckThreshold;
+                if (!positionChanged && !distanceImproved) {
+                  if (!this.isCurrentlyStuck) {
+                    this.stuckCheckStartTime = currentTime;
+                    this.isCurrentlyStuck = true;
+                  } else {
+                    if (currentTime - this.stuckCheckStartTime >= this.stuckTimeout) {
+                      const shouldContinue = this.onStuck(
+                        this.player,
+                        this.currentTarget,
+                        currentPosition
+                      );
+                      if (shouldContinue === false) {
+                        this.finished = true;
+                        this.onComplete(false);
+                        body.setVelocity({ x: 0, y: 0 });
+                        return;
+                      }
+                      this.isCurrentlyStuck = false;
+                      this.stuckCheckStartTime = 0;
+                      this.lastPosition = { ...currentPosition };
+                      this.lastDistanceToTarget = distance;
+                    }
+                  }
+                } else {
+                  this.isCurrentlyStuck = false;
+                  this.stuckCheckStartTime = 0;
+                }
+                this.lastPosition = { ...currentPosition };
+                this.lastPositionTime = currentTime;
+                this.lastDistanceToTarget = distance;
+              }
+            }
+            const map = this.player.getCurrentMap();
+            map?.speedScalar ?? 50;
+            if (distance > 0) {
+              this.currentDirection = { x: dx / distance, y: dy / distance };
             } else {
-              executeNextRoute();
+              this.currentTarget = null;
+              this.currentTargetTopLeft = null;
+              this.currentDirection = { x: 0, y: 0 };
+              body.setVelocity({ x: 0, y: 0 });
+              if (!this.finished) {
+                const playerFrequency = typeof this.player.frequency === "function" ? this.player.frequency() : this.player.frequency;
+                if (playerFrequency && playerFrequency > 0) {
+                  this.waitingForFrequency = true;
+                  this.frequencyWaitStartTime = Date.now();
+                } else {
+                  this.processNextRoute();
+                }
+              }
+              return;
             }
-          } catch (error) {
-            console.warn("Error executing route:", error);
-            executeNextRoute();
+            const absX = Math.abs(this.currentDirection.x);
+            const absY = Math.abs(this.currentDirection.y);
+            let cardinalDirection;
+            if (absX >= absY) {
+              cardinalDirection = this.currentDirection.x >= 0 ? Direction.Right : Direction.Left;
+            } else {
+              cardinalDirection = this.currentDirection.y >= 0 ? Direction.Down : Direction.Up;
+            }
+            map.movePlayer(this.player, cardinalDirection);
           }
-        };
-        executeNextRoute();
+          isFinished() {
+            return this.finished;
+          }
+          onFinished() {
+            this.onComplete(true);
+          }
+        }
+        const routeStrategy = new RouteMovementStrategy(
+          finalRoutes,
+          player,
+          (success) => {
+            this._finishRoute = null;
+            resolve(success);
+          },
+          options
+        );
+        this.addMovement(routeStrategy);
       });
     }
     flattenRoutes(routes) {
@@ -19361,8 +20045,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 +20055,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 +20083,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 +20182,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 +20213,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 +20674,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 +20723,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 +20783,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 +20835,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 +20894,19 @@ 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 });
+        const hitbox = typeof this.hitbox === "function" ? this.hitbox() : this.hitbox;
+        const width = hitbox?.w ?? 32;
+        const height = hitbox?.h ?? 32;
+        const centerX = positions.x + width / 2;
+        const centerY = positions.y + height / 2;
+        this.map.physic.teleport(entity, { x: centerX, y: centerY });
       }
-    } 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 +20988,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(
@@ -20804,6 +21542,9 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       }, this);
     }
   }
+  isEvent() {
+    return false;
+  }
 };
 __decorateClass$2([
   sync(_RpgPlayer)
@@ -20823,6 +21564,9 @@ class RpgEvent extends RpgPlayer {
     if (!map2) return;
     map2.removeEvent(this.id);
   }
+  isEvent() {
+    return true;
+  }
 }
 
 const context$1 = new Context();
@@ -21975,8 +22719,8 @@ class Doc {
 
 const version = {
     major: 4,
-    minor: 1,
-    patch: 13,
+    minor: 2,
+    patch: 0,
 };
 
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -22046,16 +22790,6 @@ const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
             }
             return payload;
         };
-        // const handleChecksResult = (
-        //   checkResult: ParsePayload,
-        //   originalResult: ParsePayload,
-        //   ctx: ParseContextInternal
-        // ): util.MaybeAsync<ParsePayload> => {
-        //   // if the checks mutated the value && there are no issues, re-parse the result
-        //   if (checkResult.value !== originalResult.value && !checkResult.issues.length)
-        //     return inst._zod.parse(checkResult, ctx);
-        //   return originalResult;
-        // };
         const handleCanaryResult = (canary, payload, ctx) => {
             // abort if the canary is aborted
             if (aborted(canary)) {
@@ -23666,6 +24400,656 @@ function _check(fn, params) {
     return ch;
 }
 
+// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
+//   return {
+//     processor: inputs.processor,
+//     metadataRegistry: inputs.metadata ?? globalRegistry,
+//     target: inputs.target ?? "draft-2020-12",
+//     unrepresentable: inputs.unrepresentable ?? "throw",
+//   };
+// }
+function initializeContext(params) {
+    // Normalize target: convert old non-hyphenated versions to hyphenated versions
+    let target = params?.target ?? "draft-2020-12";
+    if (target === "draft-4")
+        target = "draft-04";
+    if (target === "draft-7")
+        target = "draft-07";
+    return {
+        processors: params.processors ?? {},
+        metadataRegistry: params?.metadata ?? globalRegistry,
+        target,
+        unrepresentable: params?.unrepresentable ?? "throw",
+        override: params?.override ?? (() => { }),
+        io: params?.io ?? "output",
+        counter: 0,
+        seen: new Map(),
+        cycles: params?.cycles ?? "ref",
+        reused: params?.reused ?? "inline",
+        external: params?.external ?? undefined,
+    };
+}
+function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
+    var _a;
+    const def = schema._zod.def;
+    // check for schema in seens
+    const seen = ctx.seen.get(schema);
+    if (seen) {
+        seen.count++;
+        // check if cycle
+        const isCycle = _params.schemaPath.includes(schema);
+        if (isCycle) {
+            seen.cycle = _params.path;
+        }
+        return seen.schema;
+    }
+    // initialize
+    const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
+    ctx.seen.set(schema, result);
+    // custom method overrides default behavior
+    const overrideSchema = schema._zod.toJSONSchema?.();
+    if (overrideSchema) {
+        result.schema = overrideSchema;
+    }
+    else {
+        const params = {
+            ..._params,
+            schemaPath: [..._params.schemaPath, schema],
+            path: _params.path,
+        };
+        const parent = schema._zod.parent;
+        if (parent) {
+            // schema was cloned from another schema
+            result.ref = parent;
+            process$1(parent, ctx, params);
+            ctx.seen.get(parent).isParent = true;
+        }
+        else if (schema._zod.processJSONSchema) {
+            schema._zod.processJSONSchema(ctx, result.schema, params);
+        }
+        else {
+            const _json = result.schema;
+            const processor = ctx.processors[def.type];
+            if (!processor) {
+                throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+            }
+            processor(schema, ctx, _json, params);
+        }
+    }
+    // metadata
+    const meta = ctx.metadataRegistry.get(schema);
+    if (meta)
+        Object.assign(result.schema, meta);
+    if (ctx.io === "input" && isTransforming(schema)) {
+        // examples/defaults only apply to output type of pipe
+        delete result.schema.examples;
+        delete result.schema.default;
+    }
+    // set prefault as default
+    if (ctx.io === "input" && result.schema._prefault)
+        (_a = result.schema).default ?? (_a.default = result.schema._prefault);
+    delete result.schema._prefault;
+    // pulling fresh from ctx.seen in case it was overwritten
+    const _result = ctx.seen.get(schema);
+    return _result.schema;
+}
+function extractDefs(ctx, schema
+// params: EmitParams
+) {
+    // iterate over seen map;
+    const root = ctx.seen.get(schema);
+    if (!root)
+        throw new Error("Unprocessed schema. This is a bug in Zod.");
+    // returns a ref to the schema
+    // defId will be empty if the ref points to an external schema (or #)
+    const makeURI = (entry) => {
+        // comparing the seen objects because sometimes
+        // multiple schemas map to the same seen object.
+        // e.g. lazy
+        // external is configured
+        const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+        if (ctx.external) {
+            const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
+            // check if schema is in the external registry
+            const uriGenerator = ctx.external.uri ?? ((id) => id);
+            if (externalId) {
+                return { ref: uriGenerator(externalId) };
+            }
+            // otherwise, add to __shared
+            const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+            entry[1].defId = id; // set defId so it will be reused if needed
+            return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
+        }
+        if (entry[1] === root) {
+            return { ref: "#" };
+        }
+        // self-contained schema
+        const uriPrefix = `#`;
+        const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
+        const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+        return { defId, ref: defUriPrefix + defId };
+    };
+    // stored cached version in `def` property
+    // remove all properties, set $ref
+    const extractToDef = (entry) => {
+        // if the schema is already a reference, do not extract it
+        if (entry[1].schema.$ref) {
+            return;
+        }
+        const seen = entry[1];
+        const { ref, defId } = makeURI(entry);
+        seen.def = { ...seen.schema };
+        // defId won't be set if the schema is a reference to an external schema
+        // or if the schema is the root schema
+        if (defId)
+            seen.defId = defId;
+        // wipe away all properties except $ref
+        const schema = seen.schema;
+        for (const key in schema) {
+            delete schema[key];
+        }
+        schema.$ref = ref;
+    };
+    // throw on cycles
+    // break cycles
+    if (ctx.cycles === "throw") {
+        for (const entry of ctx.seen.entries()) {
+            const seen = entry[1];
+            if (seen.cycle) {
+                throw new Error("Cycle detected: " +
+                    `#/${seen.cycle?.join("/")}/<root>` +
+                    '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
+            }
+        }
+    }
+    // extract schemas into $defs
+    for (const entry of ctx.seen.entries()) {
+        const seen = entry[1];
+        // convert root schema to # $ref
+        if (schema === entry[0]) {
+            extractToDef(entry); // this has special handling for the root schema
+            continue;
+        }
+        // extract schemas that are in the external registry
+        if (ctx.external) {
+            const ext = ctx.external.registry.get(entry[0])?.id;
+            if (schema !== entry[0] && ext) {
+                extractToDef(entry);
+                continue;
+            }
+        }
+        // extract schemas with `id` meta
+        const id = ctx.metadataRegistry.get(entry[0])?.id;
+        if (id) {
+            extractToDef(entry);
+            continue;
+        }
+        // break cycles
+        if (seen.cycle) {
+            // any
+            extractToDef(entry);
+            continue;
+        }
+        // extract reused schemas
+        if (seen.count > 1) {
+            if (ctx.reused === "ref") {
+                extractToDef(entry);
+                // biome-ignore lint:
+                continue;
+            }
+        }
+    }
+}
+function finalize(ctx, schema) {
+    //
+    // iterate over seen map;
+    const root = ctx.seen.get(schema);
+    if (!root)
+        throw new Error("Unprocessed schema. This is a bug in Zod.");
+    // flatten _refs
+    const flattenRef = (zodSchema) => {
+        const seen = ctx.seen.get(zodSchema);
+        const schema = seen.def ?? seen.schema;
+        const _cached = { ...schema };
+        // already seen
+        if (seen.ref === null) {
+            return;
+        }
+        // flatten ref if defined
+        const ref = seen.ref;
+        seen.ref = null; // prevent recursion
+        if (ref) {
+            flattenRef(ref);
+            // merge referenced schema into current
+            const refSchema = ctx.seen.get(ref).schema;
+            if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+                schema.allOf = schema.allOf ?? [];
+                schema.allOf.push(refSchema);
+            }
+            else {
+                Object.assign(schema, refSchema);
+                Object.assign(schema, _cached); // prevent overwriting any fields in the original schema
+            }
+        }
+        // execute overrides
+        if (!seen.isParent)
+            ctx.override({
+                zodSchema: zodSchema,
+                jsonSchema: schema,
+                path: seen.path ?? [],
+            });
+    };
+    for (const entry of [...ctx.seen.entries()].reverse()) {
+        flattenRef(entry[0]);
+    }
+    const result = {};
+    if (ctx.target === "draft-2020-12") {
+        result.$schema = "https://json-schema.org/draft/2020-12/schema";
+    }
+    else if (ctx.target === "draft-07") {
+        result.$schema = "http://json-schema.org/draft-07/schema#";
+    }
+    else if (ctx.target === "draft-04") {
+        result.$schema = "http://json-schema.org/draft-04/schema#";
+    }
+    else if (ctx.target === "openapi-3.0") ;
+    else ;
+    if (ctx.external?.uri) {
+        const id = ctx.external.registry.get(schema)?.id;
+        if (!id)
+            throw new Error("Schema is missing an `id` property");
+        result.$id = ctx.external.uri(id);
+    }
+    Object.assign(result, root.def ?? root.schema);
+    // build defs object
+    const defs = ctx.external?.defs ?? {};
+    for (const entry of ctx.seen.entries()) {
+        const seen = entry[1];
+        if (seen.def && seen.defId) {
+            defs[seen.defId] = seen.def;
+        }
+    }
+    // set definitions in result
+    if (ctx.external) ;
+    else {
+        if (Object.keys(defs).length > 0) {
+            if (ctx.target === "draft-2020-12") {
+                result.$defs = defs;
+            }
+            else {
+                result.definitions = defs;
+            }
+        }
+    }
+    try {
+        // this "finalizes" this schema and ensures all cycles are removed
+        // each call to finalize() is functionally independent
+        // though the seen map is shared
+        const finalized = JSON.parse(JSON.stringify(result));
+        Object.defineProperty(finalized, "~standard", {
+            value: {
+                ...schema["~standard"],
+                jsonSchema: {
+                    input: createStandardJSONSchemaMethod(schema, "input"),
+                    output: createStandardJSONSchemaMethod(schema, "output"),
+                },
+            },
+            enumerable: false,
+            writable: false,
+        });
+        return finalized;
+    }
+    catch (_err) {
+        throw new Error("Error converting schema to JSON.");
+    }
+}
+function isTransforming(_schema, _ctx) {
+    const ctx = _ctx ?? { seen: new Set() };
+    if (ctx.seen.has(_schema))
+        return false;
+    ctx.seen.add(_schema);
+    const def = _schema._zod.def;
+    if (def.type === "transform")
+        return true;
+    if (def.type === "array")
+        return isTransforming(def.element, ctx);
+    if (def.type === "set")
+        return isTransforming(def.valueType, ctx);
+    if (def.type === "lazy")
+        return isTransforming(def.getter(), ctx);
+    if (def.type === "promise" ||
+        def.type === "optional" ||
+        def.type === "nonoptional" ||
+        def.type === "nullable" ||
+        def.type === "readonly" ||
+        def.type === "default" ||
+        def.type === "prefault") {
+        return isTransforming(def.innerType, ctx);
+    }
+    if (def.type === "intersection") {
+        return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    }
+    if (def.type === "record" || def.type === "map") {
+        return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    if (def.type === "pipe") {
+        return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
+    if (def.type === "object") {
+        for (const key in def.shape) {
+            if (isTransforming(def.shape[key], ctx))
+                return true;
+        }
+        return false;
+    }
+    if (def.type === "union") {
+        for (const option of def.options) {
+            if (isTransforming(option, ctx))
+                return true;
+        }
+        return false;
+    }
+    if (def.type === "tuple") {
+        for (const item of def.items) {
+            if (isTransforming(item, ctx))
+                return true;
+        }
+        if (def.rest && isTransforming(def.rest, ctx))
+            return true;
+        return false;
+    }
+    return false;
+}
+/**
+ * Creates a toJSONSchema method for a schema instance.
+ * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
+ */
+const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
+    const ctx = initializeContext({ ...params, processors });
+    process$1(schema, ctx);
+    extractDefs(ctx, schema);
+    return finalize(ctx, schema);
+};
+const createStandardJSONSchemaMethod = (schema, io) => (params) => {
+    const { libraryOptions, target } = params ?? {};
+    const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors: {} });
+    process$1(schema, ctx);
+    extractDefs(ctx, schema);
+    return finalize(ctx, schema);
+};
+
+const formatMap = {
+    guid: "uuid",
+    url: "uri",
+    datetime: "date-time",
+    json_string: "json-string",
+    regex: "", // do not set
+};
+// ==================== SIMPLE TYPE PROCESSORS ====================
+const stringProcessor = (schema, ctx, _json, _params) => {
+    const json = _json;
+    json.type = "string";
+    const { minimum, maximum, format, patterns, contentEncoding } = schema._zod
+        .bag;
+    if (typeof minimum === "number")
+        json.minLength = minimum;
+    if (typeof maximum === "number")
+        json.maxLength = maximum;
+    // custom pattern overrides format
+    if (format) {
+        json.format = formatMap[format] ?? format;
+        if (json.format === "")
+            delete json.format; // empty format is not valid
+    }
+    if (contentEncoding)
+        json.contentEncoding = contentEncoding;
+    if (patterns && patterns.size > 0) {
+        const regexes = [...patterns];
+        if (regexes.length === 1)
+            json.pattern = regexes[0].source;
+        else if (regexes.length > 1) {
+            json.allOf = [
+                ...regexes.map((regex) => ({
+                    ...(ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0"
+                        ? { type: "string" }
+                        : {}),
+                    pattern: regex.source,
+                })),
+            ];
+        }
+    }
+};
+const numberProcessor = (schema, ctx, _json, _params) => {
+    const json = _json;
+    const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+    if (typeof format === "string" && format.includes("int"))
+        json.type = "integer";
+    else
+        json.type = "number";
+    if (typeof exclusiveMinimum === "number") {
+        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+            json.minimum = exclusiveMinimum;
+            json.exclusiveMinimum = true;
+        }
+        else {
+            json.exclusiveMinimum = exclusiveMinimum;
+        }
+    }
+    if (typeof minimum === "number") {
+        json.minimum = minimum;
+        if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
+            if (exclusiveMinimum >= minimum)
+                delete json.minimum;
+            else
+                delete json.exclusiveMinimum;
+        }
+    }
+    if (typeof exclusiveMaximum === "number") {
+        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+            json.maximum = exclusiveMaximum;
+            json.exclusiveMaximum = true;
+        }
+        else {
+            json.exclusiveMaximum = exclusiveMaximum;
+        }
+    }
+    if (typeof maximum === "number") {
+        json.maximum = maximum;
+        if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
+            if (exclusiveMaximum <= maximum)
+                delete json.maximum;
+            else
+                delete json.exclusiveMaximum;
+        }
+    }
+    if (typeof multipleOf === "number")
+        json.multipleOf = multipleOf;
+};
+const neverProcessor = (_schema, _ctx, json, _params) => {
+    json.not = {};
+};
+const anyProcessor = (_schema, _ctx, _json, _params) => {
+    // empty schema accepts anything
+};
+const unknownProcessor = (_schema, _ctx, _json, _params) => {
+    // empty schema accepts anything
+};
+const enumProcessor = (schema, _ctx, json, _params) => {
+    const def = schema._zod.def;
+    const values = getEnumValues(def.entries);
+    // Number enums can have both string and number values
+    if (values.every((v) => typeof v === "number"))
+        json.type = "number";
+    if (values.every((v) => typeof v === "string"))
+        json.type = "string";
+    json.enum = values;
+};
+const customProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Custom types cannot be represented in JSON Schema");
+    }
+};
+const transformProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Transforms cannot be represented in JSON Schema");
+    }
+};
+// ==================== COMPOSITE TYPE PROCESSORS ====================
+const arrayProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    const { minimum, maximum } = schema._zod.bag;
+    if (typeof minimum === "number")
+        json.minItems = minimum;
+    if (typeof maximum === "number")
+        json.maxItems = maximum;
+    json.type = "array";
+    json.items = process$1(def.element, ctx, { ...params, path: [...params.path, "items"] });
+};
+const objectProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    json.type = "object";
+    json.properties = {};
+    const shape = def.shape;
+    for (const key in shape) {
+        json.properties[key] = process$1(shape[key], ctx, {
+            ...params,
+            path: [...params.path, "properties", key],
+        });
+    }
+    // required keys
+    const allKeys = new Set(Object.keys(shape));
+    const requiredKeys = new Set([...allKeys].filter((key) => {
+        const v = def.shape[key]._zod;
+        if (ctx.io === "input") {
+            return v.optin === undefined;
+        }
+        else {
+            return v.optout === undefined;
+        }
+    }));
+    if (requiredKeys.size > 0) {
+        json.required = Array.from(requiredKeys);
+    }
+    // catchall
+    if (def.catchall?._zod.def.type === "never") {
+        // strict
+        json.additionalProperties = false;
+    }
+    else if (!def.catchall) {
+        // regular
+        if (ctx.io === "output")
+            json.additionalProperties = false;
+    }
+    else if (def.catchall) {
+        json.additionalProperties = process$1(def.catchall, ctx, {
+            ...params,
+            path: [...params.path, "additionalProperties"],
+        });
+    }
+};
+const unionProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
+    // This includes both z.xor() and discriminated unions
+    const isExclusive = def.inclusive === false;
+    const options = def.options.map((x, i) => process$1(x, ctx, {
+        ...params,
+        path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
+    }));
+    if (isExclusive) {
+        json.oneOf = options;
+    }
+    else {
+        json.anyOf = options;
+    }
+};
+const intersectionProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    const a = process$1(def.left, ctx, {
+        ...params,
+        path: [...params.path, "allOf", 0],
+    });
+    const b = process$1(def.right, ctx, {
+        ...params,
+        path: [...params.path, "allOf", 1],
+    });
+    const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
+    const allOf = [
+        ...(isSimpleIntersection(a) ? a.allOf : [a]),
+        ...(isSimpleIntersection(b) ? b.allOf : [b]),
+    ];
+    json.allOf = allOf;
+};
+const nullableProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    const inner = process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    if (ctx.target === "openapi-3.0") {
+        seen.ref = def.innerType;
+        json.nullable = true;
+    }
+    else {
+        json.anyOf = [inner, { type: "null" }];
+    }
+};
+const nonoptionalProcessor = (schema, ctx, _json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+};
+const defaultProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    json.default = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const prefaultProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    if (ctx.io === "input")
+        json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const catchProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    let catchValue;
+    try {
+        catchValue = def.catchValue(undefined);
+    }
+    catch {
+        throw new Error("Dynamic catch values are not supported in JSON Schema");
+    }
+    json.default = catchValue;
+};
+const pipeProcessor = (schema, ctx, _json, params) => {
+    const def = schema._zod.def;
+    const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
+    process$1(innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = innerType;
+};
+const readonlyProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    json.readOnly = true;
+};
+const optionalProcessor = (schema, ctx, _json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+};
+
 const ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def) => {
     $ZodISODateTime.init(inst, def);
     ZodStringFormat.init(inst, def);
@@ -23756,6 +25140,13 @@ const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
 const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
     $ZodType.init(inst, def);
+    Object.assign(inst["~standard"], {
+        jsonSchema: {
+            input: createStandardJSONSchemaMethod(inst, "input"),
+            output: createStandardJSONSchemaMethod(inst, "output"),
+        },
+    });
+    inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
     inst.def = def;
     inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
@@ -23837,6 +25228,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def) => {
     $ZodString.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json);
     const bag = inst._zod.bag;
     inst.format = bag.format ?? null;
     inst.minLength = bag.minimum ?? null;
@@ -23994,6 +25386,7 @@ const ZodJWT = /*@__PURE__*/ $constructor("ZodJWT", (inst, def) => {
 const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json);
     inst.gt = (value, params) => inst.check(_gt(value, params));
     inst.gte = (value, params) => inst.check(_gte(value, params));
     inst.min = (value, params) => inst.check(_gte(value, params));
@@ -24032,6 +25425,7 @@ function int(params) {
 const ZodAny = /*@__PURE__*/ $constructor("ZodAny", (inst, def) => {
     $ZodAny.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => anyProcessor();
 });
 function any() {
     return _any(ZodAny);
@@ -24039,6 +25433,7 @@ function any() {
 const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
     $ZodUnknown.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor();
 });
 function unknown() {
     return _unknown(ZodUnknown);
@@ -24046,6 +25441,7 @@ function unknown() {
 const ZodNever = /*@__PURE__*/ $constructor("ZodNever", (inst, def) => {
     $ZodNever.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json);
 });
 function never(params) {
     return _never(ZodNever, params);
@@ -24053,6 +25449,7 @@ function never(params) {
 const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def) => {
     $ZodArray.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
     inst.element = def.element;
     inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
     inst.nonempty = (params) => inst.check(_minLength(1, params));
@@ -24066,6 +25463,7 @@ function array(element, params) {
 const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
     $ZodObjectJIT.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
     defineLazy(inst, "shape", () => {
         return def.shape;
     });
@@ -24098,6 +25496,7 @@ function object(shape, params) {
 const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
     $ZodUnion.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
     inst.options = def.options;
 });
 function union(options, params) {
@@ -24110,6 +25509,7 @@ function union(options, params) {
 const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
     $ZodIntersection.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
 });
 function intersection(left, right) {
     return new ZodIntersection({
@@ -24121,6 +25521,7 @@ function intersection(left, right) {
 const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def) => {
     $ZodEnum.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json);
     inst.enum = def.entries;
     inst.options = Object.values(def.entries);
     const keys = new Set(Object.keys(def.entries));
@@ -24168,6 +25569,7 @@ function _enum(values, params) {
 const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def) => {
     $ZodTransform.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx);
     inst._zod.parse = (payload, _ctx) => {
         if (_ctx.direction === "backward") {
             throw new $ZodEncodeError(inst.constructor.name);
@@ -24208,6 +25610,7 @@ function transform(fn) {
 const ZodOptional = /*@__PURE__*/ $constructor("ZodOptional", (inst, def) => {
     $ZodOptional.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -24219,6 +25622,7 @@ function optional(innerType) {
 const ZodNullable = /*@__PURE__*/ $constructor("ZodNullable", (inst, def) => {
     $ZodNullable.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -24230,6 +25634,7 @@ function nullable(innerType) {
 const ZodDefault = /*@__PURE__*/ $constructor("ZodDefault", (inst, def) => {
     $ZodDefault.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeDefault = inst.unwrap;
 });
@@ -24245,6 +25650,7 @@ function _default(innerType, defaultValue) {
 const ZodPrefault = /*@__PURE__*/ $constructor("ZodPrefault", (inst, def) => {
     $ZodPrefault.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -24259,6 +25665,7 @@ function prefault(innerType, defaultValue) {
 const ZodNonOptional = /*@__PURE__*/ $constructor("ZodNonOptional", (inst, def) => {
     $ZodNonOptional.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -24271,6 +25678,7 @@ function nonoptional(innerType, params) {
 const ZodCatch = /*@__PURE__*/ $constructor("ZodCatch", (inst, def) => {
     $ZodCatch.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeCatch = inst.unwrap;
 });
@@ -24284,6 +25692,7 @@ function _catch(innerType, catchValue) {
 const ZodPipe = /*@__PURE__*/ $constructor("ZodPipe", (inst, def) => {
     $ZodPipe.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
     inst.in = def.in;
     inst.out = def.out;
 });
@@ -24298,6 +25707,7 @@ function pipe(in_, out) {
 const ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
     $ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -24309,6 +25719,7 @@ function readonly(innerType) {
 const ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def) => {
     $ZodCustom.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx);
 });
 function refine(fn, _params = {}) {
     return _refine(ZodCustom, fn, _params);
@@ -24318,6 +25729,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 +25845,7 @@ const MapUpdateSchema = object({
   height: number()
 });
 let RpgMap = class extends RpgCommonMap {
-  constructor() {
+  constructor(room) {
     super();
     this.players = signal({});
     this.events = signal({});
@@ -24418,9 +25922,19 @@ 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.autoTickEnabled = 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,12 +26131,16 @@ 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();
     this.dataIsReady$.pipe(
-      finalize(async () => {
+      finalize$1(async () => {
         if (this.stopAllSoundsBeforeJoin) {
           player.stopAllSounds();
         }
@@ -24683,85 +26201,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 +26245,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 +26593,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 +26617,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 +26640,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
@@ -25289,8 +26720,7 @@ let RpgMap = class extends RpgCommonMap {
     }
     eventInstance.map = this;
     eventInstance.context = context$1;
-    eventInstance.x.set(x);
-    eventInstance.y.set(y);
+    await eventInstance.teleport({ x, y });
     this.events()[id] = eventInstance;
     await eventInstance.execMethod("onInit");
   }
@@ -25577,6 +27007,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 +27426,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 +27787,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;