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

package/src/Player/EffectManager.ts

@@ -2,10 +2,13 @@ import {
   arrayFlat,
   arrayUniq,
   Constructor,
-  PlayerCtor,
   RpgCommonPlayer,
 } from "@rpgjs/common";
 
+export interface IWithEffectManager {
+  effects: any[];
+}
+
 export enum Effect {
   CAN_NOT_SKILL = 'CAN_NOT_SKILL',
   CAN_NOT_ITEM = 'CAN_NOT_ITEM',
@@ -16,64 +19,23 @@ export enum Effect {
   SUPER_GUARD = 'SUPER_GUARD'
 }
 
-/**
- * Effect Manager Mixin
- * 
- * Provides effect management capabilities to any class. This mixin handles
- * player effects including restrictions, buffs, and debuffs. Effects can come
- * from various sources like states, equipment, and temporary conditions.
- * 
- * @param Base - The base class to extend with effect management
- * @returns Extended class with effect management methods
- * 
- * @example
- * ```ts
- * class MyPlayer extends WithEffectManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     // Effect system is automatically initialized
- *   }
- * }
- * 
- * const player = new MyPlayer();
- * player.effects = [Effect.GUARD];
- * console.log(player.hasEffect(Effect.GUARD)); // true
- * ```
- */
-export function WithEffectManager<TBase extends PlayerCtor>(Base: TBase) {
-  return class extends Base {
+export function WithEffectManager<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+) {
+  return class extends Base implements IWithEffectManager {
     /**
-     * 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);
+     * const bool = player.hasEffect(Effect.CAN_NOT_SKILL)
      * ```
-     */
+     *
+     * @title Has Effect
+     * @method player.hasEffect(effect)
+     * @param {string} effect
+     * @returns {boolean}
+     * @memberof EffectManager
+     * */
     hasEffect(effect: string): boolean {
       return this.effects.includes(effect);
     }
@@ -81,31 +43,13 @@ export function WithEffectManager<TBase extends PlayerCtor>(Base: TBase) {
     /**
      * 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)
-     * );
+     * console.log(player.effects)
      * ```
-     */
+     * @title Get Effects
+     * @prop {Array<Effect>} player.effects
+     * @memberof EffectManager
+     * */
     get effects(): any[] {
       const getEffects = (prop) => {
         return arrayFlat(this[prop]().map((el) => el.effects || []));
@@ -120,44 +64,17 @@ 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;
+     * player.effects = [Effect.CAN_NOT_SKILL]
      * ```
-     */
+     * @title Set Effects
+     * @prop {Array<Effect>} player.effects
+     * @memberof EffectManager
+     * */
     set effects(val) {
       this._effects.set(val);
     }
-  } as unknown as TBase;
+  };
 }
-
-/**
- * Type helper to extract the interface from the WithEffectManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IEffectManager = InstanceType<ReturnType<typeof WithEffectManager>>;

package/src/Player/ElementManager.ts

@@ -1,47 +1,17 @@
-import { arrayUniq, PlayerCtor, RpgCommonPlayer } from "@rpgjs/common";
+import { arrayUniq, RpgCommonPlayer } from "@rpgjs/common";
 import { Constructor } from "@rpgjs/common";
 import { RpgPlayer } from "./Player";
 
-/**
- * Element Manager Mixin
- * 
- * Provides elemental management capabilities to any class. This mixin handles
- * elemental resistances, vulnerabilities, and attack elements. It manages both
- * defensive capabilities (elementsDefense) and offensive elements from equipment,
- * as well as player-specific elemental efficiency modifiers.
- * 
- * @param Base - The base class to extend with element management
- * @returns Extended class with element management methods
- * 
- * @example
- * ```ts
- * class MyPlayer extends WithElementManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     this.elementsEfficiency = [{ rate: 0.5, element: 'fire' }];
- *   }
- * }
- * 
- * const player = new MyPlayer();
- * const fireResistance = player.elementsDefense.find(e => e.element === 'fire');
- * ```
- */
-export function WithElementManager<TBase extends PlayerCtor>(Base: TBase) {
-  return class extends Base {
+export function WithElementManager<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+) {
+  return class extends Base implements IWithElementManager {
     _elementsEfficiency: { rate: number; element: any }[] = [];
 
     /**
      * Recovers the player's elements defense on inventory.  This list is generated from the `elementsDefense` property defined on the weapons or armors equipped.
      * If several items have the same element, only the highest rate will be taken into account.
      *
-     * Gets the defensive capabilities against various elements from equipped items.
-     * The system automatically consolidates multiple defensive items, keeping only
-     * the highest protection rate for each element type. This provides a comprehensive
-     * view of the player's elemental resistances from all equipped gear.
-     * 
-     * @returns Array of element defense objects with rate and element properties
-     * 
-     * @example
      * ```ts
      * import { Armor } from '@rpgjs/server'
      *
@@ -67,29 +37,19 @@ export function WithElementManager<TBase extends PlayerCtor>(Base: TBase) {
      * player.equip(FireShield)
      *
      * console.log(player.elementsDefense) // [{ rate: 1, element: 'fire' }]
-     * 
-     * // Check specific element defense
-     * const fireDefense = player.elementsDefense.find(def => def.element === 'fire');
-     * if (fireDefense) {
-     *   console.log(`Fire defense rate: ${fireDefense.rate}`);
-     * }
      * ```
-     */
+     * @title Get Elements Defense
+     * @prop {Array<{ rate: number, element: Element}>} player.elementsDefense
+     * @readonly
+     * @memberof ElementManager
+     * */
     get elementsDefense(): { rate: number; element: any }[] {
-      return (this as any).getFeature("elementsDefense", "element");
+      return this.getFeature("elementsDefense", "element");
     }
 
     /**
      * Set or retrieves all the elements where the player is vulnerable or not.
      *
-     * Manages the player's elemental efficiency modifiers, which determine how
-     * effective different elements are against this player. Values greater than 1
-     * indicate vulnerability, while values less than 1 indicate resistance.
-     * This combines both class-based efficiency and player-specific modifiers.
-     * 
-     * @returns Array of element efficiency objects with rate and element properties
-     * 
-     * @example
      * ```ts
      * import { Class } from '@rpgjs/server'
      *
@@ -111,18 +71,13 @@ export function WithElementManager<TBase extends PlayerCtor>(Base: TBase) {
      * player.elementsEfficiency = [{ rate: 2, element: Elements.Ice }]
      *
      * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }, { rate: 2, element: 'ice' }]
-     * 
-     * // Check for vulnerabilities
-     * const vulnerabilities = player.elementsEfficiency.filter(eff => eff.rate > 1);
-     * console.log('Vulnerable to:', vulnerabilities.map(v => v.element));
-     * 
-     * // Check for resistances
-     * const resistances = player.elementsEfficiency.filter(eff => eff.rate < 1);
-     * console.log('Resistant to:', resistances.map(r => r.element));
      * ```
-     */
+     * @title Set/Get Elements Efficiency
+     * @prop {Array<{ rate: number, element: Element}>} player.elementsEfficiency
+     * @memberof ElementManager
+     * */
     get elementsEfficiency(): { rate: number; element: any }[] {
-      if (this._class()) {
+      if (this._class) {
         return <any>[
           ...this._elementsEfficiency,
           ...(this._class()?.elementsEfficiency || []),
@@ -138,30 +93,14 @@ export function WithElementManager<TBase extends PlayerCtor>(Base: TBase) {
     /**
      * Retrieves a array of elements assigned to the player and the elements of the weapons / armor equipped
      *
-     * Gets all offensive elements available to the player from equipped weapons and armor.
-     * This determines what elemental damage types the player can deal in combat.
-     * The system automatically combines elements from all equipped items and removes duplicates.
-     * 
-     * @returns Array of element objects with rate and element properties for offensive capabilities
-     * 
-     * @example
      * ```ts
-     * // Get all offensive elements
-     * console.log(player.elements); // [{ rate: 1.5, element: 'fire' }, { rate: 1.2, element: 'ice' }]
-     * 
-     * // Check if player can deal fire damage
-     * const hasFireElement = player.elements.some(el => el.element === 'fire');
-     * if (hasFireElement) {
-     *   console.log('Player can deal fire damage');
-     * }
-     * 
-     * // Get strongest element
-     * const strongestElement = player.elements.reduce((max, current) => 
-     *   current.rate > max.rate ? current : max
-     * );
-     * console.log(`Strongest element: ${strongestElement.element} (${strongestElement.rate})`);
+     * console.log(player.elements)
      * ```
-     */
+     * @title Get Elements
+     * @prop {Array<Element>} player.elements
+     * @readonly
+     * @memberof ElementManager
+     * */
     get elements(): {
       rate: number;
       element: string;
@@ -175,42 +114,8 @@ export function WithElementManager<TBase extends PlayerCtor>(Base: TBase) {
       return arrayUniq(elements);
     }
 
-    /**
-     * Calculate elemental damage coefficient against another player
-     * 
-     * Determines the damage multiplier when this player attacks another player,
-     * taking into account the attacker's offensive elements, the defender's
-     * elemental efficiency, and elemental defense from equipment. This is used
-     * in the battle system to calculate elemental damage modifiers.
-     * 
-     * @param otherPlayer - The target player to calculate coefficient against
-     * @returns Numerical coefficient to multiply base damage by
-     * 
-     * @example
-     * ```ts
-     * // Calculate elemental damage coefficient
-     * const firePlayer = new MyPlayer();
-     * const icePlayer = new MyPlayer();
-     * 
-     * // Fire player attacks ice player (assuming ice is weak to fire)
-     * const coefficient = icePlayer.coefficientElements(firePlayer);
-     * console.log(`Damage multiplier: ${coefficient}`); // e.g., 2.0 for double damage
-     * 
-     * // Use in damage calculation
-     * const baseDamage = 100;
-     * const finalDamage = baseDamage * coefficient;
-     * console.log(`Final damage: ${finalDamage}`);
-     * 
-     * // Check for elemental advantage
-     * if (coefficient > 1) {
-     *   console.log('Attacker has elemental advantage!');
-     * } else if (coefficient < 1) {
-     *   console.log('Defender resists this element');
-     * }
-     * ```
-     */
     coefficientElements(otherPlayer: RpgPlayer): number {
-      const atkPlayerElements: any = (otherPlayer as any).elements;
+      const atkPlayerElements: any = otherPlayer.elements;
       const playerElements: any = this.elementsEfficiency;
       let coefficient = 1;
 
@@ -222,7 +127,7 @@ export function WithElementManager<TBase extends PlayerCtor>(Base: TBase) {
           (el) => el.element == atkElement.element
         );
         if (!elementPlayer) continue;
-        const fn = (this as any).getFormulas("coefficientElements");
+        const fn = this.getFormulas("coefficientElements");
         if (!fn) {
           return coefficient;
         }
@@ -234,11 +139,5 @@ export function WithElementManager<TBase extends PlayerCtor>(Base: TBase) {
       }
       return coefficient;
     }
-  } as unknown as TBase;
+  };
 }
-
-/**
- * Type helper to extract the interface from the WithElementManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IElementManager = InstanceType<ReturnType<typeof WithElementManager>>;

package/src/Player/GoldManager.ts

@@ -1,41 +1,44 @@
-import { PlayerCtor } from "@rpgjs/common";
+import { type Constructor } from "@rpgjs/common";
+import { RpgCommonPlayer } from "@rpgjs/common";
 
-export interface GoldManager {
-  /**
-   * You can change the game money
-   *
-   * ```ts
-   * player.gold += 100
-   * ```
-   *
-   * @title Change Gold
-   * @prop {number} player.gold
-   * @default 0
-   * @memberof GoldManager
-   * */
-  gold: number;
+/**
+ * Interface defining what MoveManager adds to a class
+ */
+export interface IGoldManager {
+  
 }
 
-export function WithGoldManager<TBase extends PlayerCtor>(
-  Base: TBase
-): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> &
-  GoldManager {
-  return class extends Base {
+/**
+ * Move Manager mixin
+ * 
+ * Adds methods to manage player gold
+ * 
+ * @param Base - The base class to extend
+ * @returns A new class with gold management capabilities
+ */
+export function WithGoldManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase) {
+  return class extends Base implements IGoldManager {
+    /** 
+     * You can change the game money
+     * 
+     * ```ts
+     * player.gold += 100
+     * ```
+     * 
+     * @title Change Gold
+     * @prop {number} player.gold
+     * @default 0
+     * @memberof GoldManager
+     * */
     set gold(val: number) {
-      if (val < 0) {
-        val = 0;
-      }
-      this._gold.set(val);
+        if (val < 0) {
+            val = 0
+        }
+        this._gold.set(val)
     }
 
     get gold(): number {
-      return this._gold();
+        return this._gold()
     }
-  } as unknown as any;
+  };
 }
-
-/**
- * Type helper to extract the interface from the WithGoldManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IGoldManager = InstanceType<ReturnType<typeof WithGoldManager>>;