@rpgjs/server 5.0.0-alpha.21 → 5.0.0-alpha.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-alpha.21",
+  "version": "5.0.0-alpha.23",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,18 +11,18 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.21",
-    "@rpgjs/physic": "5.0.0-alpha.21",
+    "@rpgjs/common": "5.0.0-alpha.23",
+    "@rpgjs/physic": "5.0.0-alpha.23",
     "@rpgjs/database": "^4.3.0",
-    "@signe/di": "^2.5.1",
-    "@signe/reactive": "^2.5.1",
-    "@signe/room": "^2.5.1",
-    "@signe/sync": "^2.5.1",
+    "@signe/di": "^2.5.2",
+    "@signe/reactive": "^2.5.2",
+    "@signe/room": "^2.5.2",
+    "@signe/sync": "^2.5.2",
     "rxjs": "^7.8.2",
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "vite": "^7.2.4",
+    "vite": "^7.2.6",
     "vite-plugin-dts": "^4.5.4"
   },
   "type": "module",

package/src/Player/BattleManager.ts

@@ -2,44 +2,21 @@ import { Constructor, PlayerCtor, RpgCommonPlayer } from "@rpgjs/common";
 import { RpgPlayer } from "./Player";
 import { ATK, PDEF, SDEF } from "../presets";
 import { Effect } from "./EffectManager";
+import type { IElementManager } from "./ElementManager";
+import type { IEffectManager } from "./EffectManager";
+import type { IParameterManager } from "./ParameterManager";
 
-interface PlayerWithMixins extends RpgCommonPlayer {
-  parameters: any[];
+/**
+ * Interface combining methods from other managers needed by BattleManager
+ * Reuses existing interfaces instead of duplicating method signatures
+ */
+interface PlayerWithMixins extends IElementManager, IEffectManager, Pick<IParameterManager, 'parameters' | 'hp'> {
   getFormulas(name: string): any;
-  hasEffect(effect: string): boolean;
-  coefficientElements(attackerPlayer: RpgPlayer): number;
-  hp: number;
-  getCurrentMap(): any;
+  getCurrentMap(): ReturnType<RpgPlayer['getCurrentMap']>;
 }
 
-/**
- * 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 function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
-  return class extends Base {
-    /**
+export interface IBattleManager {
+   /**
      * Apply damage. Player will lose HP. the `attackerPlayer` parameter is the other player, the one who attacks.
      *
      * If you don't set the skill parameter, it will be a physical attack.
@@ -71,6 +48,17 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
      * }
      * ```
      */
+  applyDamage(attackerPlayer: RpgPlayer, skill?: any): {
+    damage: number;
+    critical: boolean;
+    elementVulnerable: boolean;
+    guard: boolean;
+    superGuard: boolean;
+  };
+}
+
+export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IBattleManager {
+  return class extends Base {
     applyDamage(
       attackerPlayer: RpgPlayer,
       skill?: any
@@ -81,9 +69,10 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
       guard: boolean;
       superGuard: boolean;
     } {
+      const self = this as unknown as PlayerWithMixins;
       const getParam = (player: RpgPlayer) => {
         const params = {};
-        (this as any).parameters.forEach((val, key) => {
+        Object.keys(self.parameters).forEach((key) => {
           params[key] = (player as any).param[key];
         });
         return {
@@ -100,26 +89,25 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
       let superGuard = false;
       let elementVulnerable = false;
       const paramA = getParam(attackerPlayer);
-      const paramB = getParam(<any>this);
-      console.log(paramA, paramB)
+      const paramB = getParam(self as any);
       if (skill) {
-        fn = this.getFormulas("damageSkill");
+        fn = self.getFormulas("damageSkill");
         if (!fn) {
           throw new Error("Skill Formulas not exists");
         }
         damage = fn(paramA, paramB, skill);
       } else {
-        fn = this.getFormulas("damagePhysic");
+        fn = self.getFormulas("damagePhysic");
         if (!fn) {
           throw new Error("Physic Formulas not exists");
         }
         damage = fn(paramA, paramB);
-        const coef = (this as any).coefficientElements(attackerPlayer);
+        const coef = self.coefficientElements(attackerPlayer);
         if (coef >= 2) {
           elementVulnerable = true;
         }
         damage *= coef;
-        fn = this.getFormulas("damageCritical");
+        fn = self.getFormulas("damageCritical");
         if (fn) {
           let newDamage = fn(damage, paramA, paramB);
           if (damage != newDamage) {
@@ -128,8 +116,8 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
           damage = newDamage;
         }
       }
-      if ((this as any).hasEffect(Effect.GUARD)) {
-        fn = this.getFormulas("damageGuard");
+      if (self.hasEffect(Effect.GUARD)) {
+        fn = self.getFormulas("damageGuard");
         if (fn) {
           let newDamage = fn(damage, paramA, paramB);
           if (damage != newDamage) {
@@ -138,11 +126,11 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
           damage = newDamage;
         }
       }
-      if ((this as any).hasEffect(Effect.SUPER_GUARD)) {
+      if (self.hasEffect(Effect.SUPER_GUARD)) {
         damage /= 4;
         superGuard = true;
       }
-      (this as any).hp -= damage;
+      self.hp -= damage;
       return {
         damage,
         critical,
@@ -179,14 +167,9 @@ export function WithBattleManager<TBase extends PlayerCtor>(Base: TBase) {
      * ```
      */
     getFormulas(name: string) {
-      const map = (this as any).getCurrentMap(); 
-      return map.damageFormulas[name];
+      const self = this as unknown as PlayerWithMixins;
+      const map = self.getCurrentMap(); 
+      return map?.damageFormulas[name];
     }
-  } as unknown as 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>>;
+  } as unknown as any;
+}

package/src/Player/ClassManager.ts

@@ -36,38 +36,6 @@ interface PlayerWithMixins extends RpgCommonPlayer {
  */
 export function WithClassManager<TBase extends PlayerCtor>(Base: TBase) {
   return class extends Base {
-
-    /**
-     * Assign a class to the player
-     *
-     * Sets the player's class, which defines their combat abilities, stat growth,
-     * and available skills. The class system provides the foundation for character
-     * progression and specialization. When a class is set, it automatically triggers
-     * the class's onSet method for any additional initialization.
-     * 
-     * @param _class - The class constructor or class ID to assign to the player
-     * @returns The instantiated class object
-     * 
-     * @example
-     * ```ts
-     * import { Fighter } from 'my-database/classes/fighter'
-     *
-     * // Set class using constructor
-     * const fighterClass = player.setClass(Fighter);
-     * console.log('Class set:', fighterClass.name);
-     * 
-     * // Set class using string ID
-     * player.setClass('fighter');
-     * 
-     * // Class affects available skills and stats
-     * console.log('Available skills:', player.skills);
-     * console.log('Class bonuses applied to stats');
-     * 
-     * // Class determines level progression
-     * player.level = 5;
-     * // Skills may be automatically learned based on class definition
-     * ```
-     */
     setClass(_class: ClassClass | string) {
       if (isString(_class)) _class = (this as any).databaseById(_class);
       const classInstance = new (_class as ClassClass)();
@@ -75,42 +43,6 @@ export function WithClassManager<TBase extends PlayerCtor>(Base: TBase) {
       return classInstance;
     }
 
-    /**
-     * Allows to give a set of already defined properties to the player (default equipment, or a list of skills to learn according to the level)
-     *
-     * Sets up the player as a specific actor archetype, which includes predefined
-     * characteristics like starting equipment, parameters, level ranges, and associated class.
-     * This is typically used for creating pre-configured character templates or NPCs
-     * with specific roles and equipment loadouts.
-     * 
-     * @param actorClass - The actor constructor or actor ID to assign to the player
-     * @returns The instantiated actor object
-     * 
-     * @example
-     * ```ts
-     * import { Hero } from 'my-database/classes/hero'
-     *
-     * // Set up player as Hero actor
-     * const heroActor = player.setActor(Hero);
-     * console.log('Actor configured:', heroActor.name);
-     * 
-     * // Actor automatically sets up:
-     * // - Starting equipment (sword, armor, etc.)
-     * console.log('Starting equipment:', player.equipments());
-     * 
-     * // - Parameter ranges and growth
-     * console.log('Level range:', player.initialLevel, '-', player.finalLevel);
-     * 
-     * // - Associated class
-     * console.log('Assigned class:', player.class);
-     * 
-     * // - Experience curve
-     * console.log('EXP curve:', player.expCurve);
-     * 
-     * // Actor setup is comprehensive
-     * player.setActor('hero'); // Can also use string ID
-     * ```
-     */
     setActor(actorClass: ActorClass | string) {
       if (isString(actorClass)) actorClass = (this as any).databaseById(actorClass);
       const actor = new (actorClass as ActorClass)();
@@ -132,7 +64,25 @@ export function WithClassManager<TBase extends PlayerCtor>(Base: TBase) {
 }
 
 /**
- * Type helper to extract the interface from the WithClassManager mixin
- * This provides the type without duplicating method signatures
+ * Interface for Class Manager functionality
+ * 
+ * Provides class and actor management capabilities including character class assignment
+ * and actor setup. This interface defines the public API of the ClassManager mixin.
  */
-export type IClassManager = InstanceType<ReturnType<typeof WithClassManager>>;
+export interface IClassManager {
+  /**
+   * Assign a class to the player
+   * 
+   * @param _class - The class constructor or class ID to assign to the player
+   * @returns The instantiated class object
+   */
+  setClass(_class: ClassClass | string): any;
+
+  /**
+   * Set up the player as a specific actor archetype
+   * 
+   * @param actorClass - The actor constructor or actor ID to assign to the player
+   * @returns The instantiated actor object
+   */
+  setActor(actorClass: ActorClass | string): any;
+}

package/src/Player/EffectManager.ts

@@ -42,70 +42,10 @@ export enum Effect {
  */
 export function WithEffectManager<TBase extends PlayerCtor>(Base: TBase) {
   return class extends Base {
-    /**
-     * Check if the player has a specific effect
-     * 
-     * Determines whether the player currently has the specified effect active.
-     * This includes effects from states, equipment, and temporary conditions.
-     * The effect system provides a flexible way to apply various gameplay
-     * restrictions and enhancements to the player.
-     * 
-     * @param effect - The effect identifier to check for
-     * @returns true if the player has the effect, false otherwise
-     * 
-     * @example
-     * ```ts
-     * import { Effect } from '@rpgjs/database'
-     *
-     * // Check for skill restriction
-     * const cannotUseSkills = player.hasEffect(Effect.CAN_NOT_SKILL);
-     * if (cannotUseSkills) {
-     *   console.log('Player cannot use skills right now');
-     * }
-     * 
-     * // Check for guard effect
-     * const isGuarding = player.hasEffect(Effect.GUARD);
-     * if (isGuarding) {
-     *   console.log('Player is in guard stance');
-     * }
-     * 
-     * // Check for cost reduction
-     * const halfCost = player.hasEffect(Effect.HALF_SP_COST);
-     * const actualCost = skillCost / (halfCost ? 2 : 1);
-     * ```
-     */
     hasEffect(effect: string): boolean {
       return this.effects.includes(effect);
     }
 
-    /**
-     * Retrieves a array of effects assigned to the player, state effects and effects of weapons and armors equipped with the player's own weapons.
-     *
-     * Gets all currently active effects on the player from multiple sources:
-     * - Direct effects assigned to the player
-     * - Effects from active states (buffs/debuffs)
-     * - Effects from equipped weapons and armor
-     * The returned array contains unique effects without duplicates.
-     * 
-     * @returns Array of all active effects on the player
-     * 
-     * @example
-     * ```ts
-     * // Get all active effects
-     * console.log(player.effects); // ['GUARD', 'HALF_SP_COST', ...]
-     * 
-     * // Check multiple effects
-     * const effects = player.effects;
-     * const hasRestrictions = effects.some(effect => 
-     *   effect.startsWith('CAN_NOT_')
-     * );
-     * 
-     * // Count beneficial effects
-     * const beneficialEffects = effects.filter(effect => 
-     *   ['GUARD', 'SUPER_GUARD', 'HALF_SP_COST'].includes(effect)
-     * );
-     * ```
-     */
     get effects(): any[] {
       const getEffects = (prop) => {
         return arrayFlat(this[prop]().map((el) => el.effects || []));
@@ -117,39 +57,6 @@ export function WithEffectManager<TBase extends PlayerCtor>(Base: TBase) {
       ]);
     }
 
-    /**
-     * Assigns effects to the player. If you give a array, it does not change the effects of the player's states and armor/weapons equipped.
-     *
-     * Sets the direct effects on the player. This only affects the player's own effects
-     * and does not modify effects from states or equipment. The total effects will be
-     * the combination of these direct effects plus any effects from states and equipment.
-     * 
-     * @param val - Array of effect identifiers to assign to the player
-     * 
-     * @example
-     * ```ts
-     * import { Effect } from '@rpgjs/database'
-     *
-     * // Set direct player effects
-     * player.effects = [Effect.CAN_NOT_SKILL];
-     * 
-     * // Add multiple effects
-     * player.effects = [
-     *   Effect.GUARD,
-     *   Effect.HALF_SP_COST,
-     *   Effect.CAN_NOT_ITEM
-     * ];
-     * 
-     * // Clear direct effects (equipment/state effects remain)
-     * player.effects = [];
-     * 
-     * // Temporary effect application
-     * const originalEffects = player.effects;
-     * player.effects = [...originalEffects, Effect.SUPER_GUARD];
-     * // Later restore
-     * player.effects = originalEffects;
-     * ```
-     */
     set effects(val) {
       this._effects.set(val);
     }
@@ -157,7 +64,54 @@ export function WithEffectManager<TBase extends PlayerCtor>(Base: TBase) {
 }
 
 /**
- * Type helper to extract the interface from the WithEffectManager mixin
- * This provides the type without duplicating method signatures
+ * Interface for Effect Manager functionality
+ * 
+ * Provides effect management capabilities including restrictions, buffs, and debuffs.
+ * This interface defines the public API of the EffectManager mixin.
  */
-export type IEffectManager = InstanceType<ReturnType<typeof WithEffectManager>>;
+export interface IEffectManager {
+  /**
+   * Gets all currently active effects on the player from multiple sources:
+   * - Direct effects assigned to the player
+   * - Effects from active states (buffs/debuffs)
+   * - Effects from equipped weapons and armor
+   * The returned array contains unique effects without duplicates.
+   * 
+   * @returns Array of all active effects on the player
+   */
+  effects: any[];
+
+  /**
+   * Check if the player has a specific effect
+   * 
+   * Determines whether the player currently has the specified effect active.
+   * This includes effects from states, equipment, and temporary conditions.
+   * The effect system provides a flexible way to apply various gameplay
+   * restrictions and enhancements to the player.
+   * 
+   * @param effect - The effect identifier to check for
+   * @returns true if the player has the effect, false otherwise
+   * 
+   * @example
+   * ```ts
+   * import { Effect } from '@rpgjs/database'
+   *
+   * // Check for skill restriction
+   * const cannotUseSkills = player.hasEffect(Effect.CAN_NOT_SKILL);
+   * if (cannotUseSkills) {
+   *   console.log('Player cannot use skills right now');
+   * }
+   * 
+   * // Check for guard effect
+   * const isGuarding = player.hasEffect(Effect.GUARD);
+   * if (isGuarding) {
+   *   console.log('Player is in guard stance');
+   * }
+   * 
+   * // Check for cost reduction
+   * const halfCost = player.hasEffect(Effect.HALF_SP_COST);
+   * const actualCost = skillCost / (halfCost ? 2 : 1);
+   * ```
+   */
+  hasEffect(effect: string): boolean;
+}