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

package/src/Player/ParameterManager.ts

@@ -1,20 +1,6 @@
-import { Constructor, isString, RpgCommonPlayer } from "@rpgjs/common";
+import { isString, PlayerCtor } from "@rpgjs/common";
 import { MAXHP, MAXSP } from "../presets";
 
-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 } }
-}
-
-interface PlayerWithMixins extends RpgCommonPlayer {
-    databaseById?(id: string): any;  
-}
 
 /**
  * Mixin that adds parameter management functionality to a player class.
@@ -39,18 +25,40 @@ interface PlayerWithMixins extends RpgCommonPlayer {
  * }
  * ```
  */
-export function WithParameterManager<TBase extends Constructor<RpgCommonPlayer>>(
-  Base: TBase
-): TBase & Constructor<IWithParameterManager> {
-  return class extends Base implements IWithParameterManager {
-    private _paramsModifier: {
+/**
+ * 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 function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
+  return class extends Base {
+    _paramsModifier: {
         [key: string]: {
             value?: number,
             rate?: number
         }
     } = {}
 
-    private _parameters: Map<string, {
+    _parameters: Map<string, {
         start: number,
         end: number
     }> = new Map()
@@ -127,11 +135,11 @@ export function WithParameterManager<TBase extends Constructor<RpgCommonPlayer>>
             this['execMethod']('onDead') 
             val = 0
         }
-        this._hp.set(val)
+        (this as any)._hp.set(val)
     }
 
     get hp(): number {
-        return this._hp()
+        return (this as any)._hp()
     }
 
     /** 
@@ -497,5 +505,7 @@ export function WithParameterManager<TBase extends Constructor<RpgCommonPlayer>>
     allRecovery(): void {
         this.recovery({ hp: 1, sp: 1 })
     }
-  }
-}
+  } as unknown as TBase;
+}
+
+export type IParameterManager = InstanceType<ReturnType<typeof WithParameterManager>>;

package/src/Player/Player.ts

@@ -5,33 +5,42 @@ import {
   RpgCommonPlayer,
   ShowAnimationParams,
   Constructor,
-  ZoneOptions,
 } from "@rpgjs/common";
-import { WithComponentManager, IComponentManager } from "./ComponentManager";
+import { IComponentManager, WithComponentManager } from "./ComponentManager";
 import { RpgMap } from "../rooms/map";
 import { Context, inject } from "@signe/di";
 import { IGuiManager, WithGuiManager } from "./GuiManager";
 import { MockConnection } from "@signe/room";
 import { IMoveManager, WithMoveManager } from "./MoveManager";
 import { IGoldManager, WithGoldManager } from "./GoldManager";
-import { IWithVariableManager, WithVariableManager } from "./VariableManager";
+import { WithVariableManager, type IVariableManager } from "./VariableManager";
 import { sync } from "@signe/sync";
 import { signal } from "@signe/reactive";
 import {
-  IWithParameterManager,
+  IParameterManager,
   WithParameterManager,
 } from "./ParameterManager";
 import { WithItemFixture } from "./ItemFixture";
-import { WithStateManager } from "./StateManager";
-import { WithItemManager } from "./ItemManager";
+import { IItemManager, WithItemManager } from "./ItemManager";
 import { lastValueFrom } from "rxjs";
-import { WithBattleManager } from "./BattleManager";
-import { WithEffectManager } from "./EffectManager";
-import { WithSkillManager, IWithSkillManager } from "./SkillManager";
+import { IEffectManager, WithEffectManager } from "./EffectManager";
 import { AGI, AGI_CURVE, DEX, DEX_CURVE, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, STR, STR_CURVE } from "../presets";
-import { WithClassManager } from "./ClassManager";
-import { WithElementManager } from "./ElementManager";
+import { IElementManager, WithElementManager } from "./ElementManager";
+import { ISkillManager, WithSkillManager } from "./SkillManager";
+import { IBattleManager, WithBattleManager } from "./BattleManager";
+import { IClassManager, WithClassManager } from "./ClassManager";
+import { IStateManager, WithStateManager } from "./StateManager";
 
+// Local interface for ZoneOptions to avoid import issues
+interface ZoneOptions {
+  x?: number;
+  y?: number;
+  radius: number;
+  angle?: number;
+  direction?: any;
+  linkedTo?: string;
+  limitedByWalls?: boolean;
+}
 
 /**
  * Combines multiple RpgCommonPlayer mixins into one
@@ -46,27 +55,44 @@ function combinePlayerMixins<T extends Constructor<RpgCommonPlayer>>(
     mixins.reduce((ExtendedClass, mixin) => mixin(ExtendedClass), Base);
 }
 
-const PlayerMixins = combinePlayerMixins([
+// Start with basic mixins that work
+const BasicPlayerMixins = combinePlayerMixins([
   WithComponentManager,
   WithEffectManager,
   WithGuiManager,
   WithMoveManager,
   WithGoldManager,
-  WithVariableManager,
   WithParameterManager,
   WithItemFixture,
-  WithStateManager,
   WithItemManager,
-  WithSkillManager,
+  WithElementManager,
+  WithVariableManager,
+  WithStateManager,
   WithClassManager,
+  WithSkillManager,
   WithBattleManager,
-  WithElementManager,
 ]);
 
 /**
  * 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 class RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
+export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   map: RpgMap | null = null;
   context?: Context;
   conn: MockConnection | null = null;
@@ -75,20 +101,21 @@ export class RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
 
   constructor() {
     super();
-    this.expCurve = {
+    // Use type assertion to access mixin properties
+    (this as any).expCurve = {
         basis: 30,
         extra: 20,
         accelerationA: 30,
         accelerationB: 30
-    }
+    };
 
-    this.addParameter(MAXHP, MAXHP_CURVE)
-    this.addParameter(MAXSP, MAXSP_CURVE)
-    this.addParameter(STR, STR_CURVE)
-    this.addParameter(INT, INT_CURVE)
-    this.addParameter(DEX, DEX_CURVE)
-    this.addParameter(AGI, AGI_CURVE)
-    this.allRecovery()
+    (this as any).addParameter(MAXHP, MAXHP_CURVE);
+    (this as any).addParameter(MAXSP, MAXSP_CURVE);
+    (this as any).addParameter(STR, STR_CURVE);
+    (this as any).addParameter(INT, INT_CURVE);
+    (this as any).addParameter(DEX, DEX_CURVE);
+    (this as any).addParameter(AGI, AGI_CURVE);
+    (this as any).allRecovery();
   }
 
   async execMethod(method: string, methodData: any[] = [], target?: any) {
@@ -151,7 +178,50 @@ export class RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
     });
   }
 
-  showAnimation(params: ShowAnimationParams) {}
+  /**
+   * 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 = Infinity) {
+    const map = this.getCurrentMap();
+    if (!map) return;
+    if (nbTimes === Infinity) {
+      this.animationName.set(animationName);
+    }
+    else {
+      map.$broadcast({
+        type: "setAnimation",
+        value: {
+          animationName,
+          nbTimes,
+          object: this.id,
+        },
+      });
+    }
+  }
+
 
   /**
    * 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
@@ -228,11 +298,35 @@ export class RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
     );
   }
 
-  broadcastEffect(id: string, params: any) {
+  /**
+   * 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) {
     const map = this.getCurrentMap();
     if (!map) return;
     map.$broadcast({
-      type: "showEffect",
+      type: "showComponentAnimation",
       value: {
         id,
         params,
@@ -241,8 +335,46 @@ export class RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
     });
   }
 
+  /**
+   * 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 = 'default', replaceGraphic: boolean = false) {
+    if (replaceGraphic) {
+      this.setAnimation(animationName, 1);
+      return
+    }
+    this.showComponentAnimation("animation", {
+      graphic,
+      animationName,
+    });
+  }
+
   showHit(text: string) {
-    this.broadcastEffect("hit", {
+    this.showComponentAnimation("hit", {
       text,
       direction: this.direction(),
     });
@@ -268,12 +400,25 @@ export class RpgEvent extends RpgPlayer {
   }
 }
 
-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
+ {} 

package/src/Player/SkillManager.ts

@@ -3,6 +3,7 @@ import {
   isArray,
   isInstanceOf,
   isString,
+  PlayerCtor,
   RpgCommonPlayer,
 } from "@rpgjs/common";
 import { SkillLog } from "../logs";
@@ -20,22 +21,36 @@ interface SkillManagerDependencies {
   applyStates(player: RpgPlayer, skill: any): void;
 }
 
+
+
 /**
- * Interface defining what SkillManager adds to a class
+ * 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);
+ * ```
  */
-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 function WithSkillManager<TBase extends Constructor<RpgCommonPlayer & SkillManagerDependencies>>(
-  Base: TBase
-): Constructor<IWithSkillManager> & TBase {
-  return class extends Base implements IWithSkillManager {
-    private _getSkillIndex(skillClass: any | string) {
-      return this.skills().findIndex((skill) => {
+export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase) {
+  return class extends Base {
+    _getSkillIndex(skillClass: any | string) {
+      return (this as any).skills().findIndex((skill) => {
         if (isString(skill)) {
           return skill.id == skillClass;
         }
@@ -94,7 +109,7 @@ export function WithSkillManager<TBase extends Constructor<RpgCommonPlayer & Ski
       if (this.getSkill(skillId)) {
         throw SkillLog.alreadyLearned(skillId);
       }
-      const instance = this.databaseById(skillId);
+      const instance = (this as any).databaseById(skillId);
       this.skills().push(instance);
       this["execMethod"]("onLearn", [this], instance);
       return instance;
@@ -131,7 +146,7 @@ export function WithSkillManager<TBase extends Constructor<RpgCommonPlayer & Ski
      * @memberof SkillManager
      */
     forgetSkill(skillId: any | string) {
-      if (isString(skillId)) skillId = this.databaseById(skillId);
+      if (isString(skillId)) skillId = (this as any).databaseById(skillId);
       const index = this._getSkillIndex(skillId);
       if (index == -1) {
         throw SkillLog.notLearned(skillId);
@@ -219,16 +234,16 @@ export function WithSkillManager<TBase extends Constructor<RpgCommonPlayer & Ski
      */
     useSkill(skillId: any | string, otherPlayer?: RpgPlayer | RpgPlayer[]) {
       const skill = this.getSkill(skillId);
-      if (this.hasEffect(Effect.CAN_NOT_SKILL)) {
+      if ((this as any).hasEffect(Effect.CAN_NOT_SKILL)) {
         throw SkillLog.restriction(skillId);
       }
       if (!skill) {
         throw SkillLog.notLearned(skillId);
       }
-      if (skill.spCost > this.sp) {
-        throw SkillLog.notEnoughSp(skillId, skill.spCost, this.sp);
+      if (skill.spCost > (this as any).sp) {
+        throw SkillLog.notEnoughSp(skillId, skill.spCost, (this as any).sp);
       }
-      this.sp -= skill.spCost / (this.hasEffect(Effect.HALF_SP_COST) ? 2 : 1);
+      (this as any).sp -= skill.spCost / ((this as any).hasEffect(Effect.HALF_SP_COST) ? 2 : 1);
       const hitRate = skill.hitRate ?? 1;
       if (Math.random() > hitRate) {
         this["execMethod"]("onUseFailed", [this, otherPlayer], skill);
@@ -240,12 +255,18 @@ export function WithSkillManager<TBase extends Constructor<RpgCommonPlayer & Ski
           players = [otherPlayer];
         }
         for (let player of players) {
-          this.applyStates(player, skill);
-          player.applyDamage(this, skill);
+          (this as any).applyStates(player, skill);
+          (player as any).applyDamage(this, skill);
         }
       }
       this["execMethod"]("onUse", [this, otherPlayer], skill);
       return skill;
     }
-  };
+  } as unknown as TBase;
 }
+
+/**
+ * Type helper to extract the interface from the WithSkillManager mixin
+ * This provides the type without duplicating method signatures
+ */
+export type ISkillManager = InstanceType<ReturnType<typeof WithSkillManager>>;