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

package/src/Player/ParameterManager.ts

@@ -1,6 +1,20 @@
-import { isString, PlayerCtor } from "@rpgjs/common";
+import { Constructor, isString, RpgCommonPlayer } 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.
@@ -25,40 +39,18 @@ import { MAXHP, MAXSP } from "../presets";
  * }
  * ```
  */
-/**
- * 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: {
+export function WithParameterManager<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+): TBase & Constructor<IWithParameterManager> {
+  return class extends Base implements IWithParameterManager {
+    private _paramsModifier: {
         [key: string]: {
             value?: number,
             rate?: number
         }
     } = {}
 
-    _parameters: Map<string, {
+    private _parameters: Map<string, {
         start: number,
         end: number
     }> = new Map()
@@ -135,11 +127,11 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
             this['execMethod']('onDead') 
             val = 0
         }
-        (this as any)._hp.set(val)
+        this._hp.set(val)
     }
 
     get hp(): number {
-        return (this as any)._hp()
+        return this._hp()
     }
 
     /** 
@@ -505,7 +497,5 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
     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,42 +5,33 @@ import {
   RpgCommonPlayer,
   ShowAnimationParams,
   Constructor,
+  ZoneOptions,
 } from "@rpgjs/common";
-import { IComponentManager, WithComponentManager } from "./ComponentManager";
+import { WithComponentManager, IComponentManager } 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 { WithVariableManager, type IVariableManager } from "./VariableManager";
+import { IWithVariableManager, WithVariableManager } from "./VariableManager";
 import { sync } from "@signe/sync";
 import { signal } from "@signe/reactive";
 import {
-  IParameterManager,
+  IWithParameterManager,
   WithParameterManager,
 } from "./ParameterManager";
 import { WithItemFixture } from "./ItemFixture";
-import { IItemManager, WithItemManager } from "./ItemManager";
+import { WithStateManager } from "./StateManager";
+import { WithItemManager } from "./ItemManager";
 import { lastValueFrom } from "rxjs";
-import { IEffectManager, WithEffectManager } from "./EffectManager";
+import { WithBattleManager } from "./BattleManager";
+import { WithEffectManager } from "./EffectManager";
+import { WithSkillManager, IWithSkillManager } from "./SkillManager";
 import { AGI, AGI_CURVE, DEX, DEX_CURVE, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, STR, STR_CURVE } from "../presets";
-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";
+import { WithClassManager } from "./ClassManager";
+import { WithElementManager } from "./ElementManager";
 
-// 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
@@ -55,44 +46,27 @@ function combinePlayerMixins<T extends Constructor<RpgCommonPlayer>>(
     mixins.reduce((ExtendedClass, mixin) => mixin(ExtendedClass), Base);
 }
 
-// Start with basic mixins that work
-const BasicPlayerMixins = combinePlayerMixins([
+const PlayerMixins = combinePlayerMixins([
   WithComponentManager,
   WithEffectManager,
   WithGuiManager,
   WithMoveManager,
   WithGoldManager,
+  WithVariableManager,
   WithParameterManager,
   WithItemFixture,
-  WithItemManager,
-  WithElementManager,
-  WithVariableManager,
   WithStateManager,
-  WithClassManager,
+  WithItemManager,
   WithSkillManager,
+  WithClassManager,
   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 BasicPlayerMixins(RpgCommonPlayer) {
+export class RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
   map: RpgMap | null = null;
   context?: Context;
   conn: MockConnection | null = null;
@@ -101,21 +75,20 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
 
   constructor() {
     super();
-    // Use type assertion to access mixin properties
-    (this as any).expCurve = {
+    this.expCurve = {
         basis: 30,
         extra: 20,
         accelerationA: 30,
         accelerationB: 30
-    };
+    }
 
-    (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();
+    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()
   }
 
   async execMethod(method: string, methodData: any[] = [], target?: any) {
@@ -178,50 +151,7 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     });
   }
 
-  /**
-   * 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,
-        },
-      });
-    }
-  }
-
+  showAnimation(params: ShowAnimationParams) {}
 
   /**
    * 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
@@ -298,35 +228,11 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     );
   }
 
-  /**
-   * 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) {
+  broadcastEffect(id: string, params: any) {
     const map = this.getCurrentMap();
     if (!map) return;
     map.$broadcast({
-      type: "showComponentAnimation",
+      type: "showEffect",
       value: {
         id,
         params,
@@ -335,46 +241,8 @@ export class RpgPlayer extends BasicPlayerMixins(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.showComponentAnimation("hit", {
+    this.broadcastEffect("hit", {
       text,
       direction: this.direction(),
     });
@@ -400,25 +268,12 @@ export class RpgEvent extends RpgPlayer {
   }
 }
 
-
-/**
- * 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 {}

package/src/Player/SkillManager.ts

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