@rpgjs/server 5.0.0-alpha.31 → 5.0.0-alpha.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-alpha.31",
+  "version": "5.0.0-alpha.33",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,14 +11,14 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.31",
-    "@rpgjs/physic": "5.0.0-alpha.31",
-    "@rpgjs/testing": "5.0.0-alpha.31",
+    "@rpgjs/common": "5.0.0-alpha.33",
+    "@rpgjs/physic": "5.0.0-alpha.33",
+    "@rpgjs/testing": "5.0.0-alpha.33",
     "@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"
   },

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/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/MoveManager.ts

@@ -1183,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;
@@ -1224,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) {
@@ -1328,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;
@@ -1420,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;
             }
@@ -1478,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();
@@ -1510,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();
@@ -1628,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();
@@ -1657,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

package/src/Player/ParameterManager.ts

@@ -434,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
@@ -691,7 +690,6 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
     get level(): number {
         return this._level()
     }
-
      /** 
      * ```ts
      * console.log(player.expForNextlevel) // 150

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/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);
   });
-});
+});