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

package/src/Player/StateManager.ts

@@ -46,6 +46,75 @@ export function WithStateManager<TBase extends PlayerCtor>(Base: TBase) {
   return class extends Base {
     _statesEfficiency = signal<any[]>([]);
 
+    private _getStateMap(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 resolve states');
+      }
+      return map;
+    }
+
+    private _resolveStateInput(
+      stateInput: StateClass | string,
+      databaseByIdOverride?: (id: string) => any
+    ) {
+      if (isString(stateInput)) {
+        return databaseByIdOverride
+          ? databaseByIdOverride(stateInput)
+          : (this as any).databaseById(stateInput);
+      }
+      return stateInput;
+    }
+
+    private _createStateInstance(stateClass: StateClass) {
+      return new (stateClass as StateClass)();
+    }
+
+    /**
+     * Create a state instance without side effects.
+     */
+    createStateInstance(stateInput: StateClass | string) {
+      const stateClass = this._resolveStateInput(stateInput);
+      const instance = this._createStateInstance(stateClass as StateClass);
+      return { stateClass, instance };
+    }
+
+    /**
+     * Resolve state snapshot entries into state instances without side effects.
+     */
+    resolveStatesSnapshot(snapshot: { states?: any[] }, mapOverride?: any) {
+      if (!snapshot || !Array.isArray(snapshot.states)) {
+        return snapshot;
+      }
+
+      const map = mapOverride ?? this._getStateMap(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 states = snapshot.states.map((entry: any) => {
+        const stateId = isString(entry) ? entry : entry?.id;
+        if (!stateId) {
+          return entry;
+        }
+        const stateClass = this._resolveStateInput(stateId, databaseByIdOverride);
+        return this._createStateInstance(stateClass as StateClass);
+      });
+
+      return { ...snapshot, states };
+    }
+
     get statesDefense(): { rate: number; state: any }[] {
       return (this as any).getFeature("statesDefense", "state");
     }
@@ -94,7 +163,7 @@ export function WithStateManager<TBase extends PlayerCtor>(Base: TBase) {
           throw StateLog.addFailed(stateClass);
         }
         //const efficiency = this.findStateEfficiency(stateClass)
-        const instance = new (stateClass as StateClass)();
+        const instance = this._createStateInstance(stateClass as StateClass);
         this.states().push(instance);
         this.applyStates(<any>this, instance);
         return instance;

package/src/Player/VariableManager.ts

@@ -1,4 +1,6 @@
 import { Constructor, PlayerCtor } from "@rpgjs/common";
+import { signal } from "@signe/reactive";
+import { type } from "@signe/sync";
 
 /**
  * Variable Manager Mixin
@@ -25,30 +27,31 @@ import { Constructor, PlayerCtor } from "@rpgjs/common";
  */
 export function WithVariableManager<TBase extends PlayerCtor>(Base: TBase) {
   return class extends Base {
-    variables: Map<string, any> = new Map();
+    variables = type(signal<Record<string, any>>({}) as any, 'variables', { persist: true }, this as any);
 
     setVariable(key: string, val: any): void {
-      this.variables.set(key, val);
+      this.variables()[key] = val;
     }
 
     getVariable<U = any>(key: string): U | undefined {
-      return this.variables.get(key);
+      return this.variables()[key];
     }
 
     removeVariable(key: string): boolean {
-      return this.variables.delete(key);
+      delete this.variables()[key];
+      return true;
     }
 
     hasVariable(key: string): boolean {
-      return this.variables.has(key);
+      return key in this.variables();
     }
 
     getVariableKeys(): string[] {
-      return Array.from(this.variables.keys());
+      return Object.keys(this.variables());
     }
 
     clearVariables(): void {
-      this.variables.clear();
+      this.variables.set({});
     }
   } as unknown as TBase;
 }

package/src/RpgServer.ts

@@ -178,6 +178,14 @@ export interface RpgPlayerHooks {
     */
     onConnected?: (player: RpgPlayer) => any
 
+    /**
+    *  When the player starts the game from the lobby
+    * 
+    * @prop { (player: RpgPlayer) => any } [onStart]
+    * @memberof RpgPlayerHooks
+    */
+    onStart?: (player: RpgPlayer) => any
+
     /**
     *  When the player presses a key on the client side
     * 

package/src/index.ts

@@ -10,7 +10,10 @@ export * from "./rooms/map";
 export * from "./presets";
 export * from "@signe/reactive";
 export * from "./Gui";
-export { RpgShape, RpgModule } from "@rpgjs/common";
+export * from "./services/save";
+export * from "./storage";
+export { RpgShape, RpgModule, MAXHP, MAXSP, ATK, PDEF, SDEF, STR, AGI, INT, DEX } from "@rpgjs/common";
 export * from "./decorators/event";
 export * from "./decorators/map";
-export * from "./Player/MoveManager";
+export * from "./Player/MoveManager";
+export * from "./presets";

package/src/presets/index.ts

@@ -1,14 +1,5 @@
 import { random } from "@rpgjs/common"
-
-export const MAXHP: string = 'maxHp'
-export const MAXSP: string = 'maxSp'
-export const ATK: string = 'atk'
-export const PDEF: string = 'pdef'
-export const SDEF: string = 'sdef'
-export const STR: string = 'str'
-export const AGI: string = 'agi'
-export const INT: string = 'int'
-export const DEX: string = 'dex'
+import { DEX, AGI, ATK, PDEF, SDEF, STR, INT } from "@rpgjs/common"
 
 export const MAXHP_CURVE = {
     start: 741,

package/src/rooms/BaseRoom.ts

@@ -1,4 +1,11 @@
 import { signal } from "@signe/reactive";
+import { inject } from "../core/inject";
+import { context } from "../core/context";
+import { Hooks, ModulesToken } from "@rpgjs/common";
+import { Action } from "@signe/room";
+import { RpgPlayer } from "../Player/Player";
+import { resolveSaveStorageStrategy } from "../services/save";
+import { lastValueFrom } from "rxjs";
 
 /**
  * Base class for rooms that need database functionality
@@ -20,6 +27,7 @@ import { signal } from "@signe/reactive";
  * ```
  */
 export abstract class BaseRoom {
+
   /**
    * Signal containing the room's database of items, classes, and other game data
    * 
@@ -38,6 +46,11 @@ export abstract class BaseRoom {
    */
   database = signal({});
 
+
+  async onStart() {
+    await lastValueFrom(this.hooks.callHooks("server-databaseHooks-load", this))
+  }
+
   /**
    * Add data to the room's database
    * 
@@ -117,4 +130,103 @@ export abstract class BaseRoom {
     this.database.set(database);
     return true;
   }
+
+   /**
+   * Get the hooks system for this map
+   * 
+   * Returns the dependency-injected Hooks instance that allows you to trigger
+   * and listen to various game events.
+   * 
+   * @returns The Hooks instance for this map
+   * 
+   * @example
+   * ```ts
+   * // Trigger a custom hook
+   * map.hooks.callHooks('custom-event', data).subscribe();
+   * ```
+   */
+    get hooks() {
+      return inject<Hooks>(ModulesToken, context);
+    }
+
+    /**
+     * Resolve complex snapshot entries (e.g. inventory items) before load.
+     */
+    async onSessionRestore({ userSnapshot, user }: { userSnapshot: any; user?: RpgPlayer }) {
+      if (!userSnapshot) {
+        return userSnapshot;
+      }
+
+      let resolvedSnapshot = userSnapshot;
+      if (user && typeof (user as any).resolveItemsSnapshot === 'function') {
+        resolvedSnapshot = (user as any).resolveItemsSnapshot(resolvedSnapshot, this);
+      }
+
+      if (user && typeof (user as any).resolveSkillsSnapshot === 'function') {
+        resolvedSnapshot = (user as any).resolveSkillsSnapshot(resolvedSnapshot, this);
+      }
+
+      if (user && typeof (user as any).resolveStatesSnapshot === 'function') {
+        resolvedSnapshot = (user as any).resolveStatesSnapshot(resolvedSnapshot, this);
+      }
+
+      if (user && typeof (user as any).resolveClassSnapshot === 'function') {
+        resolvedSnapshot = (user as any).resolveClassSnapshot(resolvedSnapshot, this);
+      }
+
+      if (user && typeof (user as any).resolveEquipmentsSnapshot === 'function') {
+        resolvedSnapshot = (user as any).resolveEquipmentsSnapshot(resolvedSnapshot, this);
+      }
+
+      return resolvedSnapshot;
+    }
+
+    @Action('save.list')
+    async listSaveSlots(player: RpgPlayer, value: { requestId: string }) {
+      const storage = resolveSaveStorageStrategy();
+      try {
+        const slots = await storage.list(player);
+        player.emit('save.list.result', { requestId: value?.requestId, slots });
+        return slots;
+      } catch (error: any) {
+        player.showNotification(error?.message || 'save.list failed');
+        return [];
+      }
+    }
+  
+    @Action('save.save')
+    async saveSlot(player: RpgPlayer, value: { requestId: string; index: number; meta?: any }) {
+      const storage = resolveSaveStorageStrategy();
+      try {
+        if (typeof value?.index !== 'number') {
+          throw new Error('save.save requires an index');
+        }
+        const result = await player.save(value.index, value?.meta, { reason: "manual", source: "gui" });
+        if (!result) {
+          throw new Error('save.save is not allowed');
+        }
+        const slots = await storage.list(player);
+        player.emit('save.save.result', { requestId: value?.requestId, index: result.index, slots });
+      } catch (error: any) {
+        player.emit('save.error', { requestId: value?.requestId, message: error?.message || 'save.save failed' });
+      }
+    }
+  
+    @Action('save.load')
+    async loadSlot(player: RpgPlayer, value: { requestId: string; index: number }) {
+      try {
+        if (typeof value?.index !== 'number') {
+          throw new Error('save.load requires an index');
+        }
+        const result = await player.load(value.index, { reason: "load", source: "gui" }, { changeMap: true });
+        player.emit('save.load.result', {
+          requestId: value?.requestId,
+          index: value.index,
+          ok: result.ok,
+          slot: result.slot
+        });
+      } catch (error: any) {
+        player.emit('save.error', { requestId: value?.requestId, message: error?.message || 'save.load failed' });
+      }
+    }
 }

package/src/rooms/lobby.ts

@@ -1,11 +1,13 @@
 import { inject } from "@signe/di";
-import { MockConnection, Room } from "@signe/room";
+import { Action, MockConnection, Room } from "@signe/room";
 import { Hooks, ModulesToken } from "@rpgjs/common";
 import { context } from "../core/context";
 import { users } from "@signe/sync";
 import { signal } from "@signe/reactive";
 import { RpgPlayer } from "../Player/Player";
 import { BaseRoom } from "./BaseRoom";
+import { buildSaveSlotMeta, resolveSaveStorageStrategy } from "../services/save";
+import { lastValueFrom } from "rxjs";
 
 @Room({
   path: "lobby-{id}",
@@ -22,13 +24,18 @@ export class LobbyRoom extends BaseRoom {
     }
   }
 
-  onJoin(player: RpgPlayer, conn: MockConnection) {
+  async onJoin(player: RpgPlayer, conn: MockConnection) {
     player.map = this;
     player.context = context;
     player.conn = conn;
-    const hooks = inject<Hooks>(context, ModulesToken);
-    hooks
-      .callHooks("server-player-onConnected", player)
-      .subscribe();
+    this.hooks.callHooks("server-player-onConnected", player).subscribe();
+  }
+
+  @Action('gui.interaction')
+  async guiInteraction(player: RpgPlayer, value: { guiId: string, name: string, data: any }) {
+    const id = value.data.id
+    if (id === 'start') {
+      this.hooks.callHooks("server-player-onStart", player).subscribe();
+    }
   }
 }

package/src/rooms/map.ts

@@ -14,6 +14,7 @@ import { z } from "zod";
 import { EntityState } from "@rpgjs/physic";
 import { MapOptions } from "../decorators/map";
 import { BaseRoom } from "./BaseRoom";
+import { buildSaveSlotMeta, resolveSaveStorageStrategy } from "../services/save";
 
 /**
  * Interface for input controls configuration
@@ -237,6 +238,10 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     }
   }
 
+  onStart() {
+    return BaseRoom.prototype.onStart.call(this)
+  }
+
   /**
    * Setup collision detection between players, events, and shapes
    * 
@@ -581,7 +586,11 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   get hooks() {
-    return inject<Hooks>(context, ModulesToken);
+    return BaseRoom.prototype.hooks;
+  }
+
+  async onSessionRestore(payload: { userSnapshot: any; user?: RpgPlayer }) {
+    return await BaseRoom.prototype.onSessionRestore.call(this, payload);
   }
 
   /**
@@ -600,8 +609,11 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   @Action('gui.interaction')
-  guiInteraction(player: RpgPlayer, value) {
-    this.hooks.callHooks("server-player-guiInteraction", player, value);
+  async guiInteraction(player: RpgPlayer, value: { guiId: string, name: string, data: any }) {
+    const gui = player.getGui(value.guiId)
+    if (gui) {
+      await gui.emit(value.name, value.data)
+    }
     player.syncChanges();
   }
 
@@ -699,6 +711,21 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     }
   }
 
+  @Action('save.save')
+  async saveSlot(player: RpgPlayer, value: { requestId: string; index: number; meta?: any }) {
+    BaseRoom.prototype.saveSlot(player, value);
+  }
+
+  @Action('save.load')
+  async loadSlot(player: RpgPlayer, value: { requestId: string; index: number }) {
+    BaseRoom.prototype.loadSlot(player, value);
+  }
+
+  @Action('save.list')
+  async listSaveSlots(player: RpgPlayer, value: { requestId: string }) {
+    return await BaseRoom.prototype.listSaveSlots(player, value);
+  }
+
   /**
    * Update the map configuration and data
    * 
@@ -2056,4 +2083,4 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   }
 }
 
-export interface RpgMap extends RoomMethods { }
+export interface RpgMap extends RoomMethods { }

package/src/services/save.ts

@@ -0,0 +1,147 @@
+import { SaveSlot, SaveSlotEntries, SaveSlotList, SaveSlotMeta } from "@rpgjs/common";
+import { inject } from "../core/inject";
+import { RpgPlayer } from "../Player/Player";
+
+export const SaveStorageToken = "SaveStorageToken";
+
+export type SaveSlotIndex = number | "auto";
+
+export interface SaveRequestContext {
+  reason?: "manual" | "auto" | "load";
+  source?: string;
+}
+
+export interface AutoSaveStrategy {
+  canSave?: (player: RpgPlayer, context?: SaveRequestContext) => boolean;
+  canLoad?: (player: RpgPlayer, context?: SaveRequestContext) => boolean;
+  shouldAutoSave?: (player: RpgPlayer, context?: SaveRequestContext) => boolean;
+  getDefaultSlot?: (player: RpgPlayer, context?: SaveRequestContext) => number | null;
+}
+
+export interface SaveStorageStrategy {
+  list(player: RpgPlayer): Promise<SaveSlotList>;
+  get(player: RpgPlayer, index: number): Promise<SaveSlot | null>;
+  save(player: RpgPlayer, index: number, snapshot: string, meta: SaveSlotMeta): Promise<void>;
+  delete?(player: RpgPlayer, index: number): Promise<void>;
+}
+
+type PlayerSlots = Map<string, SaveSlotEntries>;
+
+export class InMemorySaveStorageStrategy implements SaveStorageStrategy {
+  private slotsByPlayer: PlayerSlots = new Map();
+
+  async list(player: RpgPlayer): Promise<SaveSlotList> {
+    return this.stripSnapshots(this.getSlots(player));
+  }
+
+  async get(player: RpgPlayer, index: number): Promise<SaveSlot | null> {
+    const slots = this.getSlots(player);
+    const slot = slots[index];
+    return slot ?? null;
+  }
+
+  async save(player: RpgPlayer, index: number, snapshot: string, meta: SaveSlotMeta): Promise<void> {
+    const slots = this.getSlots(player);
+    const existing = slots[index];
+    slots[index] = {
+      ...(existing ?? {}),
+      ...meta,
+      snapshot,
+    };
+  }
+
+  async delete(player: RpgPlayer, index: number): Promise<void> {
+    const slots = this.getSlots(player);
+    slots[index] = null;
+  }
+
+  private getSlots(player: RpgPlayer): SaveSlotEntries {
+    const key = player.id ?? "unknown";
+    if (!this.slotsByPlayer.has(key)) {
+      this.slotsByPlayer.set(key, []);
+    }
+    return this.slotsByPlayer.get(key)!;
+  }
+
+  private stripSnapshots(slots: SaveSlotEntries): SaveSlotList {
+    return slots.map((slot) => {
+      if (!slot) return null;
+      const { snapshot, ...meta } = slot;
+      return meta;
+    });
+  }
+}
+
+let cachedSaveStorage: SaveStorageStrategy | null = null;
+let cachedAutoSave: AutoSaveStrategy | null = null;
+
+export const AutoSaveToken = "AutoSaveToken";
+
+export function resolveSaveStorageStrategy(): SaveStorageStrategy {
+  if (cachedSaveStorage) return cachedSaveStorage;
+  try {
+    cachedSaveStorage = inject<SaveStorageStrategy>(SaveStorageToken);
+  } catch {
+    cachedSaveStorage = new InMemorySaveStorageStrategy();
+  }
+  return cachedSaveStorage;
+}
+
+export function resolveAutoSaveStrategy(): AutoSaveStrategy {
+  if (cachedAutoSave) return cachedAutoSave;
+  try {
+    cachedAutoSave = inject<AutoSaveStrategy>(AutoSaveToken);
+  } catch {
+    cachedAutoSave = null;
+  }
+  cachedAutoSave ||= {
+    canSave: () => true,
+    canLoad: () => true,
+    shouldAutoSave: () => false,
+    getDefaultSlot: () => 0,
+  };
+  return cachedAutoSave;
+}
+
+export function resolveSaveSlot(
+  slot: SaveSlotIndex | undefined,
+  policy: AutoSaveStrategy,
+  player: RpgPlayer,
+  context?: SaveRequestContext
+): number | null {
+  if (typeof slot === "number") return slot;
+  const resolver = policy.getDefaultSlot;
+  if (!resolver) return null;
+  return resolver(player, context);
+}
+
+export function shouldAutoSave(player: RpgPlayer, context?: SaveRequestContext): boolean {
+  const strategy = resolveAutoSaveStrategy();
+  if (!strategy.shouldAutoSave) return false;
+  return strategy.shouldAutoSave(player, context);
+}
+
+export function buildSaveSlotMeta(player: RpgPlayer, overrides: SaveSlotMeta = {}): SaveSlotMeta {
+  const mapId = player.getCurrentMap()?.id;
+  const base: SaveSlotMeta = {
+    level: typeof player.level === "number" ? player.level : undefined,
+    exp: typeof player.exp === "number" ? player.exp : undefined,
+    map: typeof mapId === "string" ? mapId : undefined,
+    date: new Date().toISOString(),
+  };
+  return { ...base, ...overrides };
+}
+
+export function provideSaveStorage(strategy: SaveStorageStrategy) {
+  return {
+    provide: SaveStorageToken,
+    useValue: strategy,
+  };
+}
+
+export function provideAutoSave(strategy: AutoSaveStrategy) {
+  return {
+    provide: AutoSaveToken,
+    useValue: strategy,
+  };
+}

package/src/storage/index.ts

@@ -0,0 +1 @@
+export * from "./localStorage";

package/src/storage/localStorage.ts

@@ -0,0 +1,76 @@
+import type { SaveSlot, SaveSlotEntries, SaveSlotList, SaveSlotMeta } from "@rpgjs/common";
+import type { SaveStorageStrategy } from "../services/save";
+import { RpgPlayer } from "../Player/Player";
+
+export interface LocalStorageSaveStorageOptions {
+  key?: string;
+}
+
+/**
+ * Save storage strategy backed by browser localStorage.
+ *
+ * Intended for standalone mode where the server runs in the browser
+ * and localStorage is available.
+ */
+export class LocalStorageSaveStorageStrategy implements SaveStorageStrategy {
+  private key: string;
+
+  constructor(options: LocalStorageSaveStorageOptions = {}) {
+    this.key = options.key ?? "rpgjs-save-slots";
+  }
+
+  async list(_player: RpgPlayer): Promise<SaveSlotList> {
+    return this.stripSnapshots(this.readSlots());
+  }
+
+  async get(_player: RpgPlayer, index: number): Promise<SaveSlot | null> {
+    const slots = this.readSlots();
+    return slots[index] ?? null;
+  }
+
+  async save(_player: RpgPlayer, index: number, snapshot: string, meta: SaveSlotMeta): Promise<void> {
+    const slots = this.readSlots();
+    const existing = slots[index];
+    slots[index] = {
+      ...(existing ?? {}),
+      ...meta,
+      snapshot,
+    };
+    this.writeSlots(slots);
+  }
+
+  async delete(_player: RpgPlayer, index: number): Promise<void> {
+    const slots = this.readSlots();
+    slots[index] = null;
+    this.writeSlots(slots);
+  }
+
+  private readSlots(): SaveSlotEntries {
+    if (typeof localStorage === "undefined") {
+      return [];
+    }
+    const raw = localStorage.getItem(this.key);
+    if (!raw) return [];
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+
+  private writeSlots(slots: SaveSlotEntries) {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    localStorage.setItem(this.key, JSON.stringify(slots));
+  }
+
+  private stripSnapshots(slots: SaveSlotEntries): SaveSlotList {
+    return slots.map((slot) => {
+      if (!slot) return null;
+      const { snapshot, ...meta } = slot;
+      return meta;
+    });
+  }
+}