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

package/dist/logs/log.d.ts

@@ -1,5 +1,4 @@
-export declare class Log {
-    private id;
-    private msg;
+export declare class Log extends Error {
+    readonly id: string;
     constructor(id: string, msg: string);
 }

package/dist/rooms/map.d.ts

@@ -1,5 +1,5 @@
 import { MockConnection, RoomMethods, RoomOnJoin } from '@signe/room';
-import { Hooks, RpgCommonMap, RpgShape, WorldMapsManager, WorldMapConfig } from '../../../common/src';
+import { Hooks, RpgCommonMap, RpgShape, WorldMapsManager, WeatherState, WorldMapConfig } from '../../../common/src';
 import { RpgPlayer, RpgEvent } from '../Player/Player';
 import { BehaviorSubject } from 'rxjs';
 import { MapOptions } from '../decorators/map';
@@ -17,6 +17,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;
 }
 /**
  * Interface representing hook methods available for map events
@@ -58,6 +60,9 @@ export type EventPosOption = {
      */
     event: EventConstructor | (EventHooks & Record<string, any>);
 };
+interface WeatherSetOptions {
+    sync?: boolean;
+}
 export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     /**
      * Synchronized signal containing all players currently on the map
@@ -158,6 +163,7 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
      * with custom formulas when the map is loaded.
      */
     damageFormulas: any;
+    private _weatherState;
     /** Internal: Map of shapes by name */
     private _shapes;
     /** Internal: Map of shape entity UUIDs to RpgShape instances */
@@ -169,6 +175,8 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
     autoSync: boolean;
     constructor(room: any);
     onStart(): Promise<void>;
+    private isPositiveNumber;
+    private resolveTrustedMapDimensions;
     /**
      * Setup collision detection between players, events, and shapes
      *
@@ -391,6 +399,10 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
      * ```
      */
     onInput(player: RpgPlayer, input: any): Promise<void>;
+    onPing(player: RpgPlayer, payload: {
+        clientTime?: number;
+        clientFrame?: number;
+    }): void;
     saveSlot(player: RpgPlayer, value: {
         requestId: string;
         index: number;
@@ -463,10 +475,11 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
     /**
      * 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
      *
@@ -924,6 +937,27 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
         x: number;
         y: number;
     }, graphic: string, animationName?: string): void;
+    private cloneWeatherState;
+    /**
+     * Get the current map weather state.
+     */
+    getWeather(): WeatherState | null;
+    /**
+     * 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;
+    /**
+     * Patch the current weather state.
+     *
+     * Nested `params` values are merged.
+     */
+    patchWeather(patch: Partial<WeatherState>, options?: WeatherSetOptions): WeatherState | null;
+    /**
+     * Clear weather for this map.
+     */
+    clearWeather(options?: WeatherSetOptions): void;
     /**
      * Configure runtime synchronized properties on the map
      *
@@ -1257,3 +1291,4 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
 }
 export interface RpgMap extends RoomMethods {
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-alpha.32",
+  "version": "5.0.0-alpha.35",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,16 +11,16 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.32",
-    "@rpgjs/physic": "5.0.0-alpha.32",
-    "@rpgjs/testing": "5.0.0-alpha.32",
+    "@rpgjs/common": "5.0.0-alpha.35",
+    "@rpgjs/physic": "5.0.0-alpha.35",
+    "@rpgjs/testing": "5.0.0-alpha.35",
     "@rpgjs/database": "^4.3.0",
-    "@signe/di": "^2.8.2",
-    "@signe/reactive": "^2.8.2",
-    "@signe/room": "^2.8.2",
-    "@signe/sync": "^2.8.2",
+    "@signe/di": "^2.8.3",
+    "@signe/reactive": "^2.8.3",
+    "@signe/room": "^2.8.3",
+    "@signe/sync": "^2.8.3",
     "rxjs": "^7.8.2",
-    "zod": "^4.3.5"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "vite": "^7.3.1",

package/src/Gui/ShopGui.ts

@@ -3,9 +3,10 @@ import { Gui } from './Gui'
 import { RpgPlayer } from '../Player/Player'
 
 export type ShopSellList = Record<string, number> | Array<{ id: string; multiplier: number }>
+export type ShopItemInput = string | { id?: string; [key: string]: any }
 
 export interface ShopGuiOptions {
-    items: any[]
+    items: ShopItemInput[]
     sell?: ShopSellList
     sellMultiplier?: number
     message?: string
@@ -16,7 +17,7 @@ export interface ShopGuiOptions {
 }
 
 export class ShopGui extends Gui {
-    private itemsInput: any[] = []
+    private itemsInput: ShopItemInput[] = []
     private sellMultipliers: Record<string, number> = {}
     private baseSellMultiplier = 0.5
     private messageInput?: string
@@ -65,7 +66,7 @@ export class ShopGui extends Gui {
             return undefined
         }
 
-        const buildItemData = (item, overrides: { price?: number; quantity?: number } = {}) => {
+        const buildItemData = (item: ShopItemInput, overrides: { price?: number; quantity?: number } = {}) => {
             const rawId = typeof item === 'string'
                 ? item
                 : (typeof item?.id === 'function' ? item.id() : (item?.id ?? item?.name))

package/src/Player/ClassManager.ts

@@ -6,8 +6,8 @@ type ActorClass = any;
 interface PlayerWithMixins extends RpgCommonPlayer {
   databaseById(id: string): any;
   addParameter(name: string, { start, end }: { start: number, end: number }): void;
-  addItem(item: any): void;
-  equip(item: any, equip: boolean): void;
+  addItem(item: any): any;
+  equip(itemId: string, equip?: boolean | 'auto'): void;
 }
 
 /**
@@ -108,8 +108,11 @@ export function WithClassManager<TBase extends PlayerCtor>(Base: TBase) {
         (this as any).addParameter(param, actor.parameters[param]);
       }
       for (let item of actor.startingEquipment) {
-        (this as any).addItem(item);
-        (this as any).equip(item, true);
+        const inventory = (this as any).addItem(item);
+        const itemId = inventory?.id?.();
+        if (itemId) {
+          (this as any).equip(itemId, true);
+        }
       }
       if (actor.class) this.setClass(actor.class);
       (this as any)["execMethod"]("onSet", [this], actor);

package/src/Player/ItemManager.ts

@@ -581,15 +581,19 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
     }
 
     equip(
-      itemClass: ItemClass | string,
-      equip: boolean = true
+      itemId: string,
+      equip: boolean | 'auto' = true
     ): void {
-      const itemId = isString(itemClass) ? itemClass : (itemClass as any).name;
-      const inventory: Item = this.getItem(itemClass);
+      const autoAdd = equip === 'auto';
+      const equipState = equip === 'auto' ? true : equip;
+      const data = (this as any).databaseById(itemId);
+      let inventory: Item = this.getItem(itemId);
+      if (!inventory && autoAdd) {
+        inventory = this.addItem(itemId, 1);
+      }
       if (!inventory) {
         throw ItemLog.notInInventory(itemId);
       }
-      const data = (this as any).databaseById(itemId);
       if (data._type == "item") {
         throw ItemLog.invalidToEquiped(itemId);
       }
@@ -607,11 +611,11 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
 
       const item = inventory;
 
-      if ((item as any).equipped && equip) {
+      if ((item as any).equipped && equipState) {
         throw ItemLog.isAlreadyEquiped(itemId);
       }
-      (item as any).equipped = equip;
-      if (!equip) {
+      (item as any).equipped = equipState;
+      if (!equipState) {
         const index = this.equipments().findIndex((it) => it.id() == item.id());
         this.equipments().splice(index, 1);
       } else {
@@ -619,7 +623,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       }
       // Call onEquip hook - use stored instance if available
       const hookTarget = (item as any)._itemInstance || item;
-      this["execMethod"]("onEquip", [this, equip], hookTarget);
+      this["execMethod"]("onEquip", [this, equipState], hookTarget);
     }
   } as unknown as TBase;
 }
@@ -852,12 +856,13 @@ export interface IItemManager {
   /**
    * Equips a weapon or armor on a player
    * 
-   * Think first to add the item in the inventory with the `addItem()` method before equipping the item.
+   * Think first to add the item in the inventory with the `addItem()` method before equipping the item,
+   * or pass `"auto"` to add the item if it is missing and equip it.
    * 
    * The `onEquip()` method is called on the ItemClass when the item is equipped or unequipped.
    * 
-   * @param itemClass - Item class or string identifier. If string, it's the item ID
-   * @param equip - Equip the item if `true`, unequip if `false` (default: `true`)
+   * @param itemId - Item identifier to resolve from the database
+   * @param equip - Equip the item if `true`, unequip if `false`, or `"auto"` to add then equip (default: `true`)
    * @throws {Object} ItemLog.notInInventory - If the item is not in the inventory
    *   - `id`: `ITEM_NOT_INVENTORY`
    *   - `msg`: Error message
@@ -870,19 +875,17 @@ export interface IItemManager {
    * 
    * @example
    * ```ts
-   * import Sword from 'your-database/sword'
-   * 
    * try {
-   *   player.addItem(Sword)
-   *   player.equip(Sword)
+   *   player.addItem('sword')
+   *   player.equip('sword')
    *   // Later, unequip it
-   *   player.equip(Sword, false)
+   *   player.equip('sword', false)
    * } catch (err) {
    *   console.log(err)
    * }
    * ```
    */
-  equip(itemClass: ItemClass | string, equip?: boolean): void;
+  equip(itemId: string, equip?: boolean | 'auto'): void;
 
   /**
    * Get the player's attack (sum of items equipped)

package/src/Player/ParameterManager.ts

@@ -10,6 +10,32 @@ export type ExpCurve = {
   accelerationB: number;
 };
 
+const DEFAULT_EXP_CURVE: ExpCurve = {
+  basis: 30,
+  extra: 20,
+  accelerationA: 30,
+  accelerationB: 30
+};
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function toValidNumber(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function normalizeExpCurve(value: unknown): ExpCurve {
+  if (!isObject(value)) return DEFAULT_EXP_CURVE;
+
+  return {
+    basis: toValidNumber(value.basis, DEFAULT_EXP_CURVE.basis),
+    extra: toValidNumber(value.extra, DEFAULT_EXP_CURVE.extra),
+    accelerationA: toValidNumber(value.accelerationA, DEFAULT_EXP_CURVE.accelerationA),
+    accelerationB: toValidNumber(value.accelerationB, DEFAULT_EXP_CURVE.accelerationB)
+  };
+}
+
 /**
  * Interface for Parameter Manager functionality
  * 
@@ -549,10 +575,18 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
      * ```
      * @memberof ParameterManager
      * */
-    public _expCurveSignal = type(signal<string>('') as any, '_expCurveSignal', { persist: true }, this as any)
+    public _expCurveSignal = type(signal<string>(JSON.stringify(DEFAULT_EXP_CURVE)) as any, '_expCurveSignal', { persist: true }, this as any)
 
     get expCurve(): ExpCurve { 
-        return JSON.parse(this._expCurveSignal())
+        const raw = this._expCurveSignal()
+        if (!raw) return DEFAULT_EXP_CURVE
+
+        try {
+            return normalizeExpCurve(JSON.parse(raw))
+        }
+        catch {
+            return DEFAULT_EXP_CURVE
+        }
     }
 
     set expCurve(val: ExpCurve) {

package/src/Player/Player.ts

@@ -187,7 +187,9 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   constructor() {
     super();
 
-    let lastEmitted: { x: number; y: number } | null = null;
+    const initialX = typeof this.x === "function" ? Number(this.x()) || 0 : 0;
+    const initialY = typeof this.y === "function" ? Number(this.y()) || 0 : 0;
+    let lastEmitted: { x: number; y: number } | null = { x: initialX, y: initialY };
     let pendingUpdate: { x: number; y: number } | null = null;
     let updateScheduled = false;
 
@@ -252,6 +254,8 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
 
   setMap(map: RpgMap) {
     this.map = map;
+    // Prevent immediate ping-pong map transfers when spawning near a border.
+    this.touchSide = true;
   }
 
   applyFrames() {
@@ -303,12 +307,13 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     if (canChange.some(v => v === false)) return false;
 
     if (positions && typeof positions === 'object') {
-      this.teleport(positions)
+      await this.teleport(positions)
     }
-    await room?.$sessionTransfer(this.conn, realMapId);
+    const transferToken = await room?.$sessionTransfer(this.conn, realMapId);
     this.emit("changeMap", {
       mapId: realMapId,
       positions,
+      transferToken: typeof transferToken === 'string' ? transferToken : undefined,
     });
     return true;
   }
@@ -321,17 +326,34 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
         const direction = this.getDirection()
         const marginLeftRight = map.tileWidth / 2
         const marginTopDown = map.tileHeight / 2
+        const hitbox = this.hitbox()
+        const currentX = this.x()
+        const currentY = this.y()
+        const nearBorder =
+          currentX < marginLeftRight ||
+          currentX > map.widthPx - hitbox.w - marginLeftRight ||
+          currentY < marginTopDown ||
+          currentY > map.heightPx - hitbox.h - marginTopDown
+
+        if (this.touchSide) {
+            if (nearBorder) {
+                return false
+            }
+            this.touchSide = false
+        }
 
         const changeMap = async (adjacent, to) => {
-            if (this.touchSide) {
+            const [nextMap] = worldMaps.getAdjacentMaps(map, adjacent)
+            if (!nextMap) {
                 return false
             }
-            this.touchSide = true
-            const [nextMap] = worldMaps.getAdjacentMaps(map, adjacent)
-            if (!nextMap) return false
             const id = nextMap.id as string
             const nextMapInfo = worldMaps.getMapInfo(id)
-            return !!(await this.changeMap(id, to(nextMapInfo)))
+            const changed = !!(await this.changeMap(id, to(nextMapInfo)))
+            if (changed) {
+                this.touchSide = true
+            }
+            return changed
         }
 
         if (nextPosition.x < marginLeftRight && direction == Direction.Left) {

package/src/decorators/map.ts

@@ -1,3 +1,5 @@
+import type { WeatherState } from "@rpgjs/common";
+
 export interface MapOptions {
     /** 
      * Map identifier. Allows to go to the map (for example with player.changeMap())
@@ -97,6 +99,28 @@ export interface MapOptions {
      * */
     sounds?: string[]
 
+    /**
+     * Initial weather state for this map.
+     *
+     * This value is applied when the map is loaded and can later be updated
+     * at runtime with `map.setWeather()` from server logic.
+     *
+     * ```ts
+     * @MapData({
+     *   id: 'forest',
+     *   file: require('./tmx/forest.tmx'),
+     *   weather: {
+     *     effect: 'fog',
+     *     preset: 'rpgForestFog',
+     *     params: { density: 1.2, height: 0.75 },
+     *     transitionMs: 1200
+     *   }
+     * })
+     * class ForestMap extends RpgMap {}
+     * ```
+     */
+    weather?: WeatherState | null
+
     /** 
      * Whether to stop all sounds before playing the map sounds when a player joins.
      * 
@@ -278,6 +302,7 @@ export function MapData(options: MapOptions) {
         target.prototype.file = options.file
         target.prototype.id = options.id
         target.prototype.sounds = options.sounds
+        target.prototype.weather = options.weather
         target.prototype.lowMemory = options.lowMemory
         target.prototype.stopAllSoundsBeforeJoin = options.stopAllSoundsBeforeJoin
 
@@ -299,4 +324,4 @@ export function MapData(options: MapOptions) {
             target.prototype.onLeave = options.onLeave
         }
     }
-}
+}

package/src/logs/log.ts

@@ -1,3 +1,10 @@
-export class Log {
-    constructor(private id: string, private msg: string) {}
-}
+export class Log extends Error {
+  readonly id: string;
+
+  constructor(id: string, msg: string) {
+    super(`[${id}] ${msg}`);
+    this.name = "RpgLog";
+    this.id = id;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}

package/src/module.ts

@@ -97,6 +97,7 @@ export function provideServerModules(modules: RpgServerModule[]): FactoryProvide
                     type: MapClass.type,
                     name: MapClass.prototype?.name,
                     sounds: MapClass.prototype?.sounds,
+                    weather: MapClass.prototype?.weather,
                     lowMemory: MapClass.prototype?.lowMemory,
                     stopAllSoundsBeforeJoin: MapClass.prototype?.stopAllSoundsBeforeJoin,
                     events: MapClass.prototype?._events,