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

package/src/Player/ItemManager.ts

@@ -1,5 +1,5 @@
 import { isInstanceOf, isString, Item, type PlayerCtor} from "@rpgjs/common";
-import { ATK, PDEF, SDEF } from "../presets";
+import { ATK, PDEF, SDEF } from "@rpgjs/common";
 import { ItemLog } from "../logs";
 import type { ItemClass, ItemInstance } from "@rpgjs/database";
 import { RpgPlayer } from "./Player";
@@ -205,64 +205,196 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
         return isInstanceOf(it, itemClass);
       });
     }
-    addItem(item: ItemClass | ItemObject | string, nb: number = 1): Item {
+
+    private _getItemMap(required: boolean = true) {
       // Use this.map directly to support both RpgMap and LobbyRoom
-      // If no map, player is in Lobby
-      const map = (this as any).getCurrentMap() || (this as any).map;
-      if (!map || !map.database) {
+      const map = (this as any).getCurrentMap?.() || (this as any).map;
+      if (required && (!map || !map.database)) {
         throw new Error('Player must be on a map to add items');
       }
+      return map;
+    }
 
+    private _resolveItemInput(
+      item: ItemClass | ItemObject | string,
+      map: any,
+      databaseByIdOverride?: (id: string) => any
+    ) {
       let itemId: string;
       let data: any;
       let itemInstance: any = null;
 
-      // Handle string: retrieve from database
       if (isString(item)) {
         itemId = item as string;
-        data = (this as any).databaseById(itemId);
-      }
-      // Handle class: create instance and add to database if needed
-      else if (typeof item === 'function' || (item as any).prototype) {
+        data = databaseByIdOverride
+          ? databaseByIdOverride(itemId)
+          : (this as any).databaseById(itemId);
+      } else if (typeof item === 'function' || (item as any).prototype) {
         itemId = (item as any).name;
-        
-        // Check if already in database
+
         const existingData = map.database()[itemId];
         if (existingData) {
-          // Use existing data from database
           data = existingData;
         } else {
-          // Add the class to the database (it will be retrieved later via databaseById)
           map.addInDatabase(itemId, item as ItemClass);
-          // Use the class as data (it will be used to create Item instance)
           data = item as ItemClass;
         }
-        
-        // Create instance of the class for hooks
+
         itemInstance = new (item as ItemClass)();
-      }
-      // Handle object: use directly and add to database if needed
-      else {
+      } else {
         const itemObj = item as ItemObject;
         itemId = itemObj.id || `item-${Date.now()}`;
-        
-        // Check if already in database
+
         const existingData = map.database()[itemId];
         if (existingData) {
-          // Merge with existing data and force update
           data = { ...existingData, ...itemObj };
-          // Update database with merged data (force overwrite)
           map.addInDatabase(itemId, data, { force: true });
         } else {
-          // Add the object to the database
           map.addInDatabase(itemId, itemObj);
-          // Use object directly as data
           data = itemObj;
         }
-        
+
         itemInstance = itemObj;
       }
 
+      return { itemId, data, itemInstance };
+    }
+
+    private _createItemInstance(
+      itemId: string,
+      data: any,
+      nb: number,
+      itemInstance: any
+    ): Item {
+      const instance = new Item(data);
+      instance.id.set(itemId);
+      instance.quantity.set(nb);
+
+      if (itemInstance) {
+        (instance as any)._itemInstance = itemInstance;
+        if (itemInstance.onAdd) {
+          instance.onAdd = itemInstance.onAdd.bind(itemInstance);
+        }
+      }
+
+      return instance;
+    }
+
+    /**
+     * Create an item instance without inventory changes or hook execution.
+     */
+    createItemInstance(item: ItemClass | ItemObject | string, nb: number = 1) {
+      const map = this._getItemMap();
+      const { itemId, data, itemInstance } = this._resolveItemInput(item, map);
+      const instance = this._createItemInstance(itemId, data, nb, itemInstance);
+      return { itemId, data, itemInstance, instance };
+    }
+
+    /**
+     * Resolve item snapshot entries into Item instances without side effects.
+     */
+    resolveItemsSnapshot(snapshot: { items?: any[] }, mapOverride?: any) {
+      if (!snapshot || !Array.isArray(snapshot.items)) {
+        return snapshot;
+      }
+
+      const map = mapOverride ?? this._getItemMap(false);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+
+      const databaseByIdOverride = (id: string) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+
+      const items = snapshot.items.map((entry: any) => {
+        const itemId = isString(entry) ? entry : entry?.id;
+        if (!itemId) {
+          return entry;
+        }
+
+        const nb =
+          !isString(entry) && typeof entry?.nb === 'number'
+            ? entry.nb
+            : !isString(entry) && typeof entry?.quantity === 'number'
+              ? entry.quantity
+              : 1;
+
+        const { data, itemInstance } = this._resolveItemInput(
+          itemId,
+          map,
+          databaseByIdOverride
+        );
+        return this._createItemInstance(itemId, data, nb, itemInstance);
+      });
+
+      return { ...snapshot, items };
+    }
+
+    /**
+     * Resolve equipment snapshot entries into Item instances without side effects.
+     */
+    resolveEquipmentsSnapshot(snapshot: { equipments?: any[]; items?: any[] }, mapOverride?: any) {
+      if (!snapshot || !Array.isArray(snapshot.equipments)) {
+        return snapshot;
+      }
+
+      const map = mapOverride ?? this._getItemMap(false);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+
+      const databaseByIdOverride = (id: string) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+
+      const resolvedItems = Array.isArray(snapshot.items) ? snapshot.items : [];
+      const getItemId = (entry: any) => {
+        if (isString(entry)) return entry;
+        if (typeof entry?.id === 'function') return entry.id();
+        return entry?.id;
+      };
+
+      const equipments = snapshot.equipments.map((entry: any) => {
+        const itemId = getItemId(entry);
+        if (!itemId) {
+          return entry;
+        }
+
+        const existing = resolvedItems.find((item: any) => {
+          const existingId = getItemId(item);
+          return existingId === itemId;
+        });
+        if (existing) {
+          return existing;
+        }
+
+        const { data, itemInstance } = this._resolveItemInput(
+          itemId,
+          map,
+          databaseByIdOverride
+        );
+        return this._createItemInstance(itemId, data, 1, itemInstance);
+      });
+
+      return { ...snapshot, equipments };
+    }
+    addItem(item: ItemClass | ItemObject | string, nb: number = 1): Item {
+      const map = this._getItemMap();
+      const { itemId, data, itemInstance } = this._resolveItemInput(item, map);
+
       // Find existing item in inventory
       const existingItem = (this as any).items().find((it: Item) => it.id() == itemId);
       let instance: Item;
@@ -293,20 +425,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
         }
       } else {
         // Create new item instance
-        instance = new Item(data);
-        instance.id.set(itemId);
-        instance.quantity.set(nb);
-
-        // Attach hooks from class instance or object
-        if (itemInstance) {
-          // Store the original instance for hook execution
-          (instance as any)._itemInstance = itemInstance;
-          
-          // Attach onAdd hook directly for immediate use
-          if (itemInstance.onAdd) {
-            instance.onAdd = itemInstance.onAdd.bind(itemInstance);
-          }
-        };
+        instance = this._createItemInstance(itemId, data, nb, itemInstance);
         (this as any).items().push(instance);
       }
 

package/src/Player/ParameterManager.ts

@@ -1,6 +1,6 @@
 import { isString, PlayerCtor } from "@rpgjs/common";
 import { signal, computed, WritableSignal, ComputedSignal } from "@signe/reactive";
-import { MAXHP, MAXSP } from "../presets";
+import { MAXHP, MAXSP } from "@rpgjs/common";
 import { sync, type } from "@signe/sync";
 
 /**

package/src/Player/Player.ts

@@ -19,7 +19,7 @@ import { MockConnection } from "@signe/room";
 import { IMoveManager, WithMoveManager } from "./MoveManager";
 import { IGoldManager, WithGoldManager } from "./GoldManager";
 import { WithVariableManager, type IVariableManager } from "./VariableManager";
-import { createStatesSnapshot, load, sync, type } from "@signe/sync";
+import { createStatesSnapshotDeep, load, sync, type } from "@signe/sync";
 import { computed, signal } from "@signe/reactive";
 import {
   IParameterManager,
@@ -29,12 +29,23 @@ import { WithItemFixture } from "./ItemFixture";
 import { IItemManager, WithItemManager } from "./ItemManager";
 import { bufferTime, combineLatest, debounceTime, distinctUntilChanged, filter, lastValueFrom, map, Observable, pairwise, sample, throttleTime } from "rxjs";
 import { IEffectManager, WithEffectManager } from "./EffectManager";
-import { AGI, AGI_CURVE, DEX, DEX_CURVE, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, STR, STR_CURVE } from "../presets";
+import { AGI, DEX, INT, MAXHP, MAXSP, STR } from "@rpgjs/common";
+import { AGI_CURVE, DEX_CURVE, INT_CURVE, MAXHP_CURVE, MAXSP_CURVE, STR_CURVE } from "../presets";
 import { IElementManager, WithElementManager } from "./ElementManager";
 import { ISkillManager, WithSkillManager } from "./SkillManager";
 import { IBattleManager, WithBattleManager } from "./BattleManager";
 import { IClassManager, WithClassManager } from "./ClassManager";
 import { IStateManager, WithStateManager } from "./StateManager";
+import {
+  buildSaveSlotMeta,
+  resolveAutoSaveStrategy,
+  resolveSaveSlot,
+  resolveSaveStorageStrategy,
+  shouldAutoSave,
+  type SaveRequestContext,
+  type SaveSlotIndex,
+  type SaveSlotMeta,
+} from "../services/save";
 
 /**
  * Combines multiple RpgCommonPlayer mixins into one
@@ -403,17 +414,78 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     });
   }
 
-  async save() {
-    const snapshot = createStatesSnapshot(this)
-    await lastValueFrom(this.hooks.callHooks("server-player-onSave", this, snapshot))
-    return JSON.stringify(snapshot)
+  snapshot() {
+    return createStatesSnapshotDeep(this);
   }
 
-  async load(snapshot: string) {
-    const data = JSON.parse(snapshot)
-    const dataLoaded = load(this, data)
-    await lastValueFrom(this.hooks.callHooks("server-player-onLoad", this, dataLoaded))
-    return dataLoaded
+  async applySnapshot(snapshot: string | object) {
+    const data = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
+    const withItems = (this as any).resolveItemsSnapshot?.(data) ?? data;
+    const withSkills = (this as any).resolveSkillsSnapshot?.(withItems) ?? withItems;
+    const withStates = (this as any).resolveStatesSnapshot?.(withSkills) ?? withSkills;
+    const withClass = (this as any).resolveClassSnapshot?.(withStates) ?? withStates;
+    const resolvedSnapshot = (this as any).resolveEquipmentsSnapshot?.(withClass) ?? withClass;
+    load(this, resolvedSnapshot);
+    if (Array.isArray(resolvedSnapshot.items)) {
+      this.items.set(resolvedSnapshot.items);
+    }
+    if (Array.isArray(resolvedSnapshot.skills)) {
+      this.skills.set(resolvedSnapshot.skills);
+    }
+    if (Array.isArray(resolvedSnapshot.states)) {
+      this.states.set(resolvedSnapshot.states);
+    }
+    if (resolvedSnapshot._class != null && this._class?.set) {
+      this._class.set(resolvedSnapshot._class);
+    }
+    if (Array.isArray(resolvedSnapshot.equipments)) {
+      this.equipments.set(resolvedSnapshot.equipments);
+    }
+    await lastValueFrom(this.hooks.callHooks("server-player-onLoad", this, resolvedSnapshot));
+    return resolvedSnapshot;
+  }
+
+  async save(slot: SaveSlotIndex = "auto", meta: SaveSlotMeta = {}, context: SaveRequestContext = {}) {
+    const policy = resolveAutoSaveStrategy();
+    if (policy.canSave && !policy.canSave(this, context)) {
+      return null;
+    }
+    const resolvedSlot = resolveSaveSlot(slot, policy, this, context);
+    if (resolvedSlot === null) {
+      return null;
+    }
+    const snapshot = this.snapshot();
+    await lastValueFrom(this.hooks.callHooks("server-player-onSave", this, snapshot));
+    const storage = resolveSaveStorageStrategy();
+    const finalMeta = buildSaveSlotMeta(this, meta);
+    await storage.save(this, resolvedSlot, JSON.stringify(snapshot), finalMeta);
+    return { index: resolvedSlot, meta: finalMeta };
+  }
+
+  async load(
+    slot: SaveSlotIndex = "auto",
+    context: SaveRequestContext = {},
+    options: { changeMap?: boolean } = {}
+  ) {
+    const policy = resolveAutoSaveStrategy();
+    if (policy.canLoad && !policy.canLoad(this, context)) {
+      return { ok: false };
+    }
+    const resolvedSlot = resolveSaveSlot(slot, policy, this, context);
+    if (resolvedSlot === null) {
+      return { ok: false };
+    }
+    const storage = resolveSaveStorageStrategy();
+    const slotData = await storage.get(this, resolvedSlot);
+    if (!slotData?.snapshot) {
+      return { ok: false };
+    }
+    await this.applySnapshot(slotData.snapshot);
+    const { snapshot, ...meta } = slotData;
+    if (options.changeMap !== false && meta.map) {
+      await this.changeMap(meta.map);
+    }
+    return { ok: true, slot: meta, index: resolvedSlot };
   }
 
  
@@ -531,6 +603,9 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   */
   syncChanges() {
     this._eventChanges();
+    if (shouldAutoSave(this, { reason: "auto", source: "syncChanges" })) {
+      void this.save("auto", {}, { reason: "auto", source: "syncChanges" });
+    }
   }
 
   databaseById(id: string) {
@@ -1234,4 +1309,4 @@ export interface RpgPlayer extends
   ISkillManager,
   IBattleManager,
   IClassManager,
-  IStateManager { } 
+  IStateManager { } 

package/src/Player/SkillManager.ts

@@ -3,6 +3,7 @@ import {
   isInstanceOf,
   isString,
   PlayerCtor,
+  Skill,
 } from "@rpgjs/common";
 import { SkillLog } from "../logs";
 import { RpgPlayer } from "./Player";
@@ -175,6 +176,134 @@ export interface SkillObject extends SkillHooks {
  */
 export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
   return class extends (Base as any) {
+    private _getSkillMap(required: boolean = true) {
+      // Use this.map directly to support both RpgMap and LobbyRoom
+      const map = (this as any).getCurrentMap?.() || (this as any).map;
+      if (required && (!map || !map.database)) {
+        throw new Error('Player must be on a map to learn skills');
+      }
+      return map;
+    }
+
+    private _resolveSkillInput(
+      skillInput: SkillClass | SkillObject | string,
+      map: any,
+      databaseByIdOverride?: (id: string) => any
+    ) {
+      let skillId = '';
+      let skillData: any;
+      let skillInstance: any = null;
+
+      if (isString(skillInput)) {
+        skillId = skillInput as string;
+        skillData = databaseByIdOverride
+          ? databaseByIdOverride(skillId)
+          : (this as any).databaseById(skillId);
+      } else if (typeof skillInput === 'function') {
+        const SkillClassCtor = skillInput as SkillClass;
+        skillId = (SkillClassCtor as any).id || SkillClassCtor.name;
+
+        const existingData = map?.database()?.[skillId];
+        if (existingData) {
+          skillData = existingData;
+        } else if (map) {
+          map.addInDatabase(skillId, SkillClassCtor);
+          skillData = SkillClassCtor;
+        } else {
+          skillData = SkillClassCtor;
+        }
+
+        skillInstance = new SkillClassCtor();
+        skillData = { ...skillData, ...skillInstance, id: skillId };
+      } else {
+        const skillObj = skillInput as SkillObject;
+        skillId = skillObj.id || `skill-${Date.now()}`;
+        skillObj.id = skillId;
+
+        const existingData = map?.database()?.[skillId];
+        if (existingData) {
+          skillData = { ...existingData, ...skillObj };
+          if (map) {
+            map.addInDatabase(skillId, skillData, { force: true });
+          }
+        } else if (map) {
+          map.addInDatabase(skillId, skillObj);
+          skillData = skillObj;
+        } else {
+          skillData = skillObj;
+        }
+
+        skillInstance = skillObj;
+      }
+
+      return { skillId, skillData, skillInstance };
+    }
+
+    private _createSkillInstance(
+      skillId: string,
+      skillData: any,
+      skillInstance: any
+    ) {
+      const instance = new Skill(skillData);
+      instance.id.set(skillId);
+
+      if (skillInstance) {
+        (instance as any)._skillInstance = skillInstance;
+      }
+
+      return instance;
+    }
+
+    /**
+     * Create a skill instance without learning side effects.
+     */
+    createSkillInstance(skillInput: SkillClass | SkillObject | string) {
+      const map = this._getSkillMap();
+      const { skillId, skillData, skillInstance } = this._resolveSkillInput(skillInput, map);
+      const instance = this._createSkillInstance(skillId, skillData, skillInstance);
+      return { skillId, skillData, skillInstance, instance };
+    }
+
+    /**
+     * Resolve skill snapshot entries into Skill instances without side effects.
+     */
+    resolveSkillsSnapshot(snapshot: { skills?: any[] }, mapOverride?: any) {
+      if (!snapshot || !Array.isArray(snapshot.skills)) {
+        return snapshot;
+      }
+
+      const map = mapOverride ?? this._getSkillMap(false);
+      if (!map || !map.database) {
+        return snapshot;
+      }
+
+      const databaseByIdOverride = (id: string) => {
+        const data = map.database()[id];
+        if (!data) {
+          throw new Error(
+            `The ID=${id} data is not found in the database. Add the data in the property "database"`
+          );
+        }
+        return data;
+      };
+
+      const skills = snapshot.skills.map((entry: any) => {
+        const skillId = isString(entry) ? entry : entry?.id;
+        if (!skillId) {
+          return entry;
+        }
+
+        const { skillData, skillInstance } = this._resolveSkillInput(
+          skillId,
+          map,
+          databaseByIdOverride
+        );
+        return this._createSkillInstance(skillId, skillData, skillInstance);
+      });
+
+      return { ...snapshot, skills };
+    }
+
     /**
      * Find the index of a skill in the skills array
      * 
@@ -198,7 +327,7 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       }
 
       return (this as any).skills().findIndex((skill: any) => {
-        const skillId = skill.id || skill.name || '';
+        const skillId = skill.id() || skill.name() || '';
         return skillId === searchId;
       });
     }
@@ -219,9 +348,9 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
      * }
      * ```
      */
-    getSkill(skillInput: SkillClass | SkillObject | string): any | null {
+    getSkill(skillInput: SkillClass | SkillObject | string): Skill | null {
       const index = this._getSkillIndex(skillInput);
-      return (this as any).skills()[index] ?? null;
+      return (this as any).skills()[index] as Skill ?? null;
     }
 
     /**
@@ -256,74 +385,21 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
      * ```
      */
     learnSkill(skillInput: SkillClass | SkillObject | string): any {
-      // Get the map for database operations
-      const map = (this as any).getCurrentMap() || (this as any).map;
-      
-      let skillId = '';
-      let skillData: any;
-
-      // Handle string: retrieve from database
-      if (isString(skillInput)) {
-        skillId = skillInput as string;
-        skillData = (this as any).databaseById(skillId);
-      }
-      // Handle class: create instance and add to database if needed
-      else if (typeof skillInput === 'function') {
-        const SkillClassCtor = skillInput as SkillClass;
-        skillId = (SkillClassCtor as any).id || SkillClassCtor.name;
-        
-        // Check if already in database
-        const existingData = map?.database()?.[skillId];
-        if (existingData) {
-          skillData = existingData;
-        } else if (map) {
-          // Add the class to the database
-          map.addInDatabase(skillId, SkillClassCtor);
-          skillData = SkillClassCtor;
-        } else {
-          skillData = SkillClassCtor;
-        }
-        
-        // Create instance of the class for hooks
-        const skillInstance = new SkillClassCtor();
-        // Merge instance properties with class static properties
-        skillData = { ...skillData, ...skillInstance, id: skillId };
-      }
-      // Handle object: use directly and add to database if needed
-      else {
-        const skillObj = skillInput as SkillObject;
-        skillId = skillObj.id || `skill-${Date.now()}`;
-        
-        // Ensure the object has an id
-        skillObj.id = skillId;
-        
-        // Check if already in database
-        const existingData = map?.database()?.[skillId];
-        if (existingData) {
-          // Merge with existing data
-          skillData = { ...existingData, ...skillObj };
-          if (map) {
-            map.addInDatabase(skillId, skillData, { force: true });
-          }
-        } else if (map) {
-          // Add the object to the database
-          map.addInDatabase(skillId, skillObj);
-          skillData = skillObj;
-        } else {
-          skillData = skillObj;
-        }
-      }
+      const map = this._getSkillMap();
+      const { skillId, skillData, skillInstance } = this._resolveSkillInput(skillInput, map);
 
       // Check if already learned
       if (this.getSkill(skillId)) {
         throw SkillLog.alreadyLearned(skillData);
       }
 
-      // Add to skills list
-      (this as any).skills().push(skillData);
+      const instance = this._createSkillInstance(skillId, skillData, skillInstance);
+
+      (this as any).skills().push(instance);
       
       // Call onLearn hook
-      this["execMethod"]("onLearn", [this], skillData);
+      const hookTarget = (instance as any)._skillInstance || instance;
+      this["execMethod"]("onLearn", [this], hookTarget);
       
       return skillData;
     }
@@ -366,7 +442,8 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       (this as any).skills().splice(index, 1);
       
       // Call onForget hook
-      this["execMethod"]("onForget", [this], skillData);
+      const hookTarget = (skillData as any)?._skillInstance || skillData;
+      this["execMethod"]("onForget", [this], hookTarget);
       
       return skillData;
     }
@@ -423,7 +500,8 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       // Check hit rate
       const hitRate = skill.hitRate ?? 1;
       if (Math.random() > hitRate) {
-        this["execMethod"]("onUseFailed", [this, otherPlayer], skill);
+        const hookTarget = (skill as any)?._skillInstance || skill;
+        this["execMethod"]("onUseFailed", [this, otherPlayer], hookTarget);
         throw SkillLog.chanceToUseFailed(skill);
       }
       
@@ -437,7 +515,8 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       }
       
       // Call onUse hook
-      this["execMethod"]("onUse", [this, otherPlayer], skill);
+      const hookTarget = (skill as any)?._skillInstance || skill;
+      this["execMethod"]("onUse", [this, otherPlayer], hookTarget);
       
       return skill;
     }