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

package/dist/Gui/DialogGui.d.ts

@@ -17,6 +17,11 @@ export interface DialogOptions {
     tranparent?: boolean;
     typewriterEffect?: boolean;
     talkWith?: RpgPlayer;
+    speaker?: string;
+    face?: {
+        id: string;
+        expression: string;
+    };
 }
 export declare class DialogGui extends Gui {
     constructor(player: RpgPlayer);

package/dist/Gui/GameoverGui.d.ts

@@ -0,0 +1,23 @@
+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 declare class GameoverGui extends Gui {
+    constructor(player: RpgPlayer);
+    open(options?: GameoverGuiOptions): Promise<GameoverGuiSelection | null>;
+}

package/dist/Gui/Gui.d.ts

@@ -4,10 +4,16 @@ export declare class Gui {
     protected player: RpgPlayer;
     private _close;
     private _blockPlayerInput;
+    private _events;
     constructor(id: string, player: RpgPlayer);
     open(data?: any, { waitingAction, blockPlayerInput }?: {
         waitingAction?: boolean | undefined;
         blockPlayerInput?: boolean | undefined;
     }): Promise<any>;
+    on(event: string, callback: (data: any) => void): void;
+    emit(event: string, data: any): Promise<any>;
     close(data?: any): void;
+    update(data?: any, { clientActionId }?: {
+        clientActionId?: string;
+    }): void;
 }

package/dist/Gui/MenuGui.d.ts

@@ -1,7 +1,26 @@
 import { Gui } from './Gui';
 import { RpgPlayer } from '../Player/Player';
-import { IGui } from '../Interfaces/Gui';
-export declare class MenuGui extends Gui implements IGui {
+import { SaveSlot } from './SaveLoadGui';
+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 declare class MenuGui extends Gui {
+    private menuOptions;
     constructor(player: RpgPlayer);
-    open(): Promise<any>;
+    private buildSaveLoad;
+    private buildMenuData;
+    private refreshMenu;
+    open(options?: MenuGuiOptions): Promise<any>;
 }

package/dist/Gui/NotificationGui.d.ts

@@ -1,6 +1,5 @@
 import { Gui } from './Gui';
 import { RpgPlayer } from '../Player/Player';
-import { IGui } from '../Interfaces/Gui';
-export declare class NotificationGui extends Gui implements IGui {
+export declare class NotificationGui extends Gui {
     constructor(player: RpgPlayer);
 }

package/dist/Gui/SaveLoadGui.d.ts

@@ -0,0 +1,13 @@
+import { SaveSlot } from '../../../common/src';
+import { Gui } from './Gui';
+import { RpgPlayer } from '../Player/Player';
+export type SaveLoadMode = 'save' | 'load';
+export type { SaveSlot } from '../../../common/src';
+export interface SaveLoadOptions {
+    mode?: SaveLoadMode;
+    maxSlots?: number;
+}
+export declare class SaveLoadGui extends Gui {
+    constructor(player: RpgPlayer);
+    open(slots?: SaveSlot[], options?: SaveLoadOptions): Promise<number | null>;
+}

package/dist/Gui/ShopGui.d.ts

@@ -1,7 +1,28 @@
 import { Gui } from './Gui';
 import { RpgPlayer } from '../Player/Player';
-import { IGui } from '../Interfaces/Gui';
-export declare 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 declare class ShopGui extends Gui {
+    private itemsInput;
+    private sellMultipliers;
+    private baseSellMultiplier;
+    private messageInput?;
+    private faceInput?;
     constructor(player: RpgPlayer);
-    open(items: any[]): Promise<any>;
+    private normalizeSellMultipliers;
+    private buildShopData;
+    private refreshShop;
+    open(itemsOrOptions: any[] | ShopGuiOptions): Promise<any>;
 }

package/dist/Gui/TitleGui.d.ts

@@ -0,0 +1,23 @@
+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 declare class TitleGui extends Gui {
+    constructor(player: RpgPlayer);
+    open(options?: TitleGuiOptions): Promise<TitleGuiSelection | null>;
+}

package/dist/Gui/index.d.ts

@@ -3,4 +3,13 @@ import { DialogGui } from './DialogGui';
 import { MenuGui } from './MenuGui';
 import { ShopGui } from './ShopGui';
 import { NotificationGui } from './NotificationGui';
-export { Gui, DialogGui, MenuGui, ShopGui, NotificationGui };
+import { SaveLoadGui } from './SaveLoadGui';
+import { TitleGui } from './TitleGui';
+import { GameoverGui } from './GameoverGui';
+export { Gui, DialogGui, MenuGui, ShopGui, 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/dist/Player/BattleManager.d.ts

@@ -1,15 +1,38 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { PlayerCtor } from '../../../common/src';
 import { RpgPlayer } from './Player';
-interface PlayerWithMixins extends RpgCommonPlayer {
-    parameters: any[];
-    getFormulas(name: string): any;
-    hasEffect(effect: string): boolean;
-    coefficientElements(attackerPlayer: RpgPlayer): number;
-    hp: number;
-    getFormulas(name: string): any;
-    hasEffect(effect: string): boolean;
-}
 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;
@@ -18,5 +41,4 @@ export interface IBattleManager {
         superGuard: boolean;
     };
 }
-export declare function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(Base: TBase): Constructor<IBattleManager> & TBase;
-export {};
+export declare function WithBattleManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IBattleManager;

package/dist/Player/ClassManager.d.ts

@@ -1,18 +1,51 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { PlayerCtor } from '../../../common/src';
 type ClassClass = any;
 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;
-}
+/**
+ * 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 declare function WithClassManager<TBase extends PlayerCtor>(Base: TBase): 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 {
-    setClass(_class: ClassClass | string): ClassClass;
-    setActor(actorClass: ActorClass | string): ActorClass;
+    /**
+     * 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;
 }
-export declare function WithClassManager<TBase extends Constructor<PlayerWithMixins>>(Base: TBase): Constructor<IClassManager> & TBase;
 export {};

package/dist/Player/ComponentManager.d.ts

@@ -0,0 +1,123 @@
+import { Constructor, RpgCommonPlayer } from '../../../common/src';
+import { ComponentInput, ComponentLayout } from './Components';
+type ComponentPosition = 'top' | 'center' | 'bottom' | 'left' | 'right';
+/**
+ * Component Manager Mixin
+ *
+ * Provides graphic and component management capabilities to any class. This mixin allows
+ * setting single or multiple graphics for player representation, enabling
+ * dynamic visual changes and animation sequences. It also provides methods to
+ * display UI components around the player graphic (top, bottom, center, left, right).
+ *
+ * Components are stored as JSON strings for efficient synchronization.
+ *
+ * @param Base - The base class to extend with component management
+ * @returns Extended class with component management methods
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithComponentManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     this.setGraphic("hero");
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * player.setGraphic(["hero_idle", "hero_walk"]);
+ * player.setComponentsTop(Components.text('{name}'));
+ * ```
+ */
+export declare function WithComponentManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IComponentManager;
+/**
+ * Interface for component management capabilities
+ * Defines the method signatures that will be available on the player
+ */
+export interface IComponentManager {
+    /**
+     * Set the graphic(s) for this player
+     *
+     * Allows setting either a single graphic or multiple graphics for the player.
+     * When multiple graphics are provided, they are used for animation sequences.
+     * The graphics system provides flexible visual representation that can be
+     * dynamically changed during gameplay for different states, equipment, or animations.
+     *
+     * @param graphic - Single graphic name or array of graphic names for animation sequences
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * // Set a single graphic for static representation
+     * player.setGraphic("hero");
+     *
+     * // Set multiple graphics for animation sequences
+     * player.setGraphic(["hero_idle", "hero_walk", "hero_run"]);
+     *
+     * // Dynamic graphic changes based on equipment
+     * if (player.hasArmor('platemail')) {
+     *   player.setGraphic("hero_armored");
+     * }
+     *
+     * // Animation sequences for different actions
+     * player.setGraphic(["mage_cast_1", "mage_cast_2", "mage_cast_3"]);
+     * ```
+     */
+    setGraphic(graphic: string | string[]): void;
+    /**
+     * Set components to display above the player graphic
+     *
+     * @param layout - Component(s) to display, can be single, array, or 2D array
+     * @param options - Optional layout options for positioning and sizing
+     * @returns void
+     */
+    setComponentsTop(layout: ComponentInput, options?: ComponentLayout): void;
+    /**
+     * Set components to display below the player graphic
+     *
+     * @param layout - Component(s) to display, can be single, array, or 2D array
+     * @param options - Optional layout options for positioning and sizing
+     * @returns void
+     */
+    setComponentsBottom(layout: ComponentInput, options?: ComponentLayout): void;
+    /**
+     * Set components to display at the center of the player graphic
+     *
+     * @param layout - Component(s) to display, can be single, array, or 2D array
+     * @param options - Optional layout options for positioning and sizing
+     * @returns void
+     */
+    setComponentsCenter(layout: ComponentInput, options?: ComponentLayout): void;
+    /**
+     * Set components to display to the left of the player graphic
+     *
+     * @param layout - Component(s) to display, can be single, array, or 2D array
+     * @param options - Optional layout options for positioning and sizing
+     * @returns void
+     */
+    setComponentsLeft(layout: ComponentInput, options?: ComponentLayout): void;
+    /**
+     * Set components to display to the right of the player graphic
+     *
+     * @param layout - Component(s) to display, can be single, array, or 2D array
+     * @param options - Optional layout options for positioning and sizing
+     * @returns void
+     */
+    setComponentsRight(layout: ComponentInput, options?: ComponentLayout): void;
+    /**
+     * Remove components from a specific position
+     *
+     * @param position - Position of the components: 'top', 'center', 'bottom', 'left', or 'right'
+     * @returns void
+     */
+    removeComponents(position: ComponentPosition): void;
+    /**
+     * Merge components with existing components at a specific position
+     *
+     * @param position - Position of the components: 'top', 'center', 'bottom', 'left', or 'right'
+     * @param layout - Component(s) to merge, can be single, array, or 2D array
+     * @param options - Optional layout options for positioning and sizing
+     * @returns void
+     */
+    mergeComponents(position: ComponentPosition, layout: ComponentInput, options?: ComponentLayout): void;
+}
+export {};