@rpgjs/server 5.0.0-alpha.8 → 5.0.0-beta.1

package/src/Gui/ShopGui.ts

@@ -1,43 +1,173 @@
 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 type ShopItemInput = string | { id?: string; [key: string]: any }
+
+export interface ShopGuiOptions {
+    items: ShopItemInput[]
+    sell?: ShopSellList
+    sellMultiplier?: number
+    message?: string
+    face?: {
+        id: string
+        expression?: string
+    }
+}
+
+export class ShopGui extends Gui {
+    private itemsInput: ShopItemInput[] = []
+    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: ShopItemInput, 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,11 +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 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,45 +1,22 @@
 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";
+import type { IParameterManager } from "./ParameterManager";
 
-interface PlayerWithMixins extends RpgCommonPlayer {
-  parameters: any[];
+/**
+ * Interface combining methods from other managers needed by BattleManager
+ * Reuses existing interfaces instead of duplicating method signatures
+ */
+interface PlayerWithMixins extends IElementManager, IEffectManager, Pick<IParameterManager, 'parameters' | 'hp'> {
   getFormulas(name: string): any;
-  hasEffect(effect: string): boolean;
-  coefficientElements(attackerPlayer: RpgPlayer): number;
-  hp: number;
-  getCurrentMap(): any;
+  getCurrentMap(): ReturnType<RpgPlayer['getCurrentMap']>;
 }
 
-/**
- * Battle Manager Mixin
- * 
- * Provides battle management capabilities to any class. This mixin handles
- * damage calculation, critical hits, elemental vulnerabilities, and guard effects.
- * It implements a comprehensive battle system with customizable formulas and effects.
- * 
- * @param Base - The base class to extend with battle management
- * @returns Extended class with battle management methods
- * 
- * @example
- * ```ts
- * class MyPlayer extends WithBattleManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     // Battle system is automatically initialized
- *   }
- * }
- * 
- * const player = new MyPlayer();
- * const attacker = new MyPlayer();
- * const result = player.applyDamage(attacker);
- * console.log(`Damage dealt: ${result.damage}`);
- * ```
- */
-export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
-  return class extends Base {
-    /**
+export interface IBattleManager {
+   /**
      * Apply damage. Player will lose HP. the `attackerPlayer` parameter is the other player, the one who attacks.
      *
      * If you don't set the skill parameter, it will be a physical attack.
@@ -71,6 +48,17 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
      * }
      * ```
      */
+  applyDamage(attackerPlayer: RpgPlayer, skill?: any): {
+    damage: number;
+    critical: boolean;
+    elementVulnerable: boolean;
+    guard: boolean;
+    superGuard: boolean;
+  };
+}
+
+export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IBattleManager {
+  return class extends Base {
     applyDamage(
       attackerPlayer: RpgPlayer,
       skill?: any
@@ -81,9 +69,10 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
       guard: boolean;
       superGuard: boolean;
     } {
+      const self = this as unknown as PlayerWithMixins;
       const getParam = (player: RpgPlayer) => {
         const params = {};
-        (this as any).parameters.forEach((val, key) => {
+        Object.keys(self.parameters).forEach((key) => {
           params[key] = (player as any).param[key];
         });
         return {
@@ -100,26 +89,25 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
       let superGuard = false;
       let elementVulnerable = false;
       const paramA = getParam(attackerPlayer);
-      const paramB = getParam(<any>this);
-      console.log(paramA, paramB)
+      const paramB = getParam(self as any);
       if (skill) {
-        fn = this.getFormulas("damageSkill");
+        fn = self.getFormulas("damageSkill");
         if (!fn) {
           throw new Error("Skill Formulas not exists");
         }
         damage = fn(paramA, paramB, skill);
       } else {
-        fn = this.getFormulas("damagePhysic");
+        fn = self.getFormulas("damagePhysic");
         if (!fn) {
           throw new Error("Physic Formulas not exists");
         }
         damage = fn(paramA, paramB);
-        const coef = (this as any).coefficientElements(attackerPlayer);
+        const coef = self.coefficientElements(attackerPlayer);
         if (coef >= 2) {
           elementVulnerable = true;
         }
         damage *= coef;
-        fn = this.getFormulas("damageCritical");
+        fn = self.getFormulas("damageCritical");
         if (fn) {
           let newDamage = fn(damage, paramA, paramB);
           if (damage != newDamage) {
@@ -128,8 +116,8 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
           damage = newDamage;
         }
       }
-      if ((this as any).hasEffect(Effect.GUARD)) {
-        fn = this.getFormulas("damageGuard");
+      if (self.hasEffect(Effect.GUARD)) {
+        fn = self.getFormulas("damageGuard");
         if (fn) {
           let newDamage = fn(damage, paramA, paramB);
           if (damage != newDamage) {
@@ -138,11 +126,11 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
           damage = newDamage;
         }
       }
-      if ((this as any).hasEffect(Effect.SUPER_GUARD)) {
+      if (self.hasEffect(Effect.SUPER_GUARD)) {
         damage /= 4;
         superGuard = true;
       }
-      (this as any).hp -= damage;
+      self.hp -= damage;
       return {
         damage,
         critical,
@@ -179,14 +167,9 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
      * ```
      */
     getFormulas(name: string) {
-      const map = (this as any).getCurrentMap(); 
-      return map.damageFormulas[name];
+      const self = this as unknown as PlayerWithMixins;
+      const map = self.getCurrentMap(); 
+      return map?.damageFormulas[name];
     }
-  } as unknown as TBase
-}
-
-/**
- * Type helper to extract the interface from the WithBattleManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IBattleManager = InstanceType<ReturnType<typeof WithBattleManager>>;
+  } as unknown as any;
+}

package/src/Player/ClassManager.ts

@@ -6,8 +6,8 @@ type ActorClass = any;
 interface PlayerWithMixins extends RpgCommonPlayer {
   databaseById(id: string): any;
   addParameter(name: string, { start, end }: { start: number, end: number }): void;
-  addItem(item: any): void;
-  equip(item: any, equip: boolean): void;
+  addItem(item: any): any;
+  equip(itemId: string, equip?: boolean | 'auto'): void;
 }
 
 /**
@@ -36,81 +36,68 @@ 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 };
+    }
 
     /**
-     * Assign a class to the player
-     *
-     * Sets the player's class, which defines their combat abilities, stat growth,
-     * and available skills. The class system provides the foundation for character
-     * progression and specialization. When a class is set, it automatically triggers
-     * the class's onSet method for any additional initialization.
-     * 
-     * @param _class - The class constructor or class ID to assign to the player
-     * @returns The instantiated class object
-     * 
-     * @example
-     * ```ts
-     * import { Fighter } from 'my-database/classes/fighter'
-     *
-     * // Set class using constructor
-     * const fighterClass = player.setClass(Fighter);
-     * console.log('Class set:', fighterClass.name);
-     * 
-     * // Set class using string ID
-     * player.setClass('fighter');
-     * 
-     * // Class affects available skills and stats
-     * console.log('Available skills:', player.skills);
-     * console.log('Class bonuses applied to stats');
-     * 
-     * // Class determines level progression
-     * player.level = 5;
-     * // Skills may be automatically learned based on class definition
-     * ```
+     * 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;
     }
 
-    /**
-     * Allows to give a set of already defined properties to the player (default equipment, or a list of skills to learn according to the level)
-     *
-     * Sets up the player as a specific actor archetype, which includes predefined
-     * characteristics like starting equipment, parameters, level ranges, and associated class.
-     * This is typically used for creating pre-configured character templates or NPCs
-     * with specific roles and equipment loadouts.
-     * 
-     * @param actorClass - The actor constructor or actor ID to assign to the player
-     * @returns The instantiated actor object
-     * 
-     * @example
-     * ```ts
-     * import { Hero } from 'my-database/classes/hero'
-     *
-     * // Set up player as Hero actor
-     * const heroActor = player.setActor(Hero);
-     * console.log('Actor configured:', heroActor.name);
-     * 
-     * // Actor automatically sets up:
-     * // - Starting equipment (sword, armor, etc.)
-     * console.log('Starting equipment:', player.equipments());
-     * 
-     * // - Parameter ranges and growth
-     * console.log('Level range:', player.initialLevel, '-', player.finalLevel);
-     * 
-     * // - Associated class
-     * console.log('Assigned class:', player.class);
-     * 
-     * // - Experience curve
-     * console.log('EXP curve:', player.expCurve);
-     * 
-     * // Actor setup is comprehensive
-     * player.setActor('hero'); // Can also use string ID
-     * ```
-     */
     setActor(actorClass: ActorClass | string) {
       if (isString(actorClass)) actorClass = (this as any).databaseById(actorClass);
       const actor = new (actorClass as ActorClass)();
@@ -121,8 +108,11 @@ export function WithClassManager<TBase extends PlayerCtor>(Base: TBase) {
         (this as any).addParameter(param, actor.parameters[param]);
       }
       for (let item of actor.startingEquipment) {
-        (this as any).addItem(item);
-        (this as any).equip(item, true);
+        const inventory = (this as any).addItem(item);
+        const itemId = inventory?.id?.();
+        if (itemId) {
+          (this as any).equip(itemId, true);
+        }
       }
       if (actor.class) this.setClass(actor.class);
       (this as any)["execMethod"]("onSet", [this], actor);
@@ -132,7 +122,25 @@ export function WithClassManager<TBase extends PlayerCtor>(Base: TBase) {
 }
 
 /**
- * Type helper to extract the interface from the WithClassManager mixin
- * This provides the type without duplicating method signatures
+ * Interface for Class Manager functionality
+ * 
+ * Provides class and actor management capabilities including character class assignment
+ * and actor setup. This interface defines the public API of the ClassManager mixin.
  */
-export type IClassManager = InstanceType<ReturnType<typeof WithClassManager>>;
+export interface IClassManager {
+  /**
+   * Assign a class to the player
+   * 
+   * @param _class - The class constructor or class ID to assign to the player
+   * @returns The instantiated class object
+   */
+  setClass(_class: ClassClass | string): any;
+
+  /**
+   * Set up the player as a specific actor archetype
+   * 
+   * @param actorClass - The actor constructor or actor ID to assign to the player
+   * @returns The instantiated actor object
+   */
+  setActor(actorClass: ActorClass | string): any;
+}