@rpgjs/server 5.0.0-alpha.5 → 5.0.0-alpha.7

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,30 @@
+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): TBase;
+/**
+ * Type helper to extract the interface from the WithComponentManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IComponentManager = InstanceType<ReturnType<typeof WithComponentManager>>;

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,31 @@
+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): TBase;
+/**
+ * Type helper to extract the interface from the WithGuiManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type IGuiManager = InstanceType<ReturnType<typeof WithGuiManager>>;

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>>;

package/dist/Player/Player.d.ts

@@ -1,4 +1,4 @@
-import { RpgCommonPlayer, ShowAnimationParams, Constructor, ZoneOptions } from '@rpgjs/common';
+import { RpgCommonPlayer, ShowAnimationParams } from '@rpgjs/common';
 import { IComponentManager } from './ComponentManager';
 import { RpgMap } from '../rooms/map';
 import { Context } from '@signe/di';
@@ -6,12 +6,43 @@ import { IGuiManager } from './GuiManager';
 import { MockConnection } from '@signe/room';
 import { IMoveManager } from './MoveManager';
 import { IGoldManager } from './GoldManager';
-import { IWithVariableManager } from './VariableManager';
-import { IWithParameterManager } from './ParameterManager';
-import { IWithSkillManager } from './SkillManager';
-declare const RpgPlayer_base: Constructor<RpgCommonPlayer>;
+import { IVariableManager } from './VariableManager';
+import { IParameterManager } from './ParameterManager';
+import { IItemManager } from './ItemManager';
+import { IEffectManager } from './EffectManager';
+import { IElementManager } from './ElementManager';
+import { ISkillManager } from './SkillManager';
+import { IBattleManager } from './BattleManager';
+import { IClassManager } from './ClassManager';
+import { IStateManager } from './StateManager';
+interface ZoneOptions {
+    x?: number;
+    y?: number;
+    radius: number;
+    angle?: number;
+    direction?: any;
+    linkedTo?: string;
+    limitedByWalls?: boolean;
+}
+declare const RpgPlayer_base: typeof RpgCommonPlayer;
 /**
  * RPG Player class with component management capabilities
+ *
+ * Combines all player mixins to provide a complete player implementation
+ * with graphics, movement, inventory, skills, and battle capabilities.
+ *
+ * @example
+ * ```ts
+ * // Create a new player
+ * const player = new RpgPlayer();
+ *
+ * // Set player graphics
+ * player.setGraphic("hero");
+ *
+ * // Add parameters and items
+ * player.addParameter("strength", { start: 10, end: 100 });
+ * player.addItem(sword);
+ * ```
  */
 export declare class RpgPlayer extends RpgPlayer_base {
     map: RpgMap | null;
@@ -68,6 +99,12 @@ export declare class RpgEvent extends RpgPlayer {
     execMethod(methodName: string, methodData?: any[], instance?: this): Promise<any>;
     remove(): void;
 }
-export interface RpgPlayer extends RpgCommonPlayer, IComponentManager, IGuiManager, IMoveManager, IGoldManager, IWithVariableManager, IWithParameterManager, IWithSkillManager {
+/**
+ * Interface extension for RpgPlayer
+ *
+ * Extends the RpgPlayer class with additional interfaces from mixins.
+ * This provides proper TypeScript support for all mixin methods and properties.
+ */
+export interface RpgPlayer extends IVariableManager, IMoveManager, IGoldManager, IComponentManager, IGuiManager, IItemManager, IEffectManager, IParameterManager, IElementManager, ISkillManager, IBattleManager, IClassManager, IStateManager {
 }
 export {};

package/dist/Player/SkillManager.d.ts

@@ -1,23 +1,31 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
-import { RpgPlayer } from './Player';
+import { PlayerCtor } from '@rpgjs/common';
 /**
- * Interface defining dependencies from other mixins that SkillManager needs
+ * Skill Manager Mixin
+ *
+ * Provides skill management capabilities to any class. This mixin handles
+ * learning, forgetting, and using skills, including SP cost management,
+ * hit rate calculations, and skill effects application.
+ *
+ * @param Base - The base class to extend with skill management
+ * @returns Extended class with skill management methods
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithSkillManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     // Skill system is automatically initialized
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * player.learnSkill(Fire);
+ * player.useSkill(Fire, targetPlayer);
+ * ```
  */
-interface SkillManagerDependencies {
-    sp: number;
-    skills(): any[];
-    hasEffect(effect: string): boolean;
-    databaseById(id: string): any;
-    applyStates(player: RpgPlayer, skill: any): void;
-}
+export declare function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase;
 /**
- * Interface defining what SkillManager adds to a class
+ * Type helper to extract the interface from the WithSkillManager mixin
+ * This provides the type without duplicating method signatures
  */
-export interface IWithSkillManager {
-    getSkill(skillClass: any | string): any;
-    learnSkill(skillId: any | string): any;
-    forgetSkill(skillId: any | string): any;
-    useSkill(skillId: any | string, otherPlayer?: RpgPlayer | RpgPlayer[]): any;
-}
-export declare function WithSkillManager<TBase extends Constructor<RpgCommonPlayer & SkillManagerDependencies>>(Base: TBase): Constructor<IWithSkillManager> & TBase;
-export {};
+export type ISkillManager = InstanceType<ReturnType<typeof WithSkillManager>>;

package/dist/Player/StateManager.d.ts

@@ -1,39 +1,32 @@
-import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
-import { WritableArraySignal } from '@signe/reactive';
-import { RpgPlayer } from './Player';
-interface StateManagerDependencies {
-    equipments(): any[];
-    databaseById(id: string | StateClass): any;
-    addState(stateClass: StateClass | string, chance?: number): object | null;
-    removeState(stateClass: StateClass | string, chance?: number): void;
-}
+import { PlayerCtor } from '@rpgjs/common';
 /**
- * Interface defining what MoveManager adds to a class
- */
-export interface IStateManager {
-    statesDefense: {
-        rate: number;
-        state: any;
-    }[];
-    statesEfficiency: WritableArraySignal<any[]>;
-    applyStates(player: RpgPlayer, states: {
-        addStates?: any[];
-        removeStates?: any[];
-    }): void;
-    getState(stateClass: StateClass | string): any;
-    addState(stateClass: StateClass | string, chance?: number): object | null;
-    removeState(stateClass: StateClass | string, chance?: number): void;
-}
-type StateClass = {
-    new (...args: any[]): any;
-};
-/**
- * Move Manager mixin
+ * State Manager Mixin
+ *
+ * Provides state management capabilities to any class. This mixin handles
+ * player states (buffs/debuffs), state defense from equipment, and state
+ * efficiency modifiers. It manages the complete state system including
+ * application, removal, and resistance mechanics.
  *
- * Adds methods to manage player movement
+ * @param Base - The base class to extend with state management
+ * @returns Extended class with state management methods
  *
- * @param Base - The base class to extend
- * @returns A new class with move management capabilities
+ * @example
+ * ```ts
+ * class MyPlayer extends WithStateManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     // State system is automatically initialized
+ *   }
+ * }
+ *
+ * const player = new MyPlayer();
+ * player.addState(Paralyze);
+ * console.log(player.getState(Paralyze));
+ * ```
+ */
+export declare function WithStateManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+/**
+ * Type helper to extract the interface from the WithStateManager mixin
+ * This provides the type without duplicating method signatures
  */
-export declare function WithStateManager<TBase extends Constructor<RpgCommonPlayer & StateManagerDependencies>>(Base: TBase): Constructor<IStateManager> & TBase;
-export {};
+export type IStateManager = InstanceType<ReturnType<typeof WithStateManager>>;