@rpgjs/server 5.0.0-alpha.26 → 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;
@@ -7745,6 +7745,7 @@ var Server = class {
     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);
     };
@@ -7762,10 +7763,25 @@ var Server = class {
       } else {
         packet = instance.$memoryAll;
       }
-      this.broadcast({
-        type: "sync",
-        value: packet
-      }, instance);
+      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;
@@ -8083,6 +8099,8 @@ var Server = class {
           ...subRoom.$memoryAll
         }
       }, subRoom);
+    } else {
+      subRoom.$pendingInitialSync.set(conn, publicId);
     }
   }
   /**
@@ -8368,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;
@@ -9962,6 +9983,9 @@ __decorateClass$3([
 __decorateClass$3([
   sync()
 ], RpgCommonPlayer.prototype, "_gold");
+__decorateClass$3([
+  sync()
+], RpgCommonPlayer.prototype, "animationName");
 __decorateClass$3([
   sync()
 ], RpgCommonPlayer.prototype, "hpSignal");
@@ -15264,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
@@ -15811,6 +15812,11 @@ class RpgCommonMap {
     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
      * 
@@ -16044,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();
@@ -16068,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);
@@ -16157,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
    * 
@@ -16206,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
@@ -16590,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;
@@ -16669,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:
@@ -16724,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;
   }
@@ -17309,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) {
@@ -18016,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");
@@ -18083,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];
@@ -18114,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)) {
@@ -18230,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) => {
@@ -18379,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:
-                    vx = 1;
+                    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:
+                  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;
               }
-              executeNextRoute();
             } else {
-              executeNextRoute();
+              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;
+              }
             }
-          } catch (error) {
-            console.warn("Error executing route:", error);
-            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 {
+              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;
+            }
+            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) {
@@ -20329,7 +20897,12 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     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 });
       }
     }
     this.x.set(positions.x);
@@ -20969,6 +21542,9 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       }, this);
     }
   }
+  isEvent() {
+    return false;
+  }
 };
 __decorateClass$2([
   sync(_RpgPlayer)
@@ -20988,6 +21564,9 @@ class RpgEvent extends RpgPlayer {
     if (!map2) return;
     map2.removeEvent(this.id);
   }
+  isEvent() {
+    return true;
+  }
 }
 
 const context$1 = new Context();
@@ -22140,8 +22719,8 @@ class Doc {
 
 const version = {
     major: 4,
-    minor: 1,
-    patch: 13,
+    minor: 2,
+    patch: 0,
 };
 
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -22211,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)) {
@@ -23831,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);
@@ -23921,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 });
@@ -24002,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;
@@ -24159,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));
@@ -24197,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);
@@ -24204,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);
@@ -24211,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);
@@ -24218,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));
@@ -24231,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;
     });
@@ -24263,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) {
@@ -24275,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({
@@ -24286,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));
@@ -24333,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);
@@ -24373,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) {
@@ -24384,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) {
@@ -24395,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;
 });
@@ -24410,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) {
@@ -24424,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) {
@@ -24436,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;
 });
@@ -24449,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;
 });
@@ -24463,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) {
@@ -24474,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);
@@ -24682,6 +25928,7 @@ let RpgMap = class extends RpgCommonMap {
     if (isTest) {
       this.autoSync = false;
       this.setAutoTick(false);
+      this.autoTickEnabled = false;
       this.throttleSync = 0;
       this.throttleStorage = 0;
     } else {
@@ -24893,7 +26140,7 @@ let RpgMap = class extends RpgCommonMap {
     player.conn = conn;
     player._onInit();
     this.dataIsReady$.pipe(
-      finalize(async () => {
+      finalize$1(async () => {
         if (this.stopAllSoundsBeforeJoin) {
           player.stopAllSounds();
         }
@@ -25473,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");
   }