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

package/dist/Gui/DialogGui.d.ts

@@ -17,6 +17,7 @@ export interface DialogOptions {
     tranparent?: boolean;
     typewriterEffect?: boolean;
     talkWith?: RpgPlayer;
+    speaker?: string;
     face?: {
         id: string;
         expression: string;

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,5 +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/GuiManager.d.ts

@@ -1,6 +1,9 @@
 import { RpgPlayer } from './Player';
 import { Gui } 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 { PlayerCtor } from '../../../common/src';
 /**
  * GUI Manager Mixin
@@ -158,18 +161,98 @@ export interface IGuiManager {
         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;

package/dist/Player/Player.d.ts

@@ -16,6 +16,7 @@ import { ISkillManager } from './SkillManager';
 import { IBattleManager } from './BattleManager';
 import { IClassManager } from './ClassManager';
 import { IStateManager } from './StateManager';
+import { SaveRequestContext, SaveSlotIndex, SaveSlotMeta } from '../services/save';
 declare const RpgPlayer_base: Constructor<RpgCommonPlayer>;
 /**
  * RPG Player class with component management capabilities
@@ -126,8 +127,29 @@ export declare class RpgPlayer extends RpgPlayer_base {
     }): Promise<false | undefined>;
     getCurrentMap<T extends RpgMap = RpgMap>(): T | null;
     emit(type: string, value?: any): void;
-    save(): Promise<string>;
-    load(snapshot: string): Promise<void>;
+    snapshot(): Record<string, any>;
+    applySnapshot(snapshot: string | object): Promise<any>;
+    save(slot?: SaveSlotIndex, meta?: SaveSlotMeta, context?: SaveRequestContext): Promise<{
+        index: number;
+        meta: import('../../../common/src').SaveSlotMeta;
+    } | null>;
+    load(slot?: SaveSlotIndex, context?: SaveRequestContext, options?: {
+        changeMap?: boolean;
+    }): Promise<{
+        ok: boolean;
+        slot?: undefined;
+        index?: undefined;
+    } | {
+        ok: boolean;
+        slot: {
+            [key: string]: any;
+            level?: number;
+            exp?: number;
+            map?: string;
+            date?: string;
+        };
+        index: number;
+    }>;
     /**
      * @deprecated Use setGraphicAnimation instead.
      * @param animationName - The name of the animation to play (e.g., 'attack', 'skill', 'walk')

package/dist/RpgServer.d.ts

@@ -168,6 +168,13 @@ export interface RpgPlayerHooks {
     */
     onConnected?: (player: RpgPlayer) => any;
     /**
+    *  When the player starts the game from the lobby
+    *
+    * @prop { (player: RpgPlayer) => any } [onStart]
+    * @memberof RpgPlayerHooks
+    */
+    onStart?: (player: RpgPlayer) => any;
+    /**
     *  When the player presses a key on the client side
     *
     * @prop { (player: RpgPlayer, data: { input: Direction | Control | string, moving: boolean }) => any } [onInput]

package/dist/RpgServerEngine.d.ts

@@ -1,5 +1,6 @@
 import { Server } from '@signe/room';
+import { RpgMap } from './rooms/map';
 import { LobbyRoom } from './rooms/lobby';
 export declare class RpgServerEngine extends Server {
-    rooms: (typeof LobbyRoom)[];
+    rooms: (typeof RpgMap | typeof LobbyRoom)[];
 }

package/dist/index.d.ts

@@ -10,7 +10,10 @@ export * from './rooms/map';
 export * from './presets';
 export * from '@signe/reactive';
 export * from './Gui';
-export { RpgShape, RpgModule } from '../../common/src';
+export * from './services/save';
+export * from './storage';
+export { RpgShape, RpgModule, MAXHP, MAXSP, ATK, PDEF, SDEF, STR, AGI, INT, DEX } from '../../common/src';
 export * from './decorators/event';
 export * from './decorators/map';
 export * from './Player/MoveManager';
+export * from './presets';