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

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @rpgjs/server
+
+## 5.0.0-alpha.3
+
+### Patch Changes
+
+- alpha
+- Updated dependencies
+  - @rpgjs/common@5.0.0-alpha.3

package/dist/Player/BattleManager.d.ts

@@ -1,32 +1,22 @@
-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>>;
+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 {};

package/dist/Player/ClassManager.d.ts

@@ -1,31 +1,18 @@
-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>>;
+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 {};

package/dist/Player/ItemManager.d.ts

@@ -1,31 +1,17 @@
-import { PlayerCtor } from '@rpgjs/common';
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { ItemClass } from '@rpgjs/database';
 /**
- * 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.
- *
- * @param Base - The base class to extend with item management
- * @returns Extended class with item management methods
- *
- * @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');
- * ```
+ * Interface defining what MoveManager adds to a class
  */
-export declare function WithItemManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+export interface IItemManager {
+    databaseById(id: string): ItemClass;
+}
 /**
- * Type helper to extract the interface from the WithItemManager mixin
- * This provides the type without duplicating method signatures
+ * Move Manager mixin
+ *
+ * Adds methods to manage player movement
+ *
+ * @param Base - The base class to extend
+ * @returns A new class with move management capabilities
  */
-export type IItemManager = InstanceType<ReturnType<typeof WithItemManager>>;
+export declare function WithItemManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): Constructor<IItemManager> & TBase;

package/dist/Player/MoveManager.d.ts

@@ -1,7 +1,48 @@
-import { PlayerCtor, Direction } from '@rpgjs/common';
+import { Constructor, RpgCommonPlayer, Direction, MovementStrategy, ProjectileType } 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,
@@ -132,34 +173,5 @@ export declare const Move: MoveList;
  * }
  * ```
  */
-/**
- * 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 declare function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): Constructor<IMoveManager> & TBase;
 export {};

package/dist/Player/ParameterManager.d.ts

@@ -1,4 +1,21 @@
-import { PlayerCtor } from '@rpgjs/common';
+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;
+        };
+    };
+}
 /**
  * Mixin that adds parameter management functionality to a player class.
  *
@@ -22,29 +39,4 @@ import { PlayerCtor } from '@rpgjs/common';
  * }
  * ```
  */
-/**
- * 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>>;
+export declare function WithParameterManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): TBase & Constructor<IWithParameterManager>;

package/dist/Player/Player.d.ts

@@ -1,4 +1,4 @@
-import { RpgCommonPlayer } from '@rpgjs/common';
+import { RpgCommonPlayer, ShowAnimationParams, Constructor, ZoneOptions } from '@rpgjs/common';
 import { IComponentManager } from './ComponentManager';
 import { RpgMap } from '../rooms/map';
 import { Context } from '@signe/di';
@@ -6,43 +6,12 @@ import { IGuiManager } from './GuiManager';
 import { MockConnection } from '@signe/room';
 import { IMoveManager } from './MoveManager';
 import { IGoldManager } from './GoldManager';
-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;
+import { IWithVariableManager } from './VariableManager';
+import { IWithParameterManager } from './ParameterManager';
+import { IWithSkillManager } from './SkillManager';
+declare const RpgPlayer_base: Constructor<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;
@@ -78,33 +47,7 @@ export declare class RpgPlayer extends RpgPlayer_base {
     }): Promise<false | undefined>;
     getCurrentMap<T extends RpgMap = RpgMap>(): T | null;
     emit(type: string, value?: any): void;
-    /**
-     * Set the current animation of the player's sprite
-     *
-     * This method changes the animation state of the player's current sprite.
-     * It's used to trigger character animations like attack, skill, or custom movements.
-     * When `nbTimes` is set to a finite number, the animation will play that many times
-     * before returning to the previous animation state.
-     *
-     * @param animationName - The name of the animation to play (e.g., 'attack', 'skill', 'walk')
-     * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)
-     *
-     * @example
-     * ```ts
-     * // Set continuous walk animation
-     * player.setAnimation('walk');
-     *
-     * // Play attack animation 3 times then return to previous state
-     * player.setAnimation('attack', 3);
-     *
-     * // Play skill animation once
-     * player.setAnimation('skill', 1);
-     *
-     * // Set idle/stand animation
-     * player.setAnimation('stand');
-     * ```
-     */
-    setAnimation(animationName: string, nbTimes?: number): void;
+    showAnimation(params: ShowAnimationParams): void;
     /**
      * Run the change detection cycle. Normally, as soon as a hook is called in a class, the cycle is started. But you can start it manually
      * The method calls the `onChanges` method on events and synchronizes all map data with the client.
@@ -118,71 +61,13 @@ export declare class RpgPlayer extends RpgPlayer_base {
     databaseById(id: string): any;
     private _eventChanges;
     attachShape(id: string, options: ZoneOptions): void;
-    /**
-     * Show a temporary component animation on this player
-     *
-     * This method broadcasts a component animation to all clients, allowing
-     * temporary visual effects like hit indicators, spell effects, or status animations
-     * to be displayed on the player.
-     *
-     * @param id - The ID of the component animation to display
-     * @param params - Parameters to pass to the component animation
-     *
-     * @example
-     * ```ts
-     * // Show a hit animation with damage text
-     * player.showComponentAnimation("hit", {
-     *   text: "150",
-     *   color: "red"
-     * });
-     *
-     * // Show a heal animation
-     * player.showComponentAnimation("heal", {
-     *   amount: 50
-     * });
-     * ```
-     */
-    showComponentAnimation(id: string, params: any): void;
-    /**
-     * Display a spritesheet animation on the player
-     *
-     * This method displays a temporary visual animation using a spritesheet.
-     * The animation can either be displayed as an overlay on the player or replace
-     * the player's current graphic temporarily. This is useful for spell effects,
-     * transformations, or other visual feedback that uses predefined spritesheets.
-     *
-     * @param graphic - The ID of the spritesheet to use for the animation
-     * @param animationName - The name of the animation within the spritesheet (default: 'default')
-     * @param replaceGraphic - Whether to replace the player's sprite with the animation (default: false)
-     *
-     * @example
-     * ```ts
-     * // Show explosion animation as overlay on player
-     * player.showAnimation("explosion");
-     *
-     * // Show specific spell effect animation
-     * player.showAnimation("spell-effects", "fireball");
-     *
-     * // Transform player graphic temporarily with animation
-     * player.showAnimation("transformation", "werewolf", true);
-     *
-     * // Show healing effect on player
-     * player.showAnimation("healing-effects", "holy-light");
-     * ```
-     */
-    showAnimation(graphic: string, animationName?: string, replaceGraphic?: boolean): void;
+    broadcastEffect(id: string, params: any): void;
     showHit(text: string): void;
 }
 export declare class RpgEvent extends RpgPlayer {
     execMethod(methodName: string, methodData?: any[], instance?: this): Promise<any>;
     remove(): void;
 }
-/**
- * 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 interface RpgPlayer extends RpgCommonPlayer, IComponentManager, IGuiManager, IMoveManager, IGoldManager, IWithVariableManager, IWithParameterManager, IWithSkillManager {
 }
 export {};

package/dist/Player/SkillManager.d.ts

@@ -1,31 +1,23 @@
-import { PlayerCtor } from '@rpgjs/common';
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { RpgPlayer } from './Player';
 /**
- * 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 defining dependencies from other mixins that SkillManager needs
  */
-export declare function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+interface SkillManagerDependencies {
+    sp: number;
+    skills(): any[];
+    hasEffect(effect: string): boolean;
+    databaseById(id: string): any;
+    applyStates(player: RpgPlayer, skill: any): void;
+}
 /**
- * Type helper to extract the interface from the WithSkillManager mixin
- * This provides the type without duplicating method signatures
+ * Interface defining what SkillManager adds to a class
  */
-export type ISkillManager = InstanceType<ReturnType<typeof WithSkillManager>>;
+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 {};

package/dist/Player/StateManager.d.ts

@@ -1,32 +1,39 @@
-import { PlayerCtor } from '@rpgjs/common';
+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;
+}
 /**
- * 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.
- *
- * @param Base - The base class to extend with state management
- * @returns Extended class with state management methods
- *
- * @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));
- * ```
+ * Interface defining what MoveManager adds to a class
  */
-export declare function WithStateManager<TBase extends PlayerCtor>(Base: TBase): TBase;
+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;
+};
 /**
- * Type helper to extract the interface from the WithStateManager mixin
- * This provides the type without duplicating method signatures
+ * Move Manager mixin
+ *
+ * Adds methods to manage player movement
+ *
+ * @param Base - The base class to extend
+ * @returns A new class with move management capabilities
  */
-export type IStateManager = InstanceType<ReturnType<typeof WithStateManager>>;
+export declare function WithStateManager<TBase extends Constructor<RpgCommonPlayer & StateManagerDependencies>>(Base: TBase): Constructor<IStateManager> & TBase;
+export {};