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

package/dist/Player/GuiManager.d.ts

@@ -0,0 +1,259 @@
+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
+ *
+ * Provides graphical user interface management capabilities to any class. This mixin handles
+ * dialog boxes, menus, notifications, shops, and custom GUI components. It manages the
+ * complete GUI system including opening, closing, and data passing between client and server.
+ *
+ * @param Base - The base class to extend with GUI management
+ * @returns Extended class with GUI management methods
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithGuiManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     // GUI system is automatically initialized
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * await player.showText('Hello World!');
+ * player.callMainMenu();
+ * ```
+ */
+export declare function WithGuiManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IGuiManager;
+/**
+ * Interface for GUI management capabilities
+ * Defines the methods that will be available on the player
+ */
+export interface IGuiManager {
+    /**
+     * Show a text. This is a graphical interface already built. Opens the GUI named `rpg-dialog`
+     *
+     * ```ts
+     * player.showText('Hello World')
+     * ```
+     *
+     * The method returns a promise. It is resolved when the dialog box is closed.
+     *
+     * ```ts
+     * await player.showText('Hello World')
+     * // dialog box is closed, then ...
+     * ```
+     *
+     * **Option: position**
+     *
+     * You can define how the dialog box is displayed:
+     * - top
+     * - middle
+     * - bottom
+     *
+     * (bottom by default)
+     *
+     * ```ts
+     * player.showText('Hello World', {
+     *      position: 'top'
+     * })
+     * ```
+     *
+     * **Option: fullWidth**
+     *
+     * `boolean` (true by default)
+     *
+     * Indicate that the dialog box will take the full width of the screen.
+     *
+     * ```ts
+     * player.showText('Hello World', {
+     *      fullWidth: true
+     * })
+     * ```
+     *
+     * **Option: autoClose**
+     *
+     * `boolean` (false by default)
+     *
+     * If false, the user will have to press Enter to close the dialog box.
+     *
+     *  ```ts
+     * player.showText('Hello World', {
+     *      autoClose: true
+     * })
+     * ```
+     *
+     * **Option: typewriterEffect**
+     *
+     * `boolean` (true by default)
+     *
+     * Performs a typewriter effect
+     *
+     *  ```ts
+     * player.showText('Hello World', {
+     *      typewriterEffect: false
+     * })
+     * ```
+     *
+     * **Option: talkWith**
+     *
+     * `RpgPlayer` (nothing by default)
+     *
+     * If you specify the event or another player, the other player will stop his or her movement and look in the player's direction.
+     *
+     *  ```ts
+     * // Code in an event
+     * player.showText('Hello World', {
+     *      talkWith: this
+     * })
+     * ```
+     *
+     * @title Show Text
+     * @method player.showText(text,options)
+     * @param {string} text
+     * @param {object} [options] the different options, see usage below
+     * @returns {Promise}
+     * @memberof GuiManager
+     */
+    showText(msg: string, options?: DialogOptions): Promise<any>;
+    /**
+     * Shows a dialog box with a choice. Opens the GUI named `rpg-dialog`
+     *
+     * ```ts
+     * const choice = await player.showChoices('What color do you prefer?', [
+     *      { text: 'Black', value: 'black' },
+     *      { text: 'Rather the blue', value: 'blue' },
+     *      { text: 'I don\'t have a preference!', value: 'none' }
+     * ])
+     *
+     * // If the player selects the first
+     * console.log(choice) // { text: 'Black', value: 'black' }
+     * ```
+     *
+     * @title Show Choices
+     * @method player.showChoices(text,choices)
+     * @param {string} text
+     * @param {Array<{ text: string, value: any }>} choices
+     * @param {object} [options] Same options as the openDialog method
+     * @returns {Promise<Choice | null>}
+     * @memberof GuiManager
+     */
+    showChoices(msg: string, choices: Choice[], options?: DialogOptions): Promise<Choice | null>;
+    /**
+     * Displays a notification . Opens the GUI named `rpg-notification`
+     *
+     * @title Displays a notification
+     * @method player.showNotification()
+     * @param {string} message - The message to display in the notification
+     * @param {object} options - An object containing options for the notification
+     * @param {number} options.time - The time to display the notification for (in ms). Default: 2000ms
+     * @param {string} options.icon - The icon to display in the notification. Put the identifier of the spritesheet (defined on the client side)
+     * @param {string} options.sound - The sound to play when the notification is shown. Set the sound ID (defined on the client side)
+     * @returns {void}
+     * @memberof GuiManager
+     */
+    showNotification(message: 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(options)
+     * @param {object} [options]
+     * @returns {void}
+     * @memberof GuiManager
+     */
+    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/ItemFixture.d.ts

@@ -0,0 +1,6 @@
+import { ItemInstance } from '@rpgjs/database';
+import { PlayerCtor } from '../../../common/src';
+export declare function WithItemFixture<TBase extends PlayerCtor>(Base: TBase): TBase;
+export interface ItemFixture {
+    equipments: ItemInstance[];
+}