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

package/dist/Player/ParameterManager.d.ts

@@ -1,4 +1,10 @@
 import { PlayerCtor } from '../../../common/src';
+export type ExpCurve = {
+    basis: number;
+    extra: number;
+    accelerationA: number;
+    accelerationB: number;
+};
 /**
  * Interface for Parameter Manager functionality
  *
@@ -47,12 +53,7 @@ export interface IParameterManager {
      * ```
      * @memberof ParameterManager
      * */
-    expCurve: {
-        basis: number;
-        extra: number;
-        accelerationA: number;
-        accelerationB: number;
-    };
+    expCurve: ExpCurve;
     /**
      * Changes the health points
      * - Cannot exceed the MaxHP parameter

package/dist/Player/Player.d.ts

@@ -94,6 +94,7 @@ export declare class RpgPlayer extends RpgPlayer_base {
     events: import('@signe/reactive').WritableArraySignal<RpgEvent[]>;
     constructor();
     _onInit(): void;
+    onGameStart(): void;
     get hooks(): Hooks;
     get server(): RpgMap | null;
     setMap(map: RpgMap): void;
@@ -502,6 +503,7 @@ export declare class RpgPlayer extends RpgPlayer_base {
     isEvent(): boolean;
 }
 export declare class RpgEvent extends RpgPlayer {
+    constructor();
     execMethod(methodName: string, methodData?: any[], instance?: this): Promise<any>;
     /**
      * Remove this event from the map

package/dist/RpgServer.d.ts

@@ -659,10 +659,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/dist/index.js

@@ -17005,13 +17005,13 @@ class RpgCommonMap {
       const ownerHasAnimationName = animationNameSignal && typeof animationNameSignal === "object" && typeof animationNameSignal.set === "function";
       if (isMoving && intensity > LOW_INTENSITY_THRESHOLD) {
         if (hasSetAnimation) {
-          owner2.setAnimation("walk");
+          owner2.setGraphicAnimation("walk");
         } else if (ownerHasAnimationName) {
           animationNameSignal.set("walk");
         }
       } else if (!isMoving) {
         if (hasSetAnimation) {
-          owner2.setAnimation("stand");
+          owner2.setGraphicAnimation("stand");
         } else if (ownerHasAnimationName) {
           animationNameSignal.set("stand");
         }
@@ -19118,7 +19118,8 @@ function WithMoveManager(Base) {
      * 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
      * 
@@ -19137,6 +19138,10 @@ function WithMoveManager(Base) {
       const playerId = this.id;
       const engine = map.physic;
       const playerSpeed = this.speed();
+      const rawFrequency = this.frequency;
+      const playerFrequency = typeof rawFrequency === "function" ? rawFrequency() : rawFrequency;
+      const frequencyScale = playerFrequency > 0 ? 100 /* High */ / playerFrequency : 1;
+      const normalizedFrequencyScale = Number.isFinite(frequencyScale) && frequencyScale > 0 ? frequencyScale : 1;
       const existingStrategies = this.getActiveMovements();
       const conflictingStrategies = existingStrategies.filter(
         (s) => s instanceof SeekAvoid || s instanceof Dash || s instanceof Knockback || s instanceof LinearRepulsion
@@ -19149,7 +19154,7 @@ function WithMoveManager(Base) {
           const body = map.getBody(target.id) ?? null;
           return body;
         };
-        const maxSpeed2 = playerSpeed * 45;
+        const maxSpeed2 = playerSpeed * 45 * normalizedFrequencyScale;
         map.moveManager.add(
           playerId,
           new SeekAvoid(engine, targetProvider, maxSpeed2, 140, 80, 48)
@@ -19161,7 +19166,7 @@ function WithMoveManager(Base) {
         mass: Infinity
       });
       staticTarget.freeze();
-      const maxSpeed = playerSpeed * 20;
+      const maxSpeed = playerSpeed * 20 * normalizedFrequencyScale;
       map.moveManager.add(
         playerId,
         new SeekAvoid(engine, () => staticTarget, maxSpeed, 140, 80, 48)
@@ -19259,8 +19264,8 @@ function WithMoveManager(Base) {
       };
       const hasActiveKnockback = () => this.getActiveMovements().some((s) => s instanceof Knockback || s instanceof AdditiveKnockback);
       const setAnimationName = (name) => {
-        if (typeof selfAny.setAnimation === "function") {
-          selfAny.setAnimation(name);
+        if (typeof selfAny.setGraphicAnimation === "function") {
+          selfAny.setGraphicAnimation(name);
           return;
         }
         const animSignal = selfAny.animationName;
@@ -19471,6 +19476,9 @@ function WithMoveManager(Base) {
             this.waitingForPromise = false;
             this.promiseStartTime = 0;
             this.promiseDuration = 0;
+            this.remainingDistance = 0;
+            this.segmentDirection = null;
+            this.segmentStep = 0;
             // Frequency wait state
             this.waitingForFrequency = false;
             this.frequencyWaitStartTime = 0;
@@ -19497,6 +19505,9 @@ function WithMoveManager(Base) {
           processNextRoute() {
             this.waitingForFrequency = false;
             this.frequencyWaitStartTime = 0;
+            this.remainingDistance = 0;
+            this.segmentDirection = null;
+            this.segmentStep = 0;
             if (this.routeIndex >= this.routes.length) {
               this.debugLog("COMPLETE all routes finished");
               this.finished = true;
@@ -19573,41 +19584,13 @@ function WithMoveManager(Base) {
                     break;
                   }
                 }
-                let targetTopLeftX = currentTopLeftX;
-                let targetTopLeftY = currentTopLeftY;
-                switch (moveDirection) {
-                  case Direction.Right:
-                  case "right":
-                    targetTopLeftX = currentTopLeftX + distance;
-                    break;
-                  case Direction.Left:
-                  case "left":
-                    targetTopLeftX = currentTopLeftX - distance;
-                    break;
-                  case Direction.Down:
-                  case "down":
-                    targetTopLeftY = currentTopLeftY + distance;
-                    break;
-                  case Direction.Up:
-                  case "up":
-                    targetTopLeftY = currentTopLeftY - distance;
-                    break;
-                }
-                const entity = map.physic.getEntityByUUID(this.player.id);
-                if (!entity) {
-                  this.finished = true;
-                  this.onComplete(false);
-                  return;
+                this.remainingDistance = distance;
+                this.segmentDirection = moveDirection;
+                this.segmentStep = this.getTileStepDistance(playerSpeed);
+                this.setNextSegmentTarget(currentTopLeftX, currentTopLeftY);
+                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)}`);
                 }
-                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.debugLog(`MOVE direction=${moveDirection} from=(${currentTopLeftX.toFixed(1)}, ${currentTopLeftY.toFixed(1)}) to=(${targetTopLeftX.toFixed(1)}, ${targetTopLeftY.toFixed(1)}) dist=${distance.toFixed(1)}`);
                 this.lastPosition = null;
                 this.isCurrentlyStuck = false;
                 this.stuckCheckStartTime = 0;
@@ -19643,7 +19626,13 @@ function WithMoveManager(Base) {
               const frequencyMs = playerFrequency || 0;
               if (frequencyMs > 0 && Date.now() - this.frequencyWaitStartTime >= frequencyMs * this.ratioFrequency) {
                 this.waitingForFrequency = false;
-                this.processNextRoute();
+                if (this.remainingDistance > 0) {
+                  const currentTopLeftX2 = this.player.x();
+                  const currentTopLeftY2 = this.player.y();
+                  this.setNextSegmentTarget(currentTopLeftX2, currentTopLeftY2);
+                } else {
+                  this.processNextRoute();
+                }
               }
               return;
             }
@@ -19691,6 +19680,10 @@ function WithMoveManager(Base) {
                   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 {
                     this.processNextRoute();
                   }
@@ -19715,6 +19708,10 @@ function WithMoveManager(Base) {
                   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 {
                     this.processNextRoute();
                   }
@@ -19789,6 +19786,10 @@ function WithMoveManager(Base) {
                 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 {
                   this.processNextRoute();
                 }
@@ -19811,6 +19812,60 @@ function WithMoveManager(Base) {
           onFinished() {
             this.onComplete(true);
           }
+          getTileStepDistance(playerSpeed) {
+            if (!Number.isFinite(playerSpeed) || playerSpeed <= 0) {
+              return this.tileSize;
+            }
+            const stepsPerTile = Math.max(1, Math.floor(this.tileSize / playerSpeed));
+            return stepsPerTile * playerSpeed;
+          }
+          setNextSegmentTarget(currentTopLeftX, currentTopLeftY) {
+            if (!this.segmentDirection || this.remainingDistance <= 0) {
+              return;
+            }
+            const map = this.player.getCurrentMap();
+            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":
+                targetTopLeftX = currentTopLeftX + segmentDistance;
+                break;
+              case Direction.Left:
+              case "left":
+                targetTopLeftX = currentTopLeftX - segmentDistance;
+                break;
+              case Direction.Down:
+              case "down":
+                targetTopLeftY = currentTopLeftY + segmentDistance;
+                break;
+              case Direction.Up:
+              case "up":
+                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;
+          }
         }
         const routeStrategy = new RouteMovementStrategy(
           finalRoutes,
@@ -20173,7 +20228,7 @@ class MenuGui extends Gui {
       spCost: skill?.spCost() ?? 0
     }));
     const saveLoad = this.buildSaveLoad(options);
-    return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats() };
+    return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats(), expForNextlevel: player2.expForNextlevel };
   }
   refreshMenu(clientActionId) {
     const data = this.buildMenuData(this.menuOptions);
@@ -20635,14 +20690,14 @@ function WithParameterManager(Base) {
        * console.log(player.param[MAXHP]); // Updated value
        * ```
        */
-      this._paramsModifierSignal = signal({});
+      this._paramsModifierSignal = type(signal({}), "_paramsModifierSignal", { persist: true }, this);
       /**
        * Signal for base parameters configuration
        * 
        * Stores the start and end values for each parameter's level curve.
        * Changes to this signal trigger recalculation of all parameter values.
        */
-      this._parametersSignal = signal({});
+      this._parametersSignal = type(signal({}), "_parametersSignal", { persist: true }, this);
       /**
        * Computed signal for all parameter values
        * 
@@ -20662,10 +20717,10 @@ function WithParameterManager(Base) {
       this._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;
-          const allModifiers = this._getAggregatedModifiers();
           const modifier = allModifiers[name];
           if (modifier) {
             if (modifier.rate) curveVal *= modifier.rate;
@@ -20697,6 +20752,26 @@ function WithParameterManager(Base) {
        * @memberof ParameterManager
        * */
       this.finalLevel = 99;
+      /** 
+       * With Object-based syntax, you can use following options:
+       * - `basis: number`
+       * - `extra: number`
+       * - `accelerationA: number`
+       * - `accelerationB: number`
+       * @title Change Experience Curve
+       * @prop {object} player.expCurve
+       * @default 
+       *  ```ts
+       * {
+       *      basis: 30,
+       *      extra: 20,
+       *      accelerationA: 30,
+       *      accelerationB: 30
+       * }
+       * ```
+       * @memberof ParameterManager
+       * */
+      this._expCurveSignal = type(signal(""), "_expCurveSignal", { persist: true }, this);
     }
     /**
      * Aggregates parameter modifiers from all sources (direct modifiers, states, equipment)
@@ -20744,6 +20819,12 @@ function WithParameterManager(Base) {
       }
       return params;
     }
+    get expCurve() {
+      return JSON.parse(this._expCurveSignal());
+    }
+    set expCurve(val) {
+      this._expCurveSignal.set(JSON.stringify(val));
+    }
     /** 
      * Changes the health points
      * - Cannot exceed the MaxHP parameter
@@ -22284,19 +22365,6 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     this._lastFramePositions = null;
     this.frames = [];
     this.events = signal([]);
-    this.expCurve = {
-      basis: 30,
-      extra: 20,
-      accelerationA: 30,
-      accelerationB: 30
-    };
-    this.addParameter(MAXHP, MAXHP_CURVE);
-    this.addParameter(MAXSP, MAXSP_CURVE);
-    this.addParameter(STR, STR_CURVE);
-    this.addParameter(INT, INT_CURVE);
-    this.addParameter(DEX, DEX_CURVE);
-    this.addParameter(AGI, AGI_CURVE);
-    this.allRecovery();
     let lastEmitted = null;
     let pendingUpdate = null;
     let updateScheduled = false;
@@ -22375,6 +22443,21 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   _onInit() {
     this.hooks.callHooks("server-playerProps-load", this).subscribe();
   }
+  onGameStart() {
+    this.expCurve = {
+      basis: 30,
+      extra: 20,
+      accelerationA: 30,
+      accelerationB: 30
+    };
+    this.addParameter(MAXHP, MAXHP_CURVE);
+    this.addParameter(MAXSP, MAXSP_CURVE);
+    this.addParameter(STR, STR_CURVE);
+    this.addParameter(INT, INT_CURVE);
+    this.addParameter(DEX, DEX_CURVE);
+    this.addParameter(AGI, AGI_CURVE);
+    this.allRecovery();
+  }
   get hooks() {
     return inject$1(this.context, ModulesToken);
   }
@@ -22522,7 +22605,12 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     });
   }
   snapshot() {
-    return createStatesSnapshotDeep(this);
+    const snapshot = createStatesSnapshotDeep(this);
+    const expCurve = this.expCurve;
+    if (expCurve) {
+      snapshot.expCurve = { ...expCurve };
+    }
+    return snapshot;
   }
   async applySnapshot(snapshot) {
     const data = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
@@ -22532,6 +22620,9 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     const withClass = this.resolveClassSnapshot?.(withStates) ?? withStates;
     const resolvedSnapshot = this.resolveEquipmentsSnapshot?.(withClass) ?? withClass;
     load(this, resolvedSnapshot);
+    if (resolvedSnapshot.expCurve) {
+      this.expCurve = resolvedSnapshot.expCurve;
+    }
     if (Array.isArray(resolvedSnapshot.items)) {
       this.items.set(resolvedSnapshot.items);
     }
@@ -23222,6 +23313,10 @@ __decorateClass$3([
 ], _RpgPlayer.prototype, "events");
 let RpgPlayer = _RpgPlayer;
 class RpgEvent extends RpgPlayer {
+  constructor() {
+    super();
+    this.onGameStart();
+  }
   async execMethod(methodName, methodData = [], instance = this) {
     await lastValueFrom(this.hooks.callHooks(`server-event-${methodName}`, instance, ...methodData));
     if (!instance[methodName]) {
@@ -29491,6 +29586,7 @@ let LobbyRoom = class extends BaseRoom {
   async guiInteraction(player, value) {
     const id = value.data.id;
     if (id === "start") {
+      player.onGameStart();
       this.hooks.callHooks("server-player-onStart", player).subscribe();
     }
   }
@@ -29828,14 +29924,18 @@ function provideServerModules(modules) {
           }
         };
       }
-      if (module.database && typeof module.database === "object") {
-        const database = { ...module.database };
+      if (module.database) {
+        const database = module.database;
         module = {
           ...module,
           databaseHooks: {
-            load: (engine) => {
-              for (const key in database) {
-                engine.addInDatabase(key, database[key]);
+            load: async (engine) => {
+              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]);
               }
             }
           }