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

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) {
@@ -268,12 +295,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>>;