@rpgjs/server 5.0.0-beta.3 → 5.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.4",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -22,9 +22,9 @@
   "description": "",
   "dependencies": {
     "@canvasengine/tiled": "2.0.0-beta.58",
-    "@rpgjs/common": "5.0.0-beta.3",
-    "@rpgjs/physic": "5.0.0-beta.3",
-    "@rpgjs/testing": "5.0.0-beta.3",
+    "@rpgjs/common": "5.0.0-beta.4",
+    "@rpgjs/physic": "5.0.0-beta.4",
+    "@rpgjs/testing": "5.0.0-beta.4",
     "@rpgjs/database": "^4.3.0",
     "@signe/di": "^2.9.0",
     "@signe/reactive": "^2.9.0",

package/src/Gui/MenuGui.ts

@@ -22,6 +22,16 @@ export interface MenuGuiOptions {
     saveAutoSlotLabel?: string
 }
 
+function readReactiveValue(value: any, context?: any) {
+    return typeof value === 'function' ? value.call(context) : value
+}
+
+function readField(source: any, key: string, fallback?: any) {
+    const value = source?.[key]
+    const resolved = readReactiveValue(value, source)
+    return resolved ?? fallback
+}
+
 export class MenuGui extends Gui {
     private menuOptions: MenuGuiOptions = {}
 
@@ -61,7 +71,7 @@ export class MenuGui extends Gui {
         const player = this.player as any
         const databaseById = player.databaseById?.bind(player)
         const equippedIds = new Set(
-            (player.equipments?.() || []).map((it) => it?.id?.() ?? it?.id ?? it?.name)
+            (player.equipments?.() || []).map((it) => readField(it, 'id', readField(it, 'name')))
         )
 
         const buildStats = () => {
@@ -76,19 +86,19 @@ export class MenuGui extends Gui {
             ]
             const stats: Record<string, number> = {}
             statKeys.forEach((key) => {
-                stats[key] = params[key] ?? 0
+                stats[key] = readReactiveValue(params[key]) ?? 0
             })
-            stats.pdef = player.pdef ?? params.pdef ?? 0
-            stats.sdef = player.sdef ?? params.sdef ?? 0
-            stats.atk = player.atk ?? params.atk ?? 0
+            stats.pdef = readReactiveValue(player.pdef ?? params.pdef) ?? 0
+            stats.sdef = readReactiveValue(player.sdef ?? params.sdef) ?? 0
+            stats.atk = readReactiveValue(player.atk ?? params.atk) ?? 0
             return stats
         }
 
         const items = (player.items?.() || []).map((item) => {
-            const id = item.id()
+            const id = readField(item, 'id')
             const data = databaseById ? databaseById(id) : {}
-            const type = data?._type ?? 'item'
-            const consumable = data?.consumable
+            const type = readField(data, '_type', 'item')
+            const consumable = readField(data, 'consumable')
             const isConsumable = consumable !== undefined ? consumable : type === 'item'
             const usable = isConsumable === false
                 ? false
@@ -97,13 +107,13 @@ export class MenuGui extends Gui {
                     : true
             return {
                 id,
-                name: item.name(),
-                description: item.description(),
-                quantity: item.quantity(),
-                icon: data?.icon ?? (item as any)?.icon,
-                atk: item.atk(),
-                pdef: item.pdef(),
-                sdef: item.sdef(),
+                name: readField(item, 'name'),
+                description: readField(item, 'description'),
+                quantity: readField(item, 'quantity'),
+                icon: readField(data, 'icon', readField(item, 'icon')),
+                atk: readField(item, 'atk'),
+                pdef: readField(item, 'pdef'),
+                sdef: readField(item, 'sdef'),
                 consumable: isConsumable,
                 type,
                 usable,
@@ -112,14 +122,14 @@ export class MenuGui extends Gui {
         })
         const menuEquips = items.filter((item) => item.type === 'weapon' || item.type === 'armor')
         const skills = (player.skills?.() || []).map((skill) => ({
-            id: skill?.id() ?? skill?.name(),
-            name: skill?.name() ?? skill?.id() ?? 'Skill',
-            description: skill?.description() ?? '',
-            spCost: skill?.spCost() ?? 0
+            id: readField(skill, 'id', readField(skill, 'name')),
+            name: readField(skill, 'name', readField(skill, 'id', 'Skill')),
+            description: readField(skill, 'description', ''),
+            spCost: readField(skill, 'spCost', 0)
         }))
         const saveLoad = this.buildSaveLoad(options)
 
-        return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats(), expForNextlevel: player.expForNextlevel }
+        return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats(), expForNextlevel: readReactiveValue(player.expForNextlevel) }
     }
 
     private refreshMenu(clientActionId?: string) {

package/src/Player/ParameterManager.ts

@@ -753,7 +753,10 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
             for (let i = this._level() ; i <= val; i++) {
                 for (let skill of currentClass.skillsToLearn as any[]) {
                     if (skill.level == i) {
-                        this['learnSkill'](skill.skill)
+                        this['learnSkill'](skill.skill, {
+                            source: skill.source ?? 'level',
+                            level: i
+                        })
                     }
                 }
             }

package/src/Player/Player.ts

@@ -778,6 +778,8 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
           graphic,
           nbTimes: finalNbTimes,
           object: this.id,
+          restoreAnimationName: this.animationName(),
+          restoreGraphics: [...this.graphics()],
         },
       });
     }

package/src/Player/SkillManager.ts

@@ -12,7 +12,20 @@ import { Effect } from "./EffectManager";
 /**
  * Type for skill class constructor
  */
-type SkillClass = { new (...args: any[]): any };
+export type SkillClass = { new (...args: any[]): any };
+
+export type SkillChangeAction = "learn" | "forget";
+
+export interface SkillChangeOptions {
+  source?: "manual" | "level" | "class" | "studio" | string;
+  level?: number;
+}
+
+export interface SkillChangePayload extends SkillChangeOptions {
+  action: SkillChangeAction;
+  skill: SkillClass | SkillObject | string;
+  skillId: string;
+}
 
 /**
  * Interface defining the hooks that can be implemented on skill classes or objects
@@ -430,7 +443,10 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
      * });
      * ```
      */
-    learnSkill(skillInput: SkillClass | SkillObject | string): any {
+    learnSkill(
+      skillInput: SkillClass | SkillObject | string,
+      options: SkillChangeOptions = {},
+    ): any {
       const map = this._getSkillMap();
       const { skillId, skillData, skillInstance } = this._resolveSkillInput(skillInput, map);
 
@@ -446,6 +462,15 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       // Call onLearn hook
       const hookTarget = (instance as any)._skillInstance || instance;
       this["execMethod"]("onLearn", [this], hookTarget);
+      this["execMethod"]("onSkillChange", [
+        {
+          action: "learn",
+          skill: skillData,
+          skillId,
+          source: options.source ?? "manual",
+          level: options.level,
+        },
+      ]);
       
       return skillData;
     }
@@ -466,7 +491,10 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
      * player.forgetSkill(FireSkill);
      * ```
      */
-    forgetSkill(skillInput: SkillClass | SkillObject | string): any {
+    forgetSkill(
+      skillInput: SkillClass | SkillObject | string,
+      options: SkillChangeOptions = {},
+    ): any {
       const index = this._getSkillIndex(skillInput);
       
       if (index === -1) {
@@ -494,6 +522,15 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
         (skillEntry as any)?._skillData ||
         skillData;
       this["execMethod"]("onForget", [this], hookTarget);
+      this["execMethod"]("onSkillChange", [
+        {
+          action: "forget",
+          skill: skillData,
+          skillId: skillData?.id ?? String(skillInput),
+          source: options.source ?? "manual",
+          level: options.level,
+        },
+      ]);
       
       return skillData;
     }
@@ -607,7 +644,7 @@ export interface ISkillManager {
    * @returns The learned skill data
    * @throws SkillLog.alreadyLearned if the player already knows the skill
    */
-  learnSkill(skillInput: SkillClass | SkillObject | string): any;
+  learnSkill(skillInput: SkillClass | SkillObject | string, options?: SkillChangeOptions): any;
 
   /**
    * Forget a skill
@@ -616,7 +653,7 @@ export interface ISkillManager {
    * @returns The forgotten skill data
    * @throws SkillLog.notLearned if trying to forget a skill not learned
    */
-  forgetSkill(skillInput: SkillClass | SkillObject | string): any;
+  forgetSkill(skillInput: SkillClass | SkillObject | string, options?: SkillChangeOptions): any;
 
   /**
    * Use a skill

package/src/RpgServer.ts

@@ -4,6 +4,7 @@ import { type RpgMap } from "./rooms/map"
 import { RpgServerEngine } from "./RpgServerEngine"
 import { WorldMapConfig, RpgShape, type MapPhysicsInitContext, type MapPhysicsEntityContext } from "@rpgjs/common"
 import { RpgEvent } from "./Player/Player"
+import type { SkillChangePayload } from "./Player/SkillManager"
 
 type RpgClassMap<T> = new () => T
 type RpgClassEvent<T> = RpgEvent
@@ -210,6 +211,14 @@ export interface RpgPlayerHooks {
     */
     onLevelUp?: (player: RpgPlayer, nbLevel: number) => any
 
+    /**
+    *  When a player learns or forgets a skill
+    * 
+    * @prop { (player: RpgPlayer, payload: SkillChangePayload) => any } [onSkillChange]
+    * @memberof RpgPlayerHooks
+    */
+    onSkillChange?: (player: RpgPlayer, payload: SkillChangePayload) => any
+
     /**
     *  When the player's HP drops to 0
     * 

package/src/rooms/lobby.ts

@@ -36,7 +36,12 @@ export class LobbyRoom extends BaseRoom {
     const id = value.data.id
     if (id === 'start') {
       player.initializeDefaultStats();
-      this.hooks.callHooks("server-player-onStart", player).subscribe();
+      try {
+        await lastValueFrom(this.hooks.callHooks("server-player-onStart", player));
+      }
+      catch (error) {
+        console.error("[RPGJS] Error during player onStart hooks:", error);
+      }
     }
   }
 }

package/src/rooms/map.ts

@@ -1091,6 +1091,13 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    */
   @Action('move')
   async onInput(player: RpgPlayer, input: any) {
+    if (typeof player.canMove === "function" && !player.canMove()) {
+      player.pendingInputs = [];
+      player.lastProcessedInputTs = 0;
+      (this as any).stopMovement(player);
+      return;
+    }
+
     const lastAckedFrame = player._lastFramePositions?.frame ?? 0;
     const now = Date.now();
     const candidates: Array<{
@@ -1525,6 +1532,16 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       }
     }
 
+    if (typeof player.canMove === "function" && !player.canMove()) {
+      player.pendingInputs = [];
+      player.lastProcessedInputTs = 0;
+      (this as any).stopMovement(player);
+      return {
+        player,
+        inputs: []
+      }
+    }
+
     const processedInputs: string[] = [];
     const defaultControls: Required<Controls> = {
       maxTimeDelta: 1000, // 1 second max between inputs

package/tests/gui.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "vitest";
+import { MenuGui, signal } from "../src";
+
+describe("GUI", () => {
+  test("main menu sends cloneable data when inventory data contains signals", () => {
+    const inventoryItem = {
+      id: signal("sword"),
+      name: signal("Bronze Sword"),
+      description: signal("A starter weapon"),
+      quantity: signal(1),
+      atk: signal(5),
+      pdef: signal(0),
+      sdef: signal(0),
+      icon: signal("inventory-icon"),
+    };
+    const skill = {
+      id: signal("fire"),
+      name: signal("Fire"),
+      description: signal("Small fire spell"),
+      spCost: signal(3),
+    };
+    const sent: any[] = [];
+    const player: any = {
+      canMove: signal(true),
+      items: signal([inventoryItem]),
+      equipments: signal([inventoryItem]),
+      skills: signal([skill]),
+      param: { str: 4, dex: 3, int: 2, agi: 1, maxHp: 20, maxSp: 10 },
+      pdef: 1,
+      sdef: 2,
+      atk: 5,
+      expForNextlevel: signal(150),
+      databaseById() {
+        return {
+          _type: signal("weapon"),
+          icon: signal("db-icon"),
+          consumable: signal(false),
+        };
+      },
+      emit(type: string, value: any) {
+        sent.push(structuredClone({ type, value }));
+      },
+    };
+
+    const gui = new MenuGui(player);
+    const pending = gui.open();
+
+    expect(sent[0]).toMatchObject({
+      type: "gui.open",
+      value: {
+        guiId: "rpg-main-menu",
+        data: {
+          expForNextlevel: 150,
+          items: [
+            {
+              id: "sword",
+              icon: "db-icon",
+              type: "weapon",
+              equipped: true,
+            },
+          ],
+          skills: [
+            {
+              id: "fire",
+              name: "Fire",
+              spCost: 3,
+            },
+          ],
+        },
+      },
+    });
+
+    gui.close();
+    return pending;
+  });
+});

package/tests/skill.spec.ts

@@ -92,6 +92,7 @@ const FreeSkill = {
 
 let player: RpgPlayer;
 let fixture: TestingFixture;
+const onSkillChangeSpy = vi.fn();
 
 // Define server module with skills in database
 const serverModule = defineModule({
@@ -113,6 +114,7 @@ const serverModule = defineModule({
     async onConnected(player) {
       await player.changeMap("test-map", { x: 100, y: 100 });
     },
+    onSkillChange: onSkillChangeSpy,
   },
 });
 
@@ -122,6 +124,7 @@ const clientModule = defineModule({
 });
 
 beforeEach(async () => {
+  onSkillChangeSpy.mockClear();
   const myModule = createModule("TestModule", [
     {
       server: serverModule,
@@ -523,6 +526,51 @@ describe("Skill Management - Hooks", () => {
     expect(onForgetSpy).toHaveBeenCalledWith(player);
   });
 
+  test("should call player onSkillChange hook when learning skill", () => {
+    const skill = player.learnSkill("fire");
+
+    expect(skill).toBe(FireSkill);
+    expect(onSkillChangeSpy).toHaveBeenCalledWith(
+      player,
+      expect.objectContaining({
+        action: "learn",
+        skill: FireSkill,
+        skillId: "fire",
+        source: "manual",
+      }),
+    );
+  });
+
+  test("should call player onSkillChange hook when forgetting skill", () => {
+    player.learnSkill("fire");
+    onSkillChangeSpy.mockClear();
+
+    player.forgetSkill("fire");
+
+    expect(onSkillChangeSpy).toHaveBeenCalledWith(
+      player,
+      expect.objectContaining({
+        action: "forget",
+        skillId: "fire",
+        source: "manual",
+      }),
+    );
+  });
+
+  test("should pass source and level to onSkillChange hook", () => {
+    player.learnSkill("fire", { source: "level", level: 3 });
+
+    expect(onSkillChangeSpy).toHaveBeenCalledWith(
+      player,
+      expect.objectContaining({
+        action: "learn",
+        skillId: "fire",
+        source: "level",
+        level: 3,
+      }),
+    );
+  });
+
   test("should call onUse hook when using skill successfully", () => {
     const onUseSpy = vi.fn();
     const customSkill: SkillObject = {