@rpgjs/server 5.0.0-alpha.4 → 5.0.0-alpha.41

package/dist/services/save.d.ts

@@ -0,0 +1,43 @@
+import { SaveSlot, SaveSlotList, SaveSlotMeta } from '../../../common/src';
+import { RpgPlayer } from '../Player/Player';
+export declare 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>;
+}
+export declare class InMemorySaveStorageStrategy implements SaveStorageStrategy {
+    private slotsByPlayer;
+    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>;
+    private getSlots;
+    private stripSnapshots;
+}
+export declare const AutoSaveToken = "AutoSaveToken";
+export declare function resolveSaveStorageStrategy(): SaveStorageStrategy;
+export declare function resolveAutoSaveStrategy(): AutoSaveStrategy;
+export declare function resolveSaveSlot(slot: SaveSlotIndex | undefined, policy: AutoSaveStrategy, player: RpgPlayer, context?: SaveRequestContext): number | null;
+export declare function shouldAutoSave(player: RpgPlayer, context?: SaveRequestContext): boolean;
+export declare function buildSaveSlotMeta(player: RpgPlayer, overrides?: SaveSlotMeta): SaveSlotMeta;
+export declare function provideSaveStorage(strategy: SaveStorageStrategy): {
+    provide: string;
+    useValue: SaveStorageStrategy;
+};
+export declare function provideAutoSave(strategy: AutoSaveStrategy): {
+    provide: string;
+    useValue: AutoSaveStrategy;
+};

package/dist/storage/index.d.ts

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

package/dist/storage/localStorage.d.ts

@@ -0,0 +1,23 @@
+import { SaveSlot, SaveSlotList, SaveSlotMeta } from '../../../common/src';
+import { 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 declare class LocalStorageSaveStorageStrategy implements SaveStorageStrategy {
+    private key;
+    constructor(options?: LocalStorageSaveStorageOptions);
+    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>;
+    private readSlots;
+    private writeSlots;
+    private stripSnapshots;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-alpha.4",
+  "version": "5.0.0-alpha.41",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,21 +11,25 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.4",
+    "@rpgjs/common": "5.0.0-alpha.41",
+    "@rpgjs/physic": "5.0.0-alpha.41",
+    "@rpgjs/testing": "5.0.0-alpha.41",
     "@rpgjs/database": "^4.3.0",
-    "@signe/di": "^2.3.2",
-    "@signe/reactive": "^2.3.2",
-    "@signe/room": "^2.3.2",
-    "@signe/sync": "^2.3.2",
-    "rxjs": "^7.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.6"
   },
   "devDependencies": {
-    "vite": "^6.2.5",
-    "vite-plugin-dts": "^4.5.3"
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
   },
   "type": "module",
   "scripts": {
     "dev": "vite build --watch",
-    "build": "vite build"
+    "build": "vite build",
+    "test": "vitest"
   }
 }

package/src/Gui/DialogGui.ts

@@ -18,7 +18,12 @@ export interface DialogOptions {
     autoClose?: boolean,
     tranparent?: boolean,
     typewriterEffect?: boolean,
-    talkWith?: RpgPlayer
+    talkWith?: RpgPlayer,
+    speaker?: string,
+    face?: {
+        id: string,
+        expression: string
+    },
 }
 
 export class DialogGui extends Gui {
@@ -30,9 +35,17 @@ export class DialogGui extends Gui {
         if (!options.choices) options.choices = []
         if (options.autoClose == undefined) options.autoClose = false
         if (!options.position) options.position = DialogPosition.Bottom
-        if (options.fullWidth == undefined) options.fullWidth = true
+        if (options.fullWidth == undefined) options.fullWidth = false
         if (options.typewriterEffect  == undefined) options.typewriterEffect = true
         const event = options.talkWith
+        const resolveName = (target?: RpgPlayer): string | undefined => {
+            if (!target) return undefined
+            const rawName = (target as any).name
+            if (typeof rawName === 'function') return rawName()
+            if (rawName && typeof rawName.get === 'function') return rawName.get()
+            return rawName
+        }
+        const speaker = options.speaker ?? resolveName(event)
         let memoryDir
         if (event) {
             memoryDir = event.direction()
@@ -44,10 +57,12 @@ export class DialogGui extends Gui {
             position: options.position,
             fullWidth: options.fullWidth,
             typewriterEffect: options.typewriterEffect,
+            speaker,
             // remove value property. It is not useful to know this on the client side.
             choices: options.choices.map(choice => ({
                 text: choice.text
-            }))
+            })),
+            face: options.face
         }
         return super.open({
             message,
@@ -63,4 +78,4 @@ export class DialogGui extends Gui {
             return val
         })
     }
-}
+}

package/src/Gui/GameoverGui.ts

@@ -0,0 +1,39 @@
+import { PrebuiltGui } from '@rpgjs/common'
+import { Gui } from './Gui'
+import { RpgPlayer } from '../Player/Player'
+
+export interface GameoverEntry {
+    id: string
+    label: string
+    disabled?: boolean
+}
+
+export interface GameoverGuiOptions {
+    entries?: GameoverEntry[]
+    title?: string
+    subtitle?: string
+    saveLoad?: Record<string, any>
+    localActions?: boolean
+}
+
+export interface GameoverGuiSelection {
+    id?: string
+    index?: number
+    entry?: GameoverEntry
+}
+
+export class GameoverGui extends Gui {
+    constructor(player: RpgPlayer) {
+        super(PrebuiltGui.Gameover, player)
+    }
+
+    open(options: GameoverGuiOptions = {}): Promise<GameoverGuiSelection | null> {
+        this.on('select', (selection: GameoverGuiSelection) => {
+            this.close(selection)
+        })
+        return super.open(options, {
+            waitingAction: true,
+            blockPlayerInput: true
+        })
+    }
+}

package/src/Gui/Gui.ts

@@ -4,6 +4,7 @@ export class Gui {
 
     private _close: Function = () => {}
     private _blockPlayerInput: boolean = false
+    private _events = new Map<string, (data: any) => void>()
 
     constructor(
         public id: string,
@@ -34,6 +35,19 @@ export class Gui {
         })
     }
 
+    on(event: string, callback: (data: any) => void) {
+        this._events.set(event, callback)
+    }
+
+    async emit(event: string, data: any): Promise<any> {
+        const callback = this._events.get(event)
+        if (callback) {
+            return await callback(data)
+        } else {
+            return null
+        }
+    }
+
     close(data?) {
         this.player.emit('gui.exit', this.id)
         if (this._blockPlayerInput) {
@@ -41,4 +55,12 @@ export class Gui {
         }
         this._close(data)
     }
-}
+
+    update(data?, { clientActionId }: { clientActionId?: string } = {}) {
+        this.player.emit('gui.update', {
+            guiId: this.id,
+            data,
+            clientActionId
+        })
+    }
+}

package/src/Gui/MenuGui.ts

@@ -1,15 +1,137 @@
 import { PrebuiltGui } from '@rpgjs/common'
 import { Gui } from './Gui'
 import { RpgPlayer } from '../Player/Player'
-import { IGui } from '../Interfaces/Gui'
+import { SaveLoadGui, SaveSlot } from './SaveLoadGui'
+import { resolveAutoSaveStrategy } from '../services/save'
+
+export type MenuEntryId = 'items' | 'skills' | 'equip' | 'options' | 'save' | 'exit'
+
+export interface MenuEntry {
+    id: MenuEntryId
+    label: string
+    disabled?: boolean
+}
+
+export interface MenuGuiOptions {
+    menus?: MenuEntry[]
+    disabled?: MenuEntryId[]
+    saveSlots?: SaveSlot[]
+    saveMaxSlots?: number
+    saveShowAutoSlot?: boolean
+    saveAutoSlotIndex?: number
+    saveAutoSlotLabel?: string
+}
+
+export class MenuGui extends Gui {
+    private menuOptions: MenuGuiOptions = {}
 
-export class MenuGui extends Gui implements IGui {
     constructor(player: RpgPlayer) {
         super(PrebuiltGui.MainMenu, player)
     }
 
-    open() {
-        this.on('useItem', (id) => {
+    private buildSaveLoad(options: MenuGuiOptions) {
+        const autoSave = resolveAutoSaveStrategy()
+        const canSave = autoSave.canSave ? autoSave.canSave(this.player, { reason: "manual", source: "menu" }) : true
+        const autoSlotIndex = options.saveAutoSlotIndex ?? autoSave.getDefaultSlot?.(this.player, { reason: "auto", source: "menu" }) ?? 0
+        return {
+            mode: 'save',
+            canSave,
+            showAutoSlot: options.saveShowAutoSlot === true,
+            autoSlotIndex,
+            autoSlotLabel: options.saveAutoSlotLabel
+        }
+    }
+
+    private buildMenuData(options: MenuGuiOptions) {
+        const disabledSet = new Set(options.disabled || [])
+        const defaultMenus: MenuEntry[] = [
+            { id: 'items', label: 'Items' },
+            { id: 'skills', label: 'Skills' },
+            { id: 'equip', label: 'Equip' },
+            { id: 'options', label: 'Options' },
+            { id: 'save', label: 'Save' },
+            { id: 'exit', label: 'Exit' }
+        ]
+        const menus = (options.menus && options.menus.length ? options.menus : defaultMenus)
+            .map(menu => ({
+                ...menu,
+                disabled: menu.disabled || disabledSet.has(menu.id)
+            }))
+
+        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)
+        )
+
+        const buildStats = () => {
+            const params = player.param || {}
+            const statKeys = [
+                'str',
+                'dex',
+                'int',
+                'agi',
+                'maxHp',
+                'maxSp'
+            ]
+            const stats: Record<string, number> = {}
+            statKeys.forEach((key) => {
+                stats[key] = params[key] ?? 0
+            })
+            stats.pdef = player.pdef ?? params.pdef ?? 0
+            stats.sdef = player.sdef ?? params.sdef ?? 0
+            stats.atk = player.atk ?? params.atk ?? 0
+            return stats
+        }
+
+        const items = (player.items?.() || []).map((item) => {
+            const id = item.id()
+            const data = databaseById ? databaseById(id) : {}
+            const type = data?._type ?? 'item'
+            const consumable = data?.consumable
+            const isConsumable = consumable !== undefined ? consumable : type === 'item'
+            const usable = isConsumable === false
+                ? false
+                : consumable === undefined && type !== 'item'
+                    ? false
+                    : 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(),
+                consumable: isConsumable,
+                type,
+                usable,
+                equipped: equippedIds.has(id)
+            }
+        })
+        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
+        }))
+        const saveLoad = this.buildSaveLoad(options)
+
+        return { menus, items, equips: menuEquips, skills, saveLoad, playerStats: buildStats(), expForNextlevel: player.expForNextlevel }
+    }
+
+    private refreshMenu(clientActionId?: string) {
+        const data = this.buildMenuData(this.menuOptions)
+        this.update(data, { clientActionId })
+    }
+
+    open(options: MenuGuiOptions = {}) {
+        this.menuOptions = options
+        const data = this.buildMenuData(options)
+
+        this.on('useItem', ({ id, clientActionId }) => {
             try {
                 this.player.useItem(id)
                 this.player.syncChanges()
@@ -17,10 +139,37 @@ export class MenuGui extends Gui implements IGui {
             catch (err: any) {
                 this.player.showNotification(err.msg)
             }
+            finally {
+                this.refreshMenu(clientActionId)
+            }
+        })
+        this.on('equipItem', ({ id, equip, clientActionId }) => {
+            try {
+                this.player.equip(id, equip)
+                this.player.syncChanges()
+            }
+            catch (err: any) {
+                this.player.showNotification(err.msg)
+            }
+            finally {
+                this.refreshMenu(clientActionId)
+            }
+        })
+        this.on('openSave', async () => {
+            this.close()
+            const gui = new SaveLoadGui(this.player)
+            player._gui[gui.id] = gui
+            await gui.open(options.saveSlots || [], {
+                mode: 'save',
+                maxSlots: options.saveMaxSlots
+            })
+        })
+        this.on('exit', () => {
+            this.close('exit')
         })
-        return super.open('', {
+        return super.open(data, {
             waitingAction: true,
             blockPlayerInput: true
         })
     }
-}
+}

package/src/Gui/NotificationGui.ts

@@ -1,9 +1,8 @@
 import { PrebuiltGui } from '@rpgjs/common'
 import { Gui } from './Gui'
 import { RpgPlayer } from '../Player/Player'
-import { IGui } from '../Interfaces/Gui'
 
-export class NotificationGui extends Gui implements IGui {
+export class NotificationGui extends Gui {
     constructor(player: RpgPlayer) {
         super(PrebuiltGui.Notification, player)
     }

package/src/Gui/SaveLoadGui.ts

@@ -0,0 +1,60 @@
+import { PrebuiltGui } from '@rpgjs/common'
+import type { SaveSlot } from '@rpgjs/common'
+import { Gui } from './Gui'
+import { RpgPlayer } from '../Player/Player'
+
+export type SaveLoadMode = 'save' | 'load'
+
+export type { SaveSlot } from '@rpgjs/common'
+
+export interface SaveLoadOptions {
+    mode?: SaveLoadMode
+    maxSlots?: number
+}
+
+export class SaveLoadGui extends Gui {
+    constructor(player: RpgPlayer) {
+        super(PrebuiltGui.Save, player)
+    }
+
+    open(slots: SaveSlot[] = [], options: SaveLoadOptions = {}): Promise<number | null> {
+        const mode = options.mode || 'load'
+        const maxSlots = options.maxSlots ?? slots.length
+        const normalizedSlots = Array.from({ length: maxSlots }, (_, index) => slots[index] ?? null)
+        const uiSlots = normalizedSlots.map((slot) => {
+            if (!slot) return null
+            const { snapshot, ...data } = slot
+            return data
+        })
+
+        const onSelect = async ({ index }) => {
+            if (typeof index !== 'number') return
+            if (index < 0 || index >= normalizedSlots.length) return
+            const slot = normalizedSlots[index]
+            if (mode === 'load') {
+                const result = await this.player.load(index, { reason: "load", source: "gui" }, { changeMap: true })
+                if (!result.ok) return
+                this.close(index)
+                return
+            }
+            if (mode === 'save') {
+                const result = await this.player.save(index, {}, { reason: "manual", source: "gui" })
+                if (!result) return
+                const updatedSlot: SaveSlot = {
+                    ...(slot || {}),
+                    ...result.meta
+                }
+                normalizedSlots[index] = updatedSlot
+                slots[index] = updatedSlot
+                this.close(index)
+            }
+        }
+        this.on('save', onSelect)
+        this.on('load', onSelect)
+        this.on('select', onSelect)
+        return super.open({ slots: uiSlots, mode }, {
+            waitingAction: true,
+            blockPlayerInput: true
+        })
+    }
+}