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

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,19 +1,53 @@
-import { Constructor, RpgCommonPlayer } from "@rpgjs/common";
+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;
-  getFormulas(name: string): any;
-  hasEffect(effect: string): boolean; 
+  getCurrentMap(): ReturnType<RpgPlayer['getCurrentMap']>;
 }
 
 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.
+     * The attack formula is already defined but you can customize it in the server options.
+     * This method handles all aspects of damage calculation including critical hits,
+     * elemental vulnerabilities, guard effects, and applies the final damage to HP.
+     *
+     * @param attackerPlayer - The attacking player who deals the damage
+     * @param skill - Optional skill object for magical attacks, if not provided uses physical attack
+     * @returns Object containing damage details and special effects that occurred
+     * 
+     * @example
+     * ```ts
+     * // Physical attack
+     * const result = player.applyDamage(attackerPlayer);
+     * console.log(`Physical damage: ${result.damage}, Critical: ${result.critical}`);
+     * 
+     * // Magical attack with skill
+     * const fireSkill = { id: 'fire', power: 50, element: 'fire' };
+     * const magicResult = player.applyDamage(attackerPlayer, fireSkill);
+     * console.log(`Magic damage: ${magicResult.damage}, Vulnerable: ${magicResult.elementVulnerable}`);
+     * 
+     * // Check for guard effects
+     * if (result.guard) {
+     *   console.log('Attack was partially blocked!');
+     * }
+     * if (result.superGuard) {
+     *   console.log('Attack was heavily reduced by super guard!');
+     * }
+     * ```
+     */
   applyDamage(attackerPlayer: RpgPlayer, skill?: any): {
     damage: number;
     critical: boolean;
@@ -23,27 +57,8 @@ export interface IBattleManager {
   };
 }
 
-export function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(
-  Base: TBase
-): Constructor<IBattleManager> & TBase {
-  return class extends Base implements 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.
-     * The attack formula is already defined but you can customize it in the server options
-     *
-     * ```ts
-     * player.applyDamage(attackerPlayer) // returns { damage: number }
-     * ```
-     *
-     * @title Apply Damage
-     * @method player.applyDamage(attackerPlayer,skill)
-     * @param {RpgPlayer} attackerPlayer The attacking player
-     * @param {any} [skill]
-     * @returns {object}
-     * @memberof BattleManager
-     * */
+export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IBattleManager {
+  return class extends Base {
     applyDamage(
       attackerPlayer: RpgPlayer,
       skill?: any
@@ -54,15 +69,16 @@ export function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(
       guard: boolean;
       superGuard: boolean;
     } {
+      const self = this as unknown as PlayerWithMixins;
       const getParam = (player: RpgPlayer) => {
         const params = {};
-        this.parameters.forEach((val, key) => {
-          params[key] = player.param[key];
+        Object.keys(self.parameters).forEach((key) => {
+          params[key] = (player as any).param[key];
         });
         return {
-          [ATK]: player.atk,
-          [PDEF]: player.pdef,
-          [SDEF]: player.sdef,
+          [ATK]: (player as any).atk,
+          [PDEF]: (player as any).pdef,
+          [SDEF]: (player as any).sdef,
           ...params,
         };
       };
@@ -73,26 +89,25 @@ export function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(
       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.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) {
@@ -101,8 +116,8 @@ export function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(
           damage = newDamage;
         }
       }
-      if (this.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) {
@@ -111,11 +126,11 @@ export function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(
           damage = newDamage;
         }
       }
-      if (this.hasEffect(Effect.SUPER_GUARD)) {
+      if (self.hasEffect(Effect.SUPER_GUARD)) {
         damage /= 4;
         superGuard = true;
       }
-      this.hp -= damage;
+      self.hp -= damage;
       return {
         damage,
         critical,
@@ -125,9 +140,36 @@ export function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(
       };
     }
 
+    /**
+     * Get damage formulas from the current map
+     * 
+     * Retrieves the damage calculation formulas defined in the current map's configuration.
+     * These formulas are used to calculate different types of damage including physical,
+     * magical, critical hits, and guard effects. The formulas provide flexibility in
+     * customizing the battle system's damage calculations.
+     * 
+     * @param name - The name of the formula to retrieve (e.g., 'damagePhysic', 'damageSkill')
+     * @returns The formula function or undefined if not found
+     * 
+     * @example
+     * ```ts
+     * // Get physical damage formula
+     * const physicFormula = player.getFormulas('damagePhysic');
+     * if (physicFormula) {
+     *   const damage = physicFormula(attackerParams, defenderParams);
+     * }
+     * 
+     * // Get critical damage formula
+     * const criticalFormula = player.getFormulas('damageCritical');
+     * if (criticalFormula) {
+     *   const criticalDamage = criticalFormula(baseDamage, attackerParams, defenderParams);
+     * }
+     * ```
+     */
     getFormulas(name: string) {
-      const map = this.getCurrentMap(); 
-      return map.damageFormulas[name];
+      const self = this as unknown as PlayerWithMixins;
+      const map = self.getCurrentMap(); 
+      return map?.damageFormulas[name];
     }
-  };
-}
+  } as unknown as any;
+}

package/src/Player/ClassManager.ts

@@ -1,4 +1,4 @@
-import { Constructor, isString, RpgCommonPlayer } from "@rpgjs/common";
+import { Constructor, isString, PlayerCtor, RpgCommonPlayer } from "@rpgjs/common";
 
 type ClassClass = any;
 type ActorClass = any;
@@ -6,73 +6,141 @@ 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;
 }
 
-export interface IClassManager {
-  setClass(_class: ClassClass | string): ClassClass;
-  setActor(actorClass: ActorClass | string): ActorClass;
-}
+/**
+ * Class Manager Mixin
+ * 
+ * Provides class and actor management capabilities to any class. This mixin handles
+ * character class assignment and actor setup, including automatic parameter configuration,
+ * starting equipment, and skill progression based on class definitions.
+ * 
+ * @param Base - The base class to extend with class management
+ * @returns Extended class with class management methods
+ * 
+ * @example
+ * ```ts
+ * class MyPlayer extends WithClassManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     // Class system is automatically initialized
+ *   }
+ * }
+ * 
+ * const player = new MyPlayer();
+ * player.setClass(Fighter);
+ * player.setActor(Hero);
+ * ```
+ */
+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;
+    }
 
-export function WithClassManager<TBase extends Constructor<PlayerWithMixins>>(
-  Base: TBase
-): Constructor<IClassManager> & TBase {
-  return class extends Base implements IClassManager {
+    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
-     *
-     * ```ts
-     * import { Fighter } from 'my-database/classes/fighter'
-     *
-     * player.setClass(Fighter)
-     * ```
-     *
-     * @title Set Class
-     * @method player.setClass(ClassClass)
-     * @param {ClassClass | string} class class or id
-     * @returns {instance of ClassClass}
-     * @memberof ClassManager
-     * */
+     * 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.databaseById(_class);
-      const classInstance = new (_class as ClassClass)();
-      this["execMethod"]("onSet", [this], classInstance);
+      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)
-     *
-     * ```ts
-     * import { Hero } from 'my-database/classes/hero'
-     *
-     * player.setActor(Hero)
-     * ```
-     *
-     * @title Set Actor
-     * @method player.setActor(ActorClass)
-     * @param {ActorClass | string} actorClass actor class or id
-     * @returns {instance of ActorClass}
-     * @memberof ClassManager
-     * */
     setActor(actorClass: ActorClass | string) {
-      if (isString(actorClass)) actorClass = this.databaseById(actorClass);
+      if (isString(actorClass)) actorClass = (this as any).databaseById(actorClass);
       const actor = new (actorClass as ActorClass)();
       ["name", "initialLevel", "finalLevel", "expCurve"].forEach((key) => {
-        if (actor[key]) this[key] = actor[key];
+        if (actor[key]) (this as any)[key] = actor[key];
       });
       for (let param in actor.parameters) {
-        this.addParameter(param, actor.parameters[param]);
+        (this as any).addParameter(param, actor.parameters[param]);
       }
       for (let item of actor.startingEquipment) {
-        this.addItem(item);
-        this.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["execMethod"]("onSet", [this], actor);
+      (this as any)["execMethod"]("onSet", [this], actor);
       return actor;
     }
-  };
+  } as unknown as TBase;
+}
+
+/**
+ * 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 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;
 }