@rpgjs/server 5.0.0-alpha.1 → 5.0.0-alpha.10

package/dist/Player/BattleManager.d.ts

@@ -1,22 +1,32 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
-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 {
-    applyDamage(attackerPlayer: RpgPlayer, skill?: any): {
-        damage: number;
-        critical: boolean;
-        elementVulnerable: boolean;
-        guard: boolean;
-        superGuard: boolean;
-    };
-}
-export declare function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(Base: TBase): Constructor<IBattleManager> & TBase;
-export {};
+import { PlayerCtor } from '@rpgjs/common';
+/**
+ * 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 declare function WithBattleManager<TBase extends PlayerCtor>(Base: TBase): 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>>;

package/dist/Player/ClassManager.d.ts

@@ -1,18 +1,31 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
-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;
-}
-export interface IClassManager {
-    setClass(_class: ClassClass | string): ClassClass;
-    setActor(actorClass: ActorClass | string): ActorClass;
-}
-export declare function WithClassManager<TBase extends Constructor<PlayerWithMixins>>(Base: TBase): Constructor<IClassManager> & TBase;
-export {};
+import { PlayerCtor } from '@rpgjs/common';
+/**
+ * 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;
+/**
+ * Type helper to extract the interface from the WithClassManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IClassManager = InstanceType<ReturnType<typeof WithClassManager>>;

package/dist/Player/ComponentManager.d.ts

@@ -0,0 +1,60 @@
+import { PlayerCtor } from '@rpgjs/common';
+/**
+ * Component Manager Mixin
+ *
+ * Provides graphic management capabilities to any class. This mixin allows
+ * setting single or multiple graphics for player representation, enabling
+ * dynamic visual changes and animation sequences.
+ *
+ * @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"]);
+ * ```
+ */
+export declare function WithComponentManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IComponentManager;
+/**
+ * Interface for component management capabilities
+ * Defines the method signature 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;
+}

package/dist/Player/EffectManager.d.ts

@@ -0,0 +1,40 @@
+import { PlayerCtor } from '@rpgjs/common';
+export declare enum Effect {
+    CAN_NOT_SKILL = "CAN_NOT_SKILL",
+    CAN_NOT_ITEM = "CAN_NOT_ITEM",
+    CAN_NOT_STATE = "CAN_NOT_STATE",
+    CAN_NOT_EQUIPMENT = "CAN_NOT_EQUIPMENT",
+    HALF_SP_COST = "HALF_SP_COST",
+    GUARD = "GUARD",
+    SUPER_GUARD = "SUPER_GUARD"
+}
+/**
+ * Effect Manager Mixin
+ *
+ * Provides effect management capabilities to any class. This mixin handles
+ * player effects including restrictions, buffs, and debuffs. Effects can come
+ * from various sources like states, equipment, and temporary conditions.
+ *
+ * @param Base - The base class to extend with effect management
+ * @returns Extended class with effect management methods
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithEffectManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     // Effect system is automatically initialized
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * player.effects = [Effect.GUARD];
+ * console.log(player.hasEffect(Effect.GUARD)); // true
+ * ```
+ */
+export declare function WithEffectManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+/**
+ * Type helper to extract the interface from the WithEffectManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IEffectManager = InstanceType<ReturnType<typeof WithEffectManager>>;

package/dist/Player/ElementManager.d.ts

@@ -0,0 +1,31 @@
+import { PlayerCtor } from '@rpgjs/common';
+/**
+ * Element Manager Mixin
+ *
+ * Provides elemental management capabilities to any class. This mixin handles
+ * elemental resistances, vulnerabilities, and attack elements. It manages both
+ * defensive capabilities (elementsDefense) and offensive elements from equipment,
+ * as well as player-specific elemental efficiency modifiers.
+ *
+ * @param Base - The base class to extend with element management
+ * @returns Extended class with element management methods
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithElementManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     this.elementsEfficiency = [{ rate: 0.5, element: 'fire' }];
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * const fireResistance = player.elementsDefense.find(e => e.element === 'fire');
+ * ```
+ */
+export declare function WithElementManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+/**
+ * Type helper to extract the interface from the WithElementManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IElementManager = InstanceType<ReturnType<typeof WithElementManager>>;

package/dist/Player/GoldManager.d.ts

@@ -0,0 +1,22 @@
+import { PlayerCtor } from '@rpgjs/common';
+export interface GoldManager {
+    /**
+     * You can change the game money
+     *
+     * ```ts
+     * player.gold += 100
+     * ```
+     *
+     * @title Change Gold
+     * @prop {number} player.gold
+     * @default 0
+     * @memberof GoldManager
+     * */
+    gold: number;
+}
+export declare function WithGoldManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & GoldManager;
+/**
+ * Type helper to extract the interface from the WithGoldManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IGoldManager = InstanceType<ReturnType<typeof WithGoldManager>>;

package/dist/Player/GuiManager.d.ts

@@ -0,0 +1,176 @@
+import { RpgPlayer } from './Player';
+import { Gui } from '../Gui';
+import { DialogOptions, Choice } from '../Gui/DialogGui';
+import { PlayerCtor } from '@rpgjs/common';
+/**
+ * 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;
+    }): Promise<any>;
+    /**
+     * Calls main menu. Opens the GUI named `rpg-main-menu`
+     *
+     * @title Call Main Menu
+     * @method player.callMainMenu()
+     * @returns {void}
+     * @memberof GuiManager
+     */
+    callMainMenu(): void;
+    callShop(items: any[]): void;
+    gui(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 '@rpgjs/common';
+export declare function WithItemFixture<TBase extends PlayerCtor>(Base: TBase): TBase;
+export interface ItemFixture {
+    equipments: ItemInstance[];
+}

package/dist/Player/ItemManager.d.ts

@@ -1,17 +1,31 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
-import { ItemClass } from '@rpgjs/database';
+import { PlayerCtor } from '@rpgjs/common';
 /**
- * Interface defining what MoveManager adds to a class
- */
-export interface IItemManager {
-    databaseById(id: string): ItemClass;
-}
-/**
- * Move Manager mixin
+ * Item Manager Mixin
+ *
+ * Provides comprehensive item management capabilities to any class. This mixin handles
+ * inventory management, item usage, equipment, buying/selling, and item effects.
+ * It manages the complete item system including restrictions, transactions, and equipment.
  *
- * Adds methods to manage player movement
+ * @param Base - The base class to extend with item management
+ * @returns Extended class with item management methods
  *
- * @param Base - The base class to extend
- * @returns A new class with move management capabilities
+ * @example
+ * ```ts
+ * class MyPlayer extends WithItemManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     // Item system is automatically initialized
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * player.addItem('potion', 5);
+ * player.useItem('potion');
+ * ```
+ */
+export declare function WithItemManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+/**
+ * Type helper to extract the interface from the WithItemManager mixin
+ * This provides the type without duplicating method signatures
  */
-export declare function WithItemManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): Constructor<IItemManager> & TBase;
+export type IItemManager = InstanceType<ReturnType<typeof WithItemManager>>;

package/dist/Player/MoveManager.d.ts

@@ -1,48 +1,7 @@
-import { Constructor, RpgCommonPlayer, Direction, MovementStrategy, ProjectileType } from '@rpgjs/common';
+import { PlayerCtor, Direction } from '@rpgjs/common';
 import { RpgPlayer } from './Player';
-export interface IMoveManager {
-    addMovement(strategy: MovementStrategy): void;
-    removeMovement(strategy: MovementStrategy): boolean;
-    clearMovements(): void;
-    hasActiveMovements(): boolean;
-    getActiveMovements(): MovementStrategy[];
-    moveTo(target: RpgCommonPlayer | {
-        x: number;
-        y: number;
-    }): void;
-    stopMoveTo(): void;
-    dash(direction: {
-        x: number;
-        y: number;
-    }, speed?: number, duration?: number): void;
-    knockback(direction: {
-        x: number;
-        y: number;
-    }, force?: number, duration?: number): void;
-    followPath(waypoints: Array<{
-        x: number;
-        y: number;
-    }>, speed?: number, loop?: boolean): void;
-    oscillate(direction: {
-        x: number;
-        y: number;
-    }, amplitude?: number, period?: number): void;
-    applyIceMovement(direction: {
-        x: number;
-        y: number;
-    }, maxSpeed?: number): void;
-    shootProjectile(type: ProjectileType, direction: {
-        x: number;
-        y: number;
-    }, speed?: number): void;
-    moveRoutes(routes: Routes): Promise<boolean>;
-    infiniteMoveRoute(routes: Routes): void;
-    breakRoutes(force?: boolean): void;
-    replayRoutes(): void;
-}
 type CallbackTileMove = (player: RpgPlayer, map: any) => Direction[];
 type CallbackTurnMove = (player: RpgPlayer, map: any) => string;
-type Routes = (string | Promise<any> | Direction | Direction[] | Function)[];
 export declare enum Frequency {
     Lowest = 600,
     Lower = 400,
@@ -173,5 +132,34 @@ export declare const Move: MoveList;
  * }
  * ```
  */
-export declare function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): Constructor<IMoveManager> & TBase;
+/**
+ * Move Manager Mixin
+ *
+ * Provides comprehensive movement management capabilities to any class. This mixin handles
+ * various types of movement including pathfinding, physics-based movement, route following,
+ * and advanced movement strategies like dashing, knockback, and projectile movement.
+ *
+ * @param Base - The base class to extend with movement management
+ * @returns Extended class with movement management methods
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithMoveManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     this.frequency = Frequency.High;
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * player.moveTo({ x: 100, y: 100 });
+ * player.dash({ x: 1, y: 0 }, 8, 200);
+ * ```
+ */
+export declare function WithMoveManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+/**
+ * Type helper to extract the interface from the WithMoveManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IMoveManager = InstanceType<ReturnType<typeof WithMoveManager>>;
 export {};

package/dist/Player/ParameterManager.d.ts

@@ -1,21 +1,4 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
-export interface IWithParameterManager {
-    parameters: Map<string, any>;
-    hp: number;
-    sp: number;
-    exp: number;
-    level: number;
-    expForNextlevel: number;
-    param: {
-        [key: string]: number;
-    };
-    paramsModifier: {
-        [key: string]: {
-            value?: number;
-            rate?: number;
-        };
-    };
-}
+import { PlayerCtor } from '@rpgjs/common';
 /**
  * Mixin that adds parameter management functionality to a player class.
  *
@@ -39,4 +22,29 @@ export interface IWithParameterManager {
  * }
  * ```
  */
-export declare function WithParameterManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): TBase & Constructor<IWithParameterManager>;
+/**
+ * Parameter Manager Mixin
+ *
+ * Provides comprehensive parameter management functionality to any class. This mixin handles
+ * health points (HP), skill points (SP), experience and level progression, custom parameters,
+ * and parameter modifiers for temporary stat changes.
+ *
+ * @param Base - The base class to extend with parameter management
+ * @returns Extended class with parameter management methods
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithParameterManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     this.addParameter('strength', { start: 10, end: 100 });
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * player.hp = 100;
+ * player.level = 5;
+ * ```
+ */
+export declare function WithParameterManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+export type IParameterManager = InstanceType<ReturnType<typeof WithParameterManager>>;