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

package/src/Gui/ShopGui.ts

@@ -1,43 +1,172 @@
 import { PrebuiltGui } from '@rpgjs/common'
 import { Gui } from './Gui'
 import { RpgPlayer } from '../Player/Player'
-import { IGui } from '../Interfaces/Gui'
 
-export class ShopGui extends Gui implements IGui {
+export type ShopSellList = Record<string, number> | Array<{ id: string; multiplier: number }>
+
+export interface ShopGuiOptions {
+    items: any[]
+    sell?: ShopSellList
+    sellMultiplier?: number
+    message?: string
+    face?: {
+        id: string
+        expression?: string
+    }
+}
+
+export class ShopGui extends Gui {
+    private itemsInput: any[] = []
+    private sellMultipliers: Record<string, number> = {}
+    private baseSellMultiplier = 0.5
+    private messageInput?: string
+    private faceInput?: { id: string; expression?: string }
+
     constructor(player: RpgPlayer) {
         super(PrebuiltGui.Shop, player)
     }
 
-    open(items: any[]) {
-        items = items.map(item => {
-            const it = new item()
+    private normalizeSellMultipliers(sell?: ShopSellList) {
+        if (!sell) return {}
+        if (Array.isArray(sell)) {
+            return sell.reduce<Record<string, number>>((acc, entry) => {
+                if (entry && entry.id) acc[entry.id] = entry.multiplier ?? 0
+                return acc
+            }, {})
+        }
+        return { ...sell }
+    }
+
+    private buildShopData() {
+        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 playerParams = {
+            ...(player.param || {}),
+            atk: player.atk ?? 0,
+            def: player.pdef ?? 0,
+            pdef: player.pdef ?? 0,
+            sdef: player.sdef ?? 0
+        }
+
+        const getStatValue = (data, key, fallbackKeys: string[] = []) => {
+            if (data && typeof data[key] === 'number') return data[key]
+            for (const fallbackKey of fallbackKeys) {
+                if (data && typeof data[fallbackKey] === 'number') return data[fallbackKey]
+            }
+            const modifier = data?.paramsModifier?.[key]
+            if (modifier && typeof modifier.value === 'number') return modifier.value
+            for (const fallbackKey of fallbackKeys) {
+                const fallbackModifier = data?.paramsModifier?.[fallbackKey]
+                if (fallbackModifier && typeof fallbackModifier.value === 'number') return fallbackModifier.value
+            }
+            return undefined
+        }
+
+        const buildItemData = (item, overrides: { price?: number; quantity?: number } = {}) => {
+            const rawId = typeof item === 'string'
+                ? item
+                : (typeof item?.id === 'function' ? item.id() : (item?.id ?? item?.name))
+            const data = databaseById(rawId)
+            const itemName = typeof item?.name === 'function' ? item.name() : item?.name
+            const itemDescription = typeof item?.description === 'function' ? item.description() : item?.description
+            const itemPrice = typeof item?.price === 'function' ? item.price() : item?.price
+            const itemIcon = typeof item?.icon === 'function' ? item.icon() : item?.icon
+            const atk = getStatValue(data, 'atk')
+            const def = getStatValue(data, 'def', ['pdef', 'sdef'])
+            const intValue = getStatValue(data, 'int')
+            const agi = getStatValue(data, 'agi')
+            const stats = {
+                ...(atk !== undefined ? { atk } : {}),
+                ...(def !== undefined ? { def } : {}),
+                ...(intValue !== undefined ? { int: intValue } : {}),
+                ...(agi !== undefined ? { agi } : {})
+            }
             return {
-                price: it.price,
-                name: it.name,
-                description: it.description,
-                id: it.id,
-                type: item.type
+                price: overrides.price ?? data?.price ?? itemPrice ?? 0,
+                name: data?.name ?? itemName ?? rawId,
+                description: data?.description ?? itemDescription ?? '',
+                icon: data?.icon ?? itemIcon,
+                id: rawId,
+                type: data?._type ?? item.type ?? item?._type,
+                stats: Object.keys(stats).length ? stats : undefined,
+                equipped: rawId ? equippedIds.has(rawId) : false,
+                ...(overrides.quantity !== undefined ? { quantity: overrides.quantity } : {})
             }
-        })
-        this.on('buyItem', ({ id, nb }) => {
+        }
+
+        const items = this.itemsInput.map(item => buildItemData(item))
+
+        const sellItems = (player.items?.() || [])
+            .map((item) => {
+                const id = item?.id?.()
+                if (!id) return null
+                const multiplier = Object.prototype.hasOwnProperty.call(this.sellMultipliers, id)
+                    ? this.sellMultipliers[id]
+                    : this.baseSellMultiplier
+                const basePrice = databaseById(id)?.price ?? (typeof item?.price === 'function' ? item.price() : item?.price) ?? 0
+                const price = basePrice * multiplier
+                const quantity = item?.quantity?.()
+                return buildItemData(item, { price, quantity })
+            })
+            .filter(Boolean)
+
+        return { items, sellItems, playerParams, message: this.messageInput, face: this.faceInput }
+    }
+
+    private refreshShop(clientActionId?: string) {
+        this.update(this.buildShopData(), { clientActionId })
+    }
+
+    open(itemsOrOptions: any[] | ShopGuiOptions) {
+        const options: ShopGuiOptions = Array.isArray(itemsOrOptions)
+            ? { items: itemsOrOptions }
+            : (itemsOrOptions || { items: [] })
+        this.itemsInput = options.items || []
+        this.baseSellMultiplier = typeof options.sellMultiplier === 'number' ? options.sellMultiplier : 0.5
+        this.sellMultipliers = this.normalizeSellMultipliers(options.sell)
+        this.messageInput = options.message
+        this.faceInput = options.face
+        this.on('buyItem', ({ id, nb, clientActionId }) => {
             try {
                 this.player.buyItem(id, nb)
+                this.player.syncChanges()
             }
             catch (err) {
                 console.log(err)
             }
+            finally {
+                this.refreshShop(clientActionId)
+            }
         })
-        this.on('sellItem', ({ id, nb }) => {
+        this.on('sellItem', ({ id, nb, clientActionId }) => {
             try {
-                this.player.sellItem(id, nb)
+                const multiplier = Object.prototype.hasOwnProperty.call(this.sellMultipliers, id)
+                    ? this.sellMultipliers[id]
+                    : this.baseSellMultiplier
+                const basePrice = (this.player as any).databaseById?.(id)?.price ?? (typeof (inventory as any)?.price === 'function' ? (inventory as any).price() : (inventory as any)?.price) ?? 0
+                const price = basePrice * multiplier
+                if (!basePrice || price <= 0) return
+                const inventory = (this.player as any).getItem?.(id)
+                if (!inventory) return
+                const quantity = inventory.quantity()
+                if (quantity - nb < 0) return
+                ;(this.player as any)._gold.update((gold) => gold + price * nb)
+                ;(this.player as any).removeItem(id, nb)
+                this.player.syncChanges()
             }
             catch (err) {
                 console.log(err)
             }
+            finally {
+                this.refreshShop(clientActionId)
+            }
         })
-        return super.open({ items }, {
+        return super.open(this.buildShopData(), {
             waitingAction: true,
             blockPlayerInput: true
         })
     }
-}
+}

package/src/Gui/TitleGui.ts

@@ -0,0 +1,39 @@
+import { PrebuiltGui } from '@rpgjs/common'
+import { Gui } from './Gui'
+import { RpgPlayer } from '../Player/Player'
+
+export interface TitleEntry {
+    id: string
+    label: string
+    disabled?: boolean
+}
+
+export interface TitleGuiOptions {
+    entries?: TitleEntry[]
+    title?: string
+    subtitle?: string
+    version?: string
+    showPressStart?: boolean
+}
+
+export interface TitleGuiSelection {
+    id?: string
+    index?: number
+    entry?: TitleEntry
+}
+
+export class TitleGui extends Gui {
+    constructor(player: RpgPlayer) {
+        super(PrebuiltGui.TitleScreen, player)
+    }
+
+    open(options: TitleGuiOptions = {}): Promise<TitleGuiSelection | null> {
+        this.on('select', (selection: TitleGuiSelection) => {
+            this.close(selection)
+        })
+        return super.open(options, {
+            waitingAction: true,
+            blockPlayerInput: true
+        })
+    }
+}

package/src/Gui/index.ts

@@ -3,13 +3,24 @@ import { DialogGui } from './DialogGui'
 import { MenuGui } from './MenuGui'
 import { ShopGui } from './ShopGui'
 import { NotificationGui } from './NotificationGui'
+import { SaveLoadGui } from './SaveLoadGui'
+import { TitleGui } from './TitleGui'
+import { GameoverGui } from './GameoverGui'
 
 export { 
     Gui,
     DialogGui,
     MenuGui,
     ShopGui,
-    NotificationGui
+    NotificationGui,
+    SaveLoadGui,
+    TitleGui,
+    GameoverGui
 }
 
-export { DialogPosition } from './DialogGui'
+export { DialogPosition } from './DialogGui'
+export type { SaveLoadMode, SaveLoadOptions, SaveSlot } from './SaveLoadGui'
+export type { MenuEntryId, MenuEntry, MenuGuiOptions } from './MenuGui'
+export type { ShopGuiOptions, ShopSellList } from './ShopGui'
+export type { TitleEntry, TitleGuiOptions, TitleGuiSelection } from './TitleGui'
+export type { GameoverEntry, GameoverGuiOptions, GameoverGuiSelection } from './GameoverGui'

package/src/Player/BattleManager.ts

@@ -1,6 +1,6 @@
 import { Constructor, PlayerCtor, RpgCommonPlayer } from "@rpgjs/common";
 import { RpgPlayer } from "./Player";
-import { ATK, PDEF, SDEF } from "../presets";
+import { ATK, PDEF, SDEF } from "@rpgjs/common";
 import { Effect } from "./EffectManager";
 import type { IElementManager } from "./ElementManager";
 import type { IEffectManager } from "./EffectManager";

package/src/Player/ClassManager.ts

@@ -36,9 +36,64 @@ interface PlayerWithMixins extends RpgCommonPlayer {
  */
 export function WithClassManager<TBase extends PlayerCtor>(Base: TBase) {
   return class extends Base {
+    private _resolveClassInput(classInput: ClassClass | string, databaseByIdOverride?: (id: string) => any) {
+      if (isString(classInput)) {
+        return databaseByIdOverride
+          ? databaseByIdOverride(classInput)
+          : (this as any).databaseById(classInput);
+      }
+      return classInput;
+    }
+
+    private _createClassInstance(classInput: ClassClass | string) {
+      const classClass = this._resolveClassInput(classInput);
+      const instance = new (classClass as ClassClass)();
+      return { classClass, instance };
+    }
+
+    /**
+     * Create a class instance without side effects.
+     */
+    createClassInstance(classInput: ClassClass | string) {
+      return this._createClassInstance(classInput);
+    }
+
+    /**
+     * Resolve class snapshot entry into a class instance without side effects.
+     */
+    resolveClassSnapshot(snapshot: { _class?: any }, mapOverride?: any) {
+      if (!snapshot || snapshot._class == null) {
+        return snapshot;
+      }
+
+      const map = mapOverride ?? ((this as any).getCurrentMap?.() || (this as any).map);
+      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 classId = isString(snapshot._class) ? snapshot._class : snapshot._class?.id;
+      if (!classId) {
+        return snapshot;
+      }
+
+      const classClass = this._resolveClassInput(classId, databaseByIdOverride);
+      const { instance } = this._createClassInstance(classClass as ClassClass);
+      return { ...snapshot, _class: instance };
+    }
+
     setClass(_class: ClassClass | string) {
-      if (isString(_class)) _class = (this as any).databaseById(_class);
-      const classInstance = new (_class as ClassClass)();
+      const { instance } = this._createClassInstance(_class);
+      const classInstance = instance;
       (this as any)["execMethod"]("onSet", [this], classInstance);
       return classInstance;
     }

package/src/Player/GuiManager.ts

@@ -1,6 +1,9 @@
 import { RpgPlayer } from "./Player";
-import { Gui, DialogGui, MenuGui, ShopGui, NotificationGui } from "../Gui";
+import { Gui, DialogGui, MenuGui, ShopGui, NotificationGui, SaveLoadGui, GameoverGui } from "../Gui";
 import { DialogOptions, Choice } from "../Gui/DialogGui";
+import { SaveLoadOptions, SaveSlot } from "../Gui/SaveLoadGui";
+import { MenuGuiOptions } from "../Gui/MenuGui";
+import { GameoverGuiOptions, GameoverGuiSelection } from "../Gui/GameoverGui";
 import { Constructor, PlayerCtor } from "@rpgjs/common";
 
 /**
@@ -56,21 +59,42 @@ export function WithGuiManager<TBase extends PlayerCtor>(
 
     showNotification(
       message: string,
-      options: { time?: number; icon?: string; sound?: string } = {}
+      options: { time?: number; icon?: string; sound?: string; type?: "info" | "warn" | "error" } = {}
     ): Promise<any> {
-      const gui = new NotificationGui(<any>this);
-      this._gui[gui.id] = gui;
-      const data = {
+      this.emit('notification', {
         message,
         ...options,
-      };
-      return gui.open(data);
+      });
+      return Promise.resolve(true);
     }
 
-    callMainMenu() {
+    callMainMenu(options: MenuGuiOptions = {}) {
       const gui = new MenuGui(<any>this);
       this._gui[gui.id] = gui;
-      return gui.open();
+      return gui.open(options);
+    }
+
+    callGameover(options: GameoverGuiOptions = {}): Promise<GameoverGuiSelection | null> {
+      const gui = new GameoverGui(<any>this);
+      this._gui[gui.id] = gui;
+      return gui.open(options);
+    }
+
+    showSaveLoad(slots: SaveSlot[] = [], options: SaveLoadOptions = {}): Promise<number | null> {
+      const gui = new SaveLoadGui(<any>this);
+      this._gui[gui.id] = gui;
+      return gui.open(slots, options).then((index) => {
+        if (typeof index !== 'number') return null;
+        return index;
+      });
+    }
+
+    showSave(slots: SaveSlot[] = [], options: SaveLoadOptions = {}): Promise<number | null> {
+      return this.showSaveLoad(slots, { ...options, mode: 'save' });
+    }
+
+    showLoad(slots: SaveSlot[] = [], options: SaveLoadOptions = {}): Promise<number | null> {
+      return this.showSaveLoad(slots, { ...options, mode: 'load' });
     }
 
     /**
@@ -81,7 +105,13 @@ export function WithGuiManager<TBase extends PlayerCtor>(
      * @returns {void}
      * @memberof GuiManager
      */
-    callShop(items: any[]) {
+    callShop(items: any[] | {
+      items: any[]
+      sell?: Record<string, number> | Array<{ id: string; multiplier: number }>
+      sellMultiplier?: number
+      message?: string
+      face?: { id: string; expression?: string }
+    }) {
       const gui = new ShopGui(<any>this);
       this._gui[gui.id] = gui;
       return gui.open(items);
@@ -128,6 +158,10 @@ export function WithGuiManager<TBase extends PlayerCtor>(
       return gui;
     }
 
+    getGui(guiId: string) {
+      return this._gui[guiId];
+    }
+
     /**
      * Closes the GUI and removes it from memory
      *
@@ -345,19 +379,96 @@ export interface IGuiManager {
    */
   showNotification(
     message: string,
-    options?: { time?: number; icon?: string; sound?: string }
+    options?: { time?: number; icon?: string; sound?: string; type?: "info" | "warn" | "error" }
   ): Promise<any>;
+
+  /**
+   * Display a save/load slots screen. Opens the GUI named `rpg-save`
+   *
+   * ```ts
+   * const index = await player.showSaveLoad(slots, { mode: 'save' })
+   * ```
+   *
+   * @title Show Save/Load
+   * @method player.showSaveLoad(slots,options)
+   * @param {Array<object>} slots
+   * @param {object} [options]
+   * @returns {Promise<number | null>}
+   * @memberof GuiManager
+   */
+  showSaveLoad(slots?: SaveSlot[], options?: SaveLoadOptions): Promise<number | null>;
+
+  /**
+   * Display a save slots screen. Opens the GUI named `rpg-save`
+   *
+   * ```ts
+   * const index = await player.showSave(slots)
+   * ```
+   *
+   * @title Show Save
+   * @method player.showSave(slots,options)
+   * @param {Array<object>} slots
+   * @param {object} [options]
+   * @returns {Promise<number | null>}
+   * @memberof GuiManager
+   */
+  showSave(slots?: SaveSlot[], options?: SaveLoadOptions): Promise<number | null>;
+
+  /**
+   * Display a load slots screen. Opens the GUI named `rpg-save`
+   *
+   * ```ts
+   * const index = await player.showLoad(slots)
+   * ```
+   *
+   * @title Show Load
+   * @method player.showLoad(slots,options)
+   * @param {Array<object>} slots
+   * @param {object} [options]
+   * @returns {Promise<number | null>}
+   * @memberof GuiManager
+   */
+  showLoad(slots?: SaveSlot[], options?: SaveLoadOptions): Promise<number | null>;
   /**
    * Calls main menu. Opens the GUI named `rpg-main-menu`
    *
    * @title Call Main Menu
-   * @method player.callMainMenu()
+   * @method player.callMainMenu(options)
+   * @param {object} [options]
    * @returns {void}
    * @memberof GuiManager
    */
-  callMainMenu(): void;
-  callShop(items: any[]): void;
+  callMainMenu(options?: MenuGuiOptions): void;
+
+  /**
+   * Calls game over menu. Opens the GUI named `rpg-gameover`
+   *
+   * ```ts
+   * const selection = await player.callGameover()
+   * if (selection?.id === 'title') {
+   *     await player.gui('rpg-title-screen').open()
+   * }
+   * if (selection?.id === 'load') {
+   *     await player.showLoad()
+   * }
+   * ```
+   *
+   * @title Call Game Over Menu
+   * @method player.callGameover(options)
+   * @param {object} [options]
+   * @returns {Promise<GameoverGuiSelection | null>}
+   * @memberof GuiManager
+   */
+  callGameover(options?: GameoverGuiOptions): Promise<GameoverGuiSelection | null>;
+  callShop(items: any[] | {
+    items: any[]
+    sell?: Record<string, number> | Array<{ id: string; multiplier: number }>
+    sellMultiplier?: number
+    message?: string
+    face?: { id: string; expression?: string }
+  }): void;
   gui(guiId: string): Gui;
+  getGui(guiId: string): Gui;
   removeGui(guiId: string, data?: any): void;
   showAttachedGui(players?: RpgPlayer[] | RpgPlayer): void;
   hideAttachedGui(players?: RpgPlayer[] | RpgPlayer): void;