@rpgjs/server 5.0.0-alpha.32 → 5.0.0-alpha.35

package/src/rooms/map.ts

@@ -1,12 +1,12 @@
 import { Action, MockConnection, Request, Room, RoomMethods, RoomOnJoin } from "@signe/room";
 import { Hooks, IceMovement, ModulesToken, ProjectileMovement, ProjectileType, RpgCommonMap, Direction, RpgCommonPlayer, RpgShape, findModules } from "@rpgjs/common";
-import { WorldMapsManager, type WorldMapConfig } from "@rpgjs/common";
+import { WorldMapsManager, type WeatherState, type WorldMapConfig } from "@rpgjs/common";
 import { RpgPlayer, RpgEvent } from "../Player/Player";
 import { generateShortUUID, sync, type, users } from "@signe/sync";
 import { signal } from "@signe/reactive";
 import { inject } from "@signe/di";
 import { context } from "../core/context";;
-import { finalize, lastValueFrom, throttleTime } from "rxjs";
+import { finalize, lastValueFrom } from "rxjs";
 import { Subject } from "rxjs";
 import { BehaviorSubject } from "rxjs";
 import { COEFFICIENT_ELEMENTS, DAMAGE_CRITICAL, DAMAGE_PHYSIC, DAMAGE_SKILL } from "../presets";
@@ -15,6 +15,15 @@ import { EntityState } from "@rpgjs/physic";
 import { MapOptions } from "../decorators/map";
 import { BaseRoom } from "./BaseRoom";
 import { buildSaveSlotMeta, resolveSaveStorageStrategy } from "../services/save";
+import { Log } from "../logs/log";
+
+function isRpgLog(error: unknown): error is Log {
+  return error instanceof Log
+    || (typeof error === "object"
+      && error !== null
+      && "id" in error
+      && (error as any).name === "RpgLog");
+}
 
 /**
  * Interface for input controls configuration
@@ -30,6 +39,8 @@ export interface Controls {
   minTimeBetweenInputs?: number;
   /** Whether to enable anti-cheat validation */
   enableAntiCheat?: boolean;
+  /** Maximum number of queued inputs processed per server tick */
+  maxInputsPerTick?: number;
 }
 
 /**
@@ -51,6 +62,9 @@ const MapUpdateSchema = z.object({
   height: z.number(),
 });
 
+const SAFE_MAP_WIDTH = 1000;
+const SAFE_MAP_HEIGHT = 1000;
+
 /**
  * Interface representing hook methods available for map events
  * 
@@ -95,6 +109,10 @@ export type EventPosOption = {
   event: EventConstructor | (EventHooks & Record<string, any>)
 }
 
+interface WeatherSetOptions {
+  sync?: boolean;
+}
+
 @Room({
   path: "map-{id}"
 })
@@ -205,6 +223,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * with custom formulas when the map is loaded.
    */
   damageFormulas: any = {}
+  private _weatherState: WeatherState | null = null;
   /** Internal: Map of shapes by name */
   private _shapes: Map<string, RpgShape> = new Map();
   /** Internal: Map of shape entity UUIDs to RpgShape instances */
@@ -242,6 +261,31 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     return BaseRoom.prototype.onStart.call(this)
   }
 
+  private isPositiveNumber(value: unknown): value is number {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+  }
+
+  private resolveTrustedMapDimensions(map: any): void {
+    const normalizedId = typeof map?.id === "string"
+      ? map.id.replace(/^map-/, "")
+      : "";
+    const worldMapInfo = normalizedId
+      ? this.worldMapsManager?.getMapInfo(normalizedId)
+      : null;
+
+    if (!this.isPositiveNumber(map?.width)) {
+      map.width = this.isPositiveNumber(worldMapInfo?.width)
+        ? worldMapInfo.width
+        : SAFE_MAP_WIDTH;
+    }
+
+    if (!this.isPositiveNumber(map?.height)) {
+      map.height = this.isPositiveNumber(worldMapInfo?.height)
+        ? worldMapInfo.height
+        : SAFE_MAP_HEIGHT;
+    }
+  }
+
   /**
    * Setup collision detection between players, events, and shapes
    * 
@@ -288,8 +332,8 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
 
     // Helper function to check if entities have different z (height)
     const hasDifferentZ = (entityA: any, entityB: any): boolean => {
-      const zA = entityA.owner.z();
-      const zB = entityB.owner.z();
+      const zA = entityA.owner?.z();
+      const zB = entityB.owner?.z();
       return zA !== zB;
     };
 
@@ -450,14 +494,25 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     if (packet && typeof packet === 'object') {
       obj.timestamp = Date.now();
 
-      // Add ack info: last processed frame and authoritative position
+      // Add ack info: last processed frame and authoritative position.
+      // When the sync payload already contains this player's coordinates,
+      // prefer them to keep ack state aligned with the snapshot sent to the client.
       if (player) {
+        const value = packet.value && typeof packet.value === "object" ? packet.value : undefined;
+        const packetPlayers = value?.players && typeof value.players === "object" ? value.players : undefined;
+        const playerSnapshot = packetPlayers?.[player.id];
+        const bodyPos = this.getBodyPosition(player.id, "top-left");
+        const ackX =
+          typeof playerSnapshot?.x === "number" ? playerSnapshot.x : bodyPos?.x ?? player.x();
+        const ackY =
+          typeof playerSnapshot?.y === "number" ? playerSnapshot.y : bodyPos?.y ?? player.y();
         const lastFramePositions = player._lastFramePositions;
         obj.ack = {
-          frame: lastFramePositions?.frame ?? player.pendingInputs.length,
-          x: lastFramePositions?.position?.x ?? player.x(),
-          y: lastFramePositions?.position?.y ?? player.y(),
-          direction: lastFramePositions?.position?.direction ?? player.direction(),
+          frame: lastFramePositions?.frame ?? 0,
+          serverTick: this.getTick(),
+          x: Math.round(ackX),
+          y: Math.round(ackY),
+          direction: playerSnapshot?.direction ?? player.direction(),
         };
       }
     }
@@ -510,26 +565,54 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     }
     player.context = context;
     player.conn = conn;
+    player.pendingInputs = [];
+    player.lastProcessedInputTs = 0;
+    player._lastFramePositions = null;
     player._onInit()
     this.dataIsReady$.pipe(
-      finalize(async () => {
-        // Check if we should stop all sounds before playing new ones
-        if ((this as any).stopAllSoundsBeforeJoin) {
-          player.stopAllSounds();
-        }
+      finalize(() => {
+        // Avoid unhandled promise rejections from async hook execution.
+        void (async () => {
+          try {
+            const hitbox = typeof player.hitbox === 'function' ? player.hitbox() : player.hitbox;
+            const width = hitbox?.w ?? 32;
+            const height = hitbox?.h ?? 32;
+            const body = this.getBody(player.id) as any;
+            if (body) {
+              // Ensure physics callbacks target the current player instance
+              // after session transfer/map return.
+              body.owner = player;
+            }
+            // Keep physics body aligned with restored snapshot coordinates on map join.
+            this.updateHitbox(player.id, player.x(), player.y(), width, height);
 
-        this.sounds.forEach(sound => player.playSound(sound, { loop: true }));
+            // Check if we should stop all sounds before playing new ones
+            if ((this as any).stopAllSoundsBeforeJoin) {
+              player.stopAllSounds();
+            }
 
-        // Execute global map hooks (from RpgServer.map)
-        await lastValueFrom(this.hooks.callHooks("server-map-onJoin", player, this));
+            this.sounds.forEach(sound => player.playSound(sound, { loop: true }));
+            player.emit("weatherState", this.getWeather());
 
-        // // Execute map-specific hooks (from @MapData or MapOptions)
-        if (typeof (this as any)._onJoin === 'function') {
-          await (this as any)._onJoin(player);
-        }
+            // Execute global map hooks (from RpgServer.map)
+            await lastValueFrom(this.hooks.callHooks("server-map-onJoin", player, this));
+
+            // // Execute map-specific hooks (from @MapData or MapOptions)
+            if (typeof (this as any)._onJoin === 'function') {
+              await (this as any)._onJoin(player);
+            }
 
-        // Execute player hooks
-        await lastValueFrom(this.hooks.callHooks("server-player-onJoinMap", player, this));
+            // Execute player hooks
+            await lastValueFrom(this.hooks.callHooks("server-player-onJoinMap", player, this));
+          }
+          catch (error) {
+            if (isRpgLog(error)) {
+              console.warn(`[RpgLog:${error.id}] ${error.message}`);
+              return;
+            }
+            console.error("[RPGJS] Error during map onJoin hooks:", error);
+          }
+        })();
       })
     ).subscribe();
   }
@@ -569,6 +652,8 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     // Execute player hooks
     await lastValueFrom(this.hooks.callHooks("server-player-onLeaveMap", player, this));
     player.pendingInputs = [];
+    player.lastProcessedInputTs = 0;
+    player._lastFramePositions = null;
   }
 
   /**
@@ -696,21 +781,83 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    */
   @Action('move')
   async onInput(player: RpgPlayer, input: any) {
-    if (typeof input?.frame === 'number') {
-      // Check if we already have this frame to avoid duplicates
-      const existingInput = player.pendingInputs.find(pending => pending.frame === input.frame);
-      if (existingInput) {
-        return; // Skip duplicate frame
+    const lastAckedFrame = player._lastFramePositions?.frame ?? 0;
+    const now = Date.now();
+    const candidates: Array<{
+      input: any;
+      frame: number;
+      tick?: number;
+      timestamp: number;
+      clientState?: { x: number; y: number; direction?: Direction };
+    }> = [];
+
+    const enqueueCandidate = (entry: any) => {
+      if (typeof entry?.frame !== "number") {
+        return;
+      }
+      if (!entry?.input) {
+        return;
       }
+      const candidate: {
+        input: any;
+        frame: number;
+        tick?: number;
+        timestamp: number;
+        clientState?: { x: number; y: number; direction?: Direction };
+      } = {
+        input: entry.input,
+        frame: entry.frame,
+        tick: typeof entry.tick === "number" ? entry.tick : undefined,
+        timestamp: typeof entry.timestamp === "number" ? entry.timestamp : now,
+      };
+      if (typeof entry.x === "number" && typeof entry.y === "number") {
+        candidate.clientState = {
+          x: entry.x,
+          y: entry.y,
+          direction: entry.direction,
+        };
+      }
+      candidates.push(candidate);
+    };
 
-      player.pendingInputs.push({
-        input: input.input,
-        frame: input.frame,
-        timestamp: input.timestamp || Date.now(),
-      });
+    for (const trajectoryEntry of Array.isArray(input?.trajectory) ? input.trajectory : []) {
+      enqueueCandidate(trajectoryEntry);
+    }
+
+    enqueueCandidate(input);
+
+    if (candidates.length === 0) {
+      return;
+    }
+
+    candidates.sort((a, b) => a.frame - b.frame);
+    const existingFrames = new Set<number>(
+      player.pendingInputs
+        .map((pending: any) => pending?.frame)
+        .filter((frame: any): frame is number => typeof frame === "number"),
+    );
+
+    for (const candidate of candidates) {
+      if (candidate.frame <= lastAckedFrame) {
+        continue;
+      }
+      if (existingFrames.has(candidate.frame)) {
+        continue;
+      }
+      player.pendingInputs.push(candidate);
+      existingFrames.add(candidate.frame);
     }
   }
 
+  @Action("ping")
+  onPing(player: RpgPlayer, payload: { clientTime?: number; clientFrame?: number }) {
+    player.emit("pong", {
+      serverTick: this.getTick(),
+      clientTime: typeof payload?.clientTime === "number" ? payload.clientTime : Date.now(),
+      clientFrame: typeof payload?.clientFrame === "number" ? payload.clientFrame : 0,
+    });
+  }
+
   @Action('save.save')
   async saveSlot(player: RpgPlayer, value: { requestId: string; index: number; meta?: any }) {
     BaseRoom.prototype.saveSlot(player, value);
@@ -772,10 +919,17 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     await lastValueFrom(this.hooks.callHooks("server-worldMaps-load", this))
     await lastValueFrom(this.hooks.callHooks("server-databaseHooks-load", this))
 
+    this.resolveTrustedMapDimensions(map)
+    this.data.set(map)
+
     map.events = map.events ?? []
+    let initialWeather: WeatherState | null | undefined = this.globalConfig?.weather;
 
     if (map.id) {
       const mapFound = this.maps.find(m => m.id === map.id)
+      if (typeof mapFound?.weather !== "undefined") {
+        initialWeather = mapFound.weather;
+      }
       if (mapFound?.events) {
         map.events = [
           ...mapFound.events,
@@ -807,6 +961,12 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       }
     }
 
+    if (typeof initialWeather !== "undefined") {
+      this.setWeather(initialWeather);
+    } else {
+      this.clearWeather();
+    }
+
     await lastValueFrom(this.hooks.callHooks("server-map-onBeforeUpdate", map, this))
 
     this.loadPhysic()
@@ -898,10 +1058,11 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   /**
    * Process pending inputs for a player with anti-cheat validation
    * 
-   * This method processes all pending inputs for a player while performing
+   * This method processes pending inputs for a player while performing
    * anti-cheat validation to prevent time manipulation and frame skipping.
    * It validates the time deltas between inputs and ensures they are within
-   * acceptable ranges.
+   * acceptable ranges. To preserve movement itinerary under network bursts,
+   * the number of inputs processed per call is capped.
    * 
    * ## Architecture
    * 
@@ -953,20 +1114,22 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       maxTimeDelta: 1000, // 1 second max between inputs
       maxFrameDelta: 10,  // Max 10 frames skipped
       minTimeBetweenInputs: 16, // ~60fps minimum
-      enableAntiCheat: false
+      enableAntiCheat: false,
+      maxInputsPerTick: 1,
     };
 
     const config = { ...defaultControls, ...controls };
     let lastProcessedTime = player.lastProcessedInputTs || 0;
-    let lastProcessedFrame = 0;
+    let lastProcessedFrame = player._lastFramePositions?.frame ?? 0;
 
     // Sort inputs by frame number to ensure proper order
     player.pendingInputs.sort((a, b) => (a.frame || 0) - (b.frame || 0));
 
     let hasProcessedInputs = false;
+    let processedThisTick = 0;
 
-    // Process all pending inputs
-    while (player.pendingInputs.length > 0) {
+    // Process pending inputs progressively to preserve itinerary under latency.
+    while (player.pendingInputs.length > 0 && processedThisTick < config.maxInputsPerTick) {
       const input = player.pendingInputs.shift();
 
       if (!input || typeof input.frame !== 'number') {
@@ -1009,6 +1172,26 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
         processedInputs.push(input.input);
         hasProcessedInputs = true;
         lastProcessedTime = input.timestamp || Date.now();
+        processedThisTick += 1;
+
+        const bodyPos = this.getBodyPosition(player.id, "top-left");
+        const ackX =
+          typeof input.clientState?.x === "number"
+            ? input.clientState.x
+            : bodyPos?.x ?? player.x();
+        const ackY =
+          typeof input.clientState?.y === "number"
+            ? input.clientState.y
+            : bodyPos?.y ?? player.y();
+        player._lastFramePositions = {
+          frame: input.frame,
+          position: {
+            x: Math.round(ackX),
+            y: Math.round(ackY),
+            direction: input.clientState?.direction ?? player.direction(),
+          },
+          serverTick: this.getTick(),
+        };
       }
 
       // Update tracking variables
@@ -1060,19 +1243,17 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       this._inputLoopSubscription.unsubscribe();
     }
 
-    this._inputLoopSubscription = this.tick$.pipe(
-      throttleTime(50) // Throttle to 50ms for input processing
-    ).subscribe(async ({ timestamp }) => {
+    this._inputLoopSubscription = this.tick$.subscribe(() => {
       for (const player of this.getPlayers()) {
-        if (player.pendingInputs.length > 0) {
-          const anyPlayer = player as any;
-          if (!anyPlayer._isProcessingInputs) {
-            anyPlayer._isProcessingInputs = true;
-            await this.processInput(player.id).finally(() => {
-              anyPlayer._isProcessingInputs = false;
-            });
-          }
+        const anyPlayer = player as any;
+        const shouldProcess = player.pendingInputs.length > 0 || (player.lastProcessedInputTs || 0) > 0;
+        if (!shouldProcess || anyPlayer._isProcessingInputs) {
+          continue;
         }
+        anyPlayer._isProcessingInputs = true;
+        void this.processInput(player.id).finally(() => {
+          anyPlayer._isProcessingInputs = false;
+        });
       }
     });
   }
@@ -1616,6 +1797,71 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     })
   }
 
+  private cloneWeatherState(weather: WeatherState | null): WeatherState | null {
+    if (!weather) {
+      return null;
+    }
+    return {
+      ...weather,
+      params: weather.params ? { ...weather.params } : undefined,
+    };
+  }
+
+  /**
+   * Get the current map weather state.
+   */
+  getWeather(): WeatherState | null {
+    return this.cloneWeatherState(this._weatherState);
+  }
+
+  /**
+   * Set the full weather state for this map.
+   *
+   * When `sync` is true (default), all connected clients receive the new weather.
+   */
+  setWeather(next: WeatherState | null, options: WeatherSetOptions = {}): WeatherState | null {
+    const sync = options.sync !== false;
+    if (next && !next.effect) {
+      throw new Error("setWeather: 'effect' is required when weather is not null.");
+    }
+    this._weatherState = this.cloneWeatherState(next);
+    if (sync) {
+      this.$broadcast({
+        type: "weatherState",
+        value: this._weatherState,
+      });
+    }
+    return this.getWeather();
+  }
+
+  /**
+   * Patch the current weather state.
+   *
+   * Nested `params` values are merged.
+   */
+  patchWeather(patch: Partial<WeatherState>, options: WeatherSetOptions = {}): WeatherState | null {
+    const current = this._weatherState ?? null;
+    if (!current && !patch.effect) {
+      throw new Error("patchWeather: 'effect' is required when no weather is currently set.");
+    }
+    const next: WeatherState = {
+      ...(current ?? {}),
+      ...patch,
+      params: {
+        ...(current?.params ?? {}),
+        ...(patch.params ?? {}),
+      },
+    } as WeatherState;
+    return this.setWeather(next, options);
+  }
+
+  /**
+   * Clear weather for this map.
+   */
+  clearWeather(options: WeatherSetOptions = {}): void {
+    this.setWeather(null, options);
+  }
+
   /**
    * Configure runtime synchronized properties on the map
    * 

package/tests/item.spec.ts

@@ -385,6 +385,24 @@ describe("Item Management - Equipment", () => {
     expect((item as any).equipped).toBe(true);
   });
 
+  test("should auto add and equip item", () => {
+    player.equip("TestSword", "auto");
+    const item = player.getItem("TestSword");
+    expect(item).toBeDefined();
+    expect(item?.quantity()).toBe(1);
+    expect((item as any).equipped).toBe(true);
+    expect(player.equipments().some((eq) => eq.id() === "TestSword")).toBe(
+      true
+    );
+  });
+
+  test("should not add duplicate when auto equipping existing item", () => {
+    player.addItem("TestSword", 2);
+    player.equip("TestSword", "auto");
+    const item = player.getItem("TestSword");
+    expect(item?.quantity()).toBe(2);
+  });
+
   test("should throw error when equipping non-existent item", () => {
     expect(() => {
       player.equip("TestSword", true);
@@ -588,4 +606,4 @@ describe("Item Management - Edge Cases", () => {
     expect(player.getItem("TestSword")?.quantity()).toBe(1);
     expect(player.getItem("TestArmor")?.quantity()).toBe(2);
   });
-});
+});