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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-alpha.30",
+  "version": "5.0.0-alpha.32",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,9 +11,9 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.30",
-    "@rpgjs/physic": "5.0.0-alpha.30",
-    "@rpgjs/testing": "5.0.0-alpha.30",
+    "@rpgjs/common": "5.0.0-alpha.32",
+    "@rpgjs/physic": "5.0.0-alpha.32",
+    "@rpgjs/testing": "5.0.0-alpha.32",
     "@rpgjs/database": "^4.3.0",
     "@signe/di": "^2.8.2",
     "@signe/reactive": "^2.8.2",

package/src/Gui/MenuGui.ts

@@ -119,7 +119,7 @@ export class MenuGui extends Gui {
         }))
         const saveLoad = this.buildSaveLoad(options)
 
-        return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats() }
+        return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats(), expForNextlevel: player.expForNextlevel }
     }
 
     private refreshMenu(clientActionId?: string) {

package/src/Player/MoveManager.ts

@@ -744,7 +744,8 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
      * Move toward a target player or position using AI pathfinding
      * 
      * Uses the `SeekAvoid` strategy to navigate toward the target while avoiding obstacles.
-     * The movement speed is based on the player's current `speed` property, scaled appropriately.
+     * The movement speed is based on the player's current `speed` and `frequency` settings,
+     * scaled appropriately.
      * 
      * @param target - Target player or position `{ x, y }` to move toward
      * 
@@ -764,10 +765,14 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
       const playerId = (this as unknown as PlayerWithMixins).id;
       const engine = map.physic;
 
-      // Calculate maxSpeed based on player's speed
+      // Calculate maxSpeed based on player's speed and frequency
       // Original values: 180 for player target, 80 for position target (with default speed=4)
       // Factor: 45 for player (180/4), 20 for position (80/4)
       const playerSpeed = (this as any).speed();
+      const rawFrequency = (this as any).frequency;
+      const playerFrequency = typeof rawFrequency === 'function' ? rawFrequency() : rawFrequency;
+      const frequencyScale = playerFrequency > 0 ? Frequency.High / playerFrequency : 1;
+      const normalizedFrequencyScale = Number.isFinite(frequencyScale) && frequencyScale > 0 ? frequencyScale : 1;
 
       // Remove ALL movement strategies that could interfere with SeekAvoid
       // This includes SeekAvoid, Dash, Knockback, and LinearRepulsion
@@ -789,7 +794,7 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
           return body;
         };
         // Factor 45: with speed=4 gives 180 (original value)
-        const maxSpeed = playerSpeed * 45;
+        const maxSpeed = playerSpeed * 45 * normalizedFrequencyScale;
         map.moveManager.add(
           playerId,
           new SeekAvoid(engine, targetProvider, maxSpeed, 140, 80, 48)
@@ -804,7 +809,7 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
       staticTarget.freeze();
 
       // Factor 20: with speed=4 gives 80 (original value)
-      const maxSpeed = playerSpeed * 20;
+      const maxSpeed = playerSpeed * 20 * normalizedFrequencyScale;
       map.moveManager.add(
         playerId,
         new SeekAvoid(engine, () => staticTarget, maxSpeed, 140, 80, 48)
@@ -920,8 +925,8 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
         this.getActiveMovements().some(s => s instanceof Knockback || s instanceof AdditiveKnockback);
 
       const setAnimationName = (name: string): void => {
-        if (typeof selfAny.setAnimation === 'function') {
-          selfAny.setAnimation(name);
+        if (typeof selfAny.setGraphicAnimation === 'function') {
+          selfAny.setGraphicAnimation(name);
           return;
         }
         const animSignal = selfAny.animationName;
@@ -1178,6 +1183,9 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
           private readonly onStuck?: MoveRoutesOptions['onStuck'];
           private readonly stuckTimeout: number;
           private readonly stuckThreshold: number;
+          private remainingDistance = 0;
+          private segmentDirection: Direction | null = null;
+          private segmentStep = 0;
 
           // Frequency wait state
           private waitingForFrequency = false;
@@ -1219,6 +1227,9 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
             // Reset frequency wait state when processing a new route
             this.waitingForFrequency = false;
             this.frequencyWaitStartTime = 0;
+            this.remainingDistance = 0;
+            this.segmentDirection = null;
+            this.segmentStep = 0;
 
             // Check if we've completed all routes
             if (this.routeIndex >= this.routes.length) {
@@ -1323,52 +1334,15 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
                   }
                 }
 
-                // Calculate target top-left position
-                let targetTopLeftX = currentTopLeftX;
-                let targetTopLeftY = currentTopLeftY;
-
-                switch (moveDirection) {
-                  case Direction.Right:
-                  case 'right' as any:
-                    targetTopLeftX = currentTopLeftX + distance;
-                    break;
-                  case Direction.Left:
-                  case 'left' as any:
-                    targetTopLeftX = currentTopLeftX - distance;
-                    break;
-                  case Direction.Down:
-                  case 'down' as any:
-                    targetTopLeftY = currentTopLeftY + distance;
-                    break;
-                  case Direction.Up:
-                  case 'up' as any:
-                    targetTopLeftY = currentTopLeftY - distance;
-                    break;
-                }
-
-                // Convert target top-left to center position for physics engine
-                // Get entity to access hitbox dimensions
-                const entity = map.physic.getEntityByUUID(this.player.id);
-                if (!entity) {
-                  this.finished = true;
-                  this.onComplete(false);
-                  return;
-                }
-
-                // Get hitbox dimensions for conversion
-                const hitbox = this.player.hitbox();
-                const hitboxWidth = hitbox?.w ?? 32;
-                const hitboxHeight = hitbox?.h ?? 32;
-
-                // Convert top-left to center: center = topLeft + (size / 2)
-                const targetX = targetTopLeftX + hitboxWidth / 2;
-                const targetY = targetTopLeftY + hitboxHeight / 2;
-
-                this.currentTarget = { x: targetX, y: targetY }; // Center position for physics engine
-                this.currentTargetTopLeft = { x: targetTopLeftX, y: targetTopLeftY }; // Top-left position for player.x() comparison
-                this.currentDirection = { x: 0, y: 0 };
+                // Prepare segmented movement (per tile)
+                this.remainingDistance = distance;
+                this.segmentDirection = moveDirection;
+                this.segmentStep = this.getTileStepDistance(playerSpeed);
+                this.setNextSegmentTarget(currentTopLeftX, currentTopLeftY);
                 
-                this.debugLog(`MOVE direction=${moveDirection} from=(${currentTopLeftX.toFixed(1)}, ${currentTopLeftY.toFixed(1)}) to=(${targetTopLeftX.toFixed(1)}, ${targetTopLeftY.toFixed(1)}) dist=${distance.toFixed(1)}`);
+                if (this.currentTargetTopLeft) {
+                  this.debugLog(`MOVE direction=${moveDirection} from=(${currentTopLeftX.toFixed(1)}, ${currentTopLeftY.toFixed(1)}) to=(${this.currentTargetTopLeft.x.toFixed(1)}, ${this.currentTargetTopLeft.y.toFixed(1)}) dist=${distance.toFixed(1)}`);
+                }
                 
                 // Reset stuck detection when starting a new movement
                 this.lastPosition = null;
@@ -1415,7 +1389,13 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
 
               if (frequencyMs > 0 && Date.now() - this.frequencyWaitStartTime >= frequencyMs * this.ratioFrequency) {
                 this.waitingForFrequency = false;
-                this.processNextRoute();
+                if (this.remainingDistance > 0) {
+                  const currentTopLeftX = this.player.x();
+                  const currentTopLeftY = this.player.y();
+                  this.setNextSegmentTarget(currentTopLeftX, currentTopLeftY);
+                } else {
+                  this.processNextRoute();
+                }
               }
               return;
             }
@@ -1473,12 +1453,16 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
                 this.lastDistanceToTarget = null;
                 this.stuckCheckInitialized = false;
 
-                // Wait for frequency before processing next route
+                // Wait for frequency before processing next route or segment
                 if (!this.finished) {
                   const playerFrequency = this.player.frequency;
                   if (playerFrequency && playerFrequency > 0) {
                     this.waitingForFrequency = true;
                     this.frequencyWaitStartTime = Date.now();
+                  } else if (this.remainingDistance > 0) {
+                    const nextTopLeftX = this.player.x();
+                    const nextTopLeftY = this.player.y();
+                    this.setNextSegmentTarget(nextTopLeftX, nextTopLeftY);
                   } else {
                     // No frequency delay, process immediately
                     this.processNextRoute();
@@ -1505,12 +1489,16 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
                 this.lastDistanceToTarget = null;
                 this.stuckCheckInitialized = false;
 
-                // Wait for frequency before processing next route
+                // Wait for frequency before processing next route or segment
                 if (!this.finished) {
                   const playerFrequency = player.frequency;
                   if (playerFrequency && playerFrequency > 0) {
                     this.waitingForFrequency = true;
                     this.frequencyWaitStartTime = Date.now();
+                  } else if (this.remainingDistance > 0) {
+                    const nextTopLeftX = this.player.x();
+                    const nextTopLeftY = this.player.y();
+                    this.setNextSegmentTarget(nextTopLeftX, nextTopLeftY);
                   } else {
                     // No frequency delay, process immediately
                     this.processNextRoute();
@@ -1623,6 +1611,10 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
                 if (playerFrequency && playerFrequency > 0) {
                   this.waitingForFrequency = true;
                   this.frequencyWaitStartTime = Date.now();
+                } else if (this.remainingDistance > 0) {
+                  const nextTopLeftX = this.player.x();
+                  const nextTopLeftY = this.player.y();
+                  this.setNextSegmentTarget(nextTopLeftX, nextTopLeftY);
                 } else {
                   // No frequency delay, process immediately
                   this.processNextRoute();
@@ -1652,6 +1644,69 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
           onFinished(): void {
             this.onComplete(true);
           }
+
+          private getTileStepDistance(playerSpeed: number): number {
+            if (!Number.isFinite(playerSpeed) || playerSpeed <= 0) {
+              return this.tileSize;
+            }
+            const stepsPerTile = Math.max(1, Math.floor(this.tileSize / playerSpeed));
+            return stepsPerTile * playerSpeed;
+          }
+
+          private setNextSegmentTarget(currentTopLeftX: number, currentTopLeftY: number): void {
+            if (!this.segmentDirection || this.remainingDistance <= 0) {
+              return;
+            }
+
+            const map = this.player.getCurrentMap() as any;
+            if (!map) {
+              this.finished = true;
+              this.onComplete(false);
+              return;
+            }
+
+            const entity = map.physic.getEntityByUUID(this.player.id);
+            if (!entity) {
+              this.finished = true;
+              this.onComplete(false);
+              return;
+            }
+
+            const segmentDistance = Math.min(this.segmentStep || this.remainingDistance, this.remainingDistance);
+            let targetTopLeftX = currentTopLeftX;
+            let targetTopLeftY = currentTopLeftY;
+
+            switch (this.segmentDirection) {
+              case Direction.Right:
+              case 'right' as any:
+                targetTopLeftX = currentTopLeftX + segmentDistance;
+                break;
+              case Direction.Left:
+              case 'left' as any:
+                targetTopLeftX = currentTopLeftX - segmentDistance;
+                break;
+              case Direction.Down:
+              case 'down' as any:
+                targetTopLeftY = currentTopLeftY + segmentDistance;
+                break;
+              case Direction.Up:
+              case 'up' as any:
+                targetTopLeftY = currentTopLeftY - segmentDistance;
+                break;
+            }
+
+            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.remainingDistance -= segmentDistance;
+          }
         }
 
         // Create and add the route movement strategy
@@ -1948,4 +2003,3 @@ export interface IMoveManager {
    */
   replayRoutes(): void;
 }
-

package/src/Player/ParameterManager.ts

@@ -1,7 +1,14 @@
 import { isString, PlayerCtor } from "@rpgjs/common";
 import { signal, computed, WritableSignal, ComputedSignal } from "@signe/reactive";
 import { MAXHP, MAXSP } from "@rpgjs/common";
-import { sync, type } from "@signe/sync";
+import { type } from "@signe/sync";
+
+export type ExpCurve = {
+  basis: number;
+  extra: number;
+  accelerationA: number;
+  accelerationB: number;
+};
 
 /**
  * Interface for Parameter Manager functionality
@@ -53,12 +60,7 @@ export interface IParameterManager {
    * ```
    * @memberof ParameterManager
    * */
-  expCurve: { 
-    basis: number,
-    extra: number,
-    accelerationA: number
-    accelerationB: number
-  };
+  expCurve: ExpCurve;
 
   /** 
    * Changes the health points
@@ -393,12 +395,12 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
      * console.log(player.param[MAXHP]); // Updated value
      * ```
      */
-    private _paramsModifierSignal = signal<{
+    private _paramsModifierSignal = type(signal<{
         [key: string]: {
             value?: number,
             rate?: number
         }
-    }>({})
+    }>({}) as any, '_paramsModifierSignal', { persist: true }, this as any)
 
     /**
      * Signal for base parameters configuration
@@ -406,12 +408,12 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
      * Stores the start and end values for each parameter's level curve.
      * Changes to this signal trigger recalculation of all parameter values.
      */
-    private _parametersSignal = signal<{
+    private _parametersSignal = type(signal<{
         [key: string]: {
             start: number,
             end: number
         }
-    }>({})
+    }>({}) as any, '_parametersSignal', { persist: true }, this as any)
 
     /**
      * Computed signal for all parameter values
@@ -432,13 +434,12 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
     _param = type(computed(() => {
         const obj = {}
         const parameters = this._parametersSignal()
+        const allModifiers = this._getAggregatedModifiers()
         const level = this._level()
         
         for (const [name, paramConfig] of Object.entries(parameters)) {
             let curveVal = Math.floor((paramConfig.end - paramConfig.start) * ((level - 1) / (this.finalLevel - this.initialLevel))) + paramConfig.start
             
-            // Apply modifiers from equipment, states, etc.
-            const allModifiers = this._getAggregatedModifiers()
             const modifier = allModifiers[name]
             if (modifier) {
                 if (modifier.rate) curveVal *= modifier.rate
@@ -548,11 +549,14 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
      * ```
      * @memberof ParameterManager
      * */
-    public expCurve: { 
-        basis: number,
-        extra: number,
-        accelerationA: number
-        accelerationB: number
+    public _expCurveSignal = type(signal<string>('') as any, '_expCurveSignal', { persist: true }, this as any)
+
+    get expCurve(): ExpCurve { 
+        return JSON.parse(this._expCurveSignal())
+    }
+
+    set expCurve(val: ExpCurve) {
+        this._expCurveSignal.set(JSON.stringify(val)) 
     }
     
     /** 
@@ -686,7 +690,6 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
     get level(): number {
         return this._level()
     }
-
      /** 
      * ```ts
      * console.log(player.expForNextlevel) // 150
@@ -903,4 +906,4 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
         this.recovery({ hp: 1, sp: 1 })
     }
   } as unknown as TBase;
-}
+}

package/src/Player/Player.ts

@@ -186,21 +186,6 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
 
   constructor() {
     super();
-    // Use type assertion to access mixin properties
-    (this as any).expCurve = {
-      basis: 30,
-      extra: 20,
-      accelerationA: 30,
-      accelerationB: 30
-    };
-
-    (this as any).addParameter(MAXHP, MAXHP_CURVE);
-    (this as any).addParameter(MAXSP, MAXSP_CURVE);
-    (this as any).addParameter(STR, STR_CURVE);
-    (this as any).addParameter(INT, INT_CURVE);
-    (this as any).addParameter(DEX, DEX_CURVE);
-    (this as any).addParameter(AGI, AGI_CURVE);
-    (this as any).allRecovery();
 
     let lastEmitted: { x: number; y: number } | null = null;
     let pendingUpdate: { x: number; y: number } | null = null;
@@ -238,6 +223,24 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     this.hooks.callHooks("server-playerProps-load", this).subscribe();
   }
 
+  onGameStart() {
+    // Use type assertion to access mixin properties
+    (this as any).expCurve = {
+      basis: 30,
+      extra: 20,
+      accelerationA: 30,
+      accelerationB: 30
+    };
+
+    ;(this as any).addParameter(MAXHP, MAXHP_CURVE);
+    (this as any).addParameter(MAXSP, MAXSP_CURVE);
+    (this as any).addParameter(STR, STR_CURVE);
+    (this as any).addParameter(INT, INT_CURVE);
+    (this as any).addParameter(DEX, DEX_CURVE);
+    (this as any).addParameter(AGI, AGI_CURVE);
+    (this as any).allRecovery();
+  }
+
   get hooks() {
     return inject<Hooks>(this.context as any, ModulesToken);
   }
@@ -415,7 +418,12 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   }
 
   snapshot() {
-    return createStatesSnapshotDeep(this);
+    const snapshot = createStatesSnapshotDeep(this);
+    const expCurve = (this as any).expCurve;
+    if (expCurve) {
+      snapshot.expCurve = { ...expCurve };
+    }
+    return snapshot;
   }
 
   async applySnapshot(snapshot: string | object) {
@@ -426,6 +434,9 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     const withClass = (this as any).resolveClassSnapshot?.(withStates) ?? withStates;
     const resolvedSnapshot = (this as any).resolveEquipmentsSnapshot?.(withClass) ?? withClass;
     load(this, resolvedSnapshot);
+    if (resolvedSnapshot.expCurve) {
+      (this as any).expCurve = resolvedSnapshot.expCurve;
+    }
     if (Array.isArray(resolvedSnapshot.items)) {
       this.items.set(resolvedSnapshot.items);
     }
@@ -1258,6 +1269,12 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
 }
 
 export class RpgEvent extends RpgPlayer {
+
+  constructor() {
+    super();
+    this.onGameStart()
+  }
+
   override async execMethod(methodName: string, methodData: any[] = [], instance = this) {
     await lastValueFrom(this.hooks
       .callHooks(`server-event-${methodName}`, instance, ...methodData));

package/src/RpgServer.ts

@@ -696,10 +696,10 @@ export interface RpgServer {
      * })
      * ``` 
      * 
-     * @prop { { [dataName]: data } } [database]
+     * @prop { { [dataName]: data } | (engine: RpgMap) => { [dataName]: data } | Promise<{ [dataName]: data }> } [database]
      * @memberof RpgServer
      * */
-    database?: object | any[],
+    database?: object | any[] | ((engine: RpgMap) => object | any[] | Promise<object | any[]>),
 
     /** 
      * Array of all maps. Each element can be either a class (decorated with `@MapData` or not) or a `MapOptions` object

package/src/module.ts

@@ -127,14 +127,20 @@ export function provideServerModules(modules: RpgServerModule[]): FactoryProvide
           }
         };
       }
-      if (module.database && typeof module.database === 'object') {
-        const database = {...module.database};
+      if (module.database) {
+        const database = module.database;
         module = {
           ...module,
           databaseHooks: {
-            load: (engine: RpgMap) => {
-              for (const key in database) {
-                engine.addInDatabase(key, database[key]);
+            load: async (engine: RpgMap) => {
+              const data = typeof database === 'function'
+                ? await database(engine)
+                : database;
+              if (!data || typeof data !== 'object') {
+                return;
+              }
+              for (const key in data) {
+                engine.addInDatabase(key, data[key]);
               }
             },
           }
@@ -145,4 +151,4 @@ export function provideServerModules(modules: RpgServerModule[]): FactoryProvide
     return modules
   });
 }
- 
+ 

package/src/rooms/lobby.ts

@@ -35,6 +35,7 @@ export class LobbyRoom extends BaseRoom {
   async guiInteraction(player: RpgPlayer, value: { guiId: string, name: string, data: any }) {
     const id = value.data.id
     if (id === 'start') {
+      player.onGameStart();
       this.hooks.callHooks("server-player-onStart", player).subscribe();
     }
   }