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

package/dist/Gui/DialogGui.d.ts

@@ -17,6 +17,10 @@ export interface DialogOptions {
     tranparent?: boolean;
     typewriterEffect?: boolean;
     talkWith?: RpgPlayer;
+    face?: {
+        id: string;
+        expression: string;
+    };
 }
 export declare class DialogGui extends Gui {
     constructor(player: RpgPlayer);

package/dist/Gui/index.d.ts

@@ -4,3 +4,4 @@ import { MenuGui } from './MenuGui';
 import { ShopGui } from './ShopGui';
 import { NotificationGui } from './NotificationGui';
 export { Gui, DialogGui, MenuGui, ShopGui, NotificationGui };
+export { DialogPosition } from './DialogGui';

package/dist/Player/ParameterManager.d.ts

@@ -1,50 +1,371 @@
 import { PlayerCtor } from '@rpgjs/common';
 /**
- * Mixin that adds parameter management functionality to a player class.
+ * Interface for Parameter Manager functionality
  *
- * This mixin provides comprehensive parameter management including:
- * - Health Points (HP) and Skill Points (SP) management
- * - Experience and level progression system
- * - Custom parameter creation and modification
- * - Parameter modifiers for temporary stat changes
- *
- * @template TBase - The base class constructor type
- * @param Base - The base class to extend
- * @returns A new class that extends the base with parameter management capabilities
- *
- * @example
- * ```ts
- * class MyPlayer extends WithParameterManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     this.addParameter('strength', { start: 10, end: 100 });
- *   }
- * }
- * ```
+ * Provides comprehensive parameter management including health points (HP), skill points (SP),
+ * experience and level progression, custom parameters, and parameter modifiers.
  */
+export interface IParameterManager {
+    /**
+     * ```ts
+     * player.initialLevel = 5
+     * ```
+     *
+     * @title Set initial level
+     * @prop {number} player.initialLevel
+     * @default 1
+     * @memberof ParameterManager
+     * */
+    initialLevel: number;
+    /**
+     * ```ts
+     * player.finalLevel = 50
+     * ```
+     *
+     * @title Set final level
+     * @prop {number} player.finalLevel
+     * @default 99
+     * @memberof ParameterManager
+     * */
+    finalLevel: number;
+    /**
+     * With Object-based syntax, you can use following options:
+     * - `basis: number`
+     * - `extra: number`
+     * - `accelerationA: number`
+     * - `accelerationB: number`
+     * @title Change Experience Curve
+     * @prop {object} player.expCurve
+     * @default
+     *  ```ts
+     * {
+     *      basis: 30,
+     *      extra: 20,
+     *      accelerationA: 30,
+     *      accelerationB: 30
+     * }
+     * ```
+     * @memberof ParameterManager
+     * */
+    expCurve: {
+        basis: number;
+        extra: number;
+        accelerationA: number;
+        accelerationB: number;
+    };
+    /**
+     * Changes the health points
+     * - Cannot exceed the MaxHP parameter
+     * - Cannot have a negative value
+     * - If the value is 0, a hook named `onDead()` is called in the RpgPlayer class.
+     *
+     * ```ts
+     * player.hp = 100
+     * ```
+     * @title Change HP
+     * @prop {number} player.hp
+     * @default MaxHPValue
+     * @memberof ParameterManager
+     * */
+    hp: number;
+    /**
+     * Changes the skill points
+     * - Cannot exceed the MaxSP parameter
+     * - Cannot have a negative value
+     *
+     * ```ts
+     * player.sp = 200
+     * ```
+     * @title Change SP
+     * @prop {number} player.sp
+     * @default MaxSPValue
+     * @memberof ParameterManager
+     * */
+    sp: number;
+    /**
+     * Changing the player's experience.
+     * ```ts
+     * player.exp += 100
+     * ```
+     *
+     * Levels are based on the experience curve.
+     *
+     * ```ts
+     * console.log(player.level) // 1
+     * console.log(player.expForNextlevel) // 150
+     * player.exp += 160
+     * console.log(player.level) // 2
+     * ```
+     *
+     * @title Change Experience
+     * @prop {number} player.exp
+     * @default 0
+     * @memberof ParameterManager
+     * */
+    exp: number;
+    /**
+     * Changing the player's level.
+     *
+     * ```ts
+     * player.level += 1
+     * ```
+     *
+     * The level will be between the initial level given by the `initialLevel` and final level given by `finalLevel`
+     *
+     * ```ts
+     * player.finalLevel = 50
+     * player.level = 60
+     * console.log(player.level) // 50
+     * ```
+     *
+     * @title Change Level
+     * @prop {number} player.level
+     * @default 1
+     * @memberof ParameterManager
+     * */
+    level: number;
+    /**
+     * ```ts
+     * console.log(player.expForNextlevel) // 150
+     * ```
+     * @title Experience for next level ?
+     * @prop {number} player.expForNextlevel
+     * @readonly
+     * @memberof ParameterManager
+     * */
+    readonly expForNextlevel: number;
+    /**
+     * Read the value of a parameter. Put the name of the parameter.
+     *
+     * ```ts
+     * import { Presets } from '@rpgjs/server'
+     *
+     * const { MAXHP } = Presets
+     *
+     * console.log(player.param[MAXHP])
+     * ```
+     *
+     * > Possible to use the `player.getParamValue(name)` method instead
+     * @title Get Param Value
+     * @prop {object} player.param
+     * @readonly
+     * @memberof ParameterManager
+     * */
+    readonly param: {
+        [key: string]: number;
+    };
+    /**
+     * Direct parameter modifiers (reactive signal)
+     *
+     * > It is important that these parameters have been created beforehand with the `addParameter()` method.
+     * > By default, the following settings have been created:
+     * - maxhp
+     * - maxsp
+     * - str
+     * - int
+     * - dex
+     * - agi
+     *
+     * **Object Key**
+     *
+     * The key of the object is the name of the parameter
+     *
+     * > The good practice is to retrieve the name coming from a constant
+     *
+     * **Object Value**
+     *
+     * The value of the key is an object containing:
+     * ```
+     * {
+     *   value: number,
+     *   rate: number
+     * }
+     * ```
+     *
+     * - value: Adds a number to the parameter
+     * - rate: Adds a rate to the parameter
+     *
+     * > Note that you can put both (value and rate)
+     *
+     * This property uses reactive signals - changes automatically trigger parameter recalculation.
+     * The final parameter values in `param` include aggregated modifiers from equipment, states, etc.
+     *
+     * @prop {Object} [paramsModifier]
+     * @example
+     *
+     * ```ts
+     * import { Presets } from '@rpgjs/server'
+     *
+     * const { MAXHP } = Presets
+     *
+     * // Set direct modifiers (reactive)
+     * player.paramsModifier = {
+     *      [MAXHP]: {
+     *          value: 100
+     *      }
+     * }
+     *
+     * // Parameters automatically recalculate
+     * console.log(player.param[MAXHP]); // Updated value
+     * ```
+     *
+     * @title Set Parameters Modifier
+     * @prop {object} paramsModifier
+     * @memberof ParameterManager
+     * */
+    paramsModifier: {
+        [key: string]: {
+            value?: number;
+            rate?: number;
+        };
+    };
+    /**
+     * Get or set the parameters object
+     *
+     * @prop {object} parameters
+     * @memberof ParameterManager
+     */
+    parameters: {
+        [key: string]: {
+            start: number;
+            end: number;
+        };
+    };
+    /**
+     * Get the value of a specific parameter by name
+     *
+     * @deprecated Use `player.param[name]` instead for better reactivity
+     * @param name - The name of the parameter to get
+     * @returns The calculated parameter value
+     *
+     * @example
+     * ```ts
+     * import { Presets } from '@rpgjs/server'
+     *
+     * const { MAXHP } = Presets
+     *
+     * // Preferred way (reactive)
+     * const maxHp = player.param[MAXHP];
+     *
+     * // Legacy way (still works)
+     * const maxHp = player.getParamValue(MAXHP);
+     * ```
+     */
+    getParamValue(name: string): number;
+    /**
+     * Give a new parameter. Give a start value and an end value.
+     * The start value will be set to the level set at `player.initialLevel` and the end value will be linked to the level set at `player.finalLevel`.
+     *
+     * ```ts
+     * const SPEED = 'speed'
+     *
+     * player.addParameter(SPEED, {
+     *     start: 10,
+     *     end: 100
+     * })
+     *
+     * player.param[SPEED] // 10
+     * player.level += 5
+     * player.param[SPEED] // 14
+     * ```
+     *
+     * @title Add custom parameters
+     * @method player.addParameter(name,curve)
+     * @param {string} name - The name of the parameter
+     * @param {object} curve - Scheme of the object: { start: number, end: number }
+     * @returns {void}
+     * @memberof ParameterManager
+     * */
+    addParameter(name: string, curve: {
+        start: number;
+        end: number;
+    }): void;
+    /**
+     * Gives back in percentage of health points to skill points
+     *
+     * ```ts
+     * import { Presets } from '@rpgjs/server'
+     *
+     * const { MAXHP } = Presets
+     *
+     * console.log(player.param[MAXHP]) // 800
+     * player.hp = 100
+     * player.recovery({ hp: 0.5 }) // = 800 * 0.5
+     * console.log(player.hp) // 400
+     * ```
+     *
+     * @title Recovery HP and/or SP
+     * @method player.recovery(params)
+     * @param {object} params - Scheme of the object: { hp: number, sp: number }. The values of the numbers must be in 0 and 1
+     * @returns {void}
+     * @memberof ParameterManager
+     * */
+    recovery(params: {
+        hp?: number;
+        sp?: number;
+    }): void;
+    /**
+     * restores all HP and SP
+     *
+     * ```ts
+     * import { Presets } from '@rpgjs/server'
+     *
+     * const { MAXHP, MAXSP } = Presets
+     *
+     * console.log(player.param[MAXHP], player.param[MAXSP]) // 800, 230
+     * player.hp = 100
+     * player.sp = 0
+     * player.allRecovery()
+     * console.log(player.hp, player.sp) // 800, 230
+     * ```
+     *
+     * @title All Recovery
+     * @method player.allRecovery()
+     * @returns {void}
+     * @memberof ParameterManager
+     * */
+    allRecovery(): void;
+}
 /**
- * Parameter Manager Mixin
+ * Parameter Manager Mixin with Reactive Signals
+ *
+ * Provides comprehensive parameter management functionality using reactive signals from `@signe/reactive`.
+ * This mixin handles health points (HP), skill points (SP), experience and level progression,
+ * custom parameters, and parameter modifiers with automatic reactivity.
  *
- * 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.
+ * **Key Features:**
+ * - ✨ **Reactive Parameters**: All parameters automatically recalculate when level or modifiers change
+ * - 🚀 **Performance Optimized**: Uses computed signals to avoid unnecessary recalculations
+ * - 🔄 **Real-time Updates**: Changes propagate automatically throughout the system
+ * - 🎯 **Type Safe**: Full TypeScript support with proper type inference
  *
+ * @template TBase - The base class constructor type
  * @param Base - The base class to extend with parameter management
- * @returns Extended class with parameter management methods
+ * @returns Extended class with reactive parameter management methods
  *
  * @example
  * ```ts
  * class MyPlayer extends WithParameterManager(BasePlayer) {
  *   constructor() {
  *     super();
+ *
+ *     // Add custom parameters
  *     this.addParameter('strength', { start: 10, end: 100 });
+ *     this.addParameter('magic', { start: 5, end: 80 });
  *   }
  * }
  *
  * const player = new MyPlayer();
- * player.hp = 100;
+ *
+ * // Reactive parameter updates
  * player.level = 5;
+ * console.log(player.param.strength); // Automatically calculated for level 5
+ *
+ * // Reactive modifiers
+ * player.paramsModifier = {
+ *   [MAXHP]: { value: 100, rate: 1.2 }
+ * };
+ * console.log(player.param[MAXHP]); // Automatically includes modifiers
  * ```
  */
 export declare function WithParameterManager<TBase extends PlayerCtor>(Base: TBase): TBase;
-export type IParameterManager = InstanceType<ReturnType<typeof WithParameterManager>>;

package/dist/Player/Player.d.ts

@@ -1,4 +1,4 @@
-import { RpgCommonPlayer } from '@rpgjs/common';
+import { Hooks } from '@rpgjs/common';
 import { IComponentManager } from './ComponentManager';
 import { RpgMap } from '../rooms/map';
 import { Context } from '@signe/di';
@@ -24,7 +24,7 @@ interface ZoneOptions {
     linkedTo?: string;
     limitedByWalls?: boolean;
 }
-declare const RpgPlayer_base: typeof RpgCommonPlayer;
+declare const RpgPlayer_base: import('@rpgjs/common').PlayerCtor;
 /**
  * RPG Player class with component management capabilities
  *
@@ -50,6 +50,8 @@ export declare class RpgPlayer extends RpgPlayer_base {
     conn: MockConnection | null;
     events: import('@signe/reactive').WritableArraySignal<RpgEvent[]>;
     constructor();
+    _onInit(): void;
+    get hooks(): Hooks;
     execMethod(method: string, methodData?: any[], target?: any): Promise<any>;
     /**
      * Change the map for this player
@@ -78,6 +80,8 @@ export declare class RpgPlayer extends RpgPlayer_base {
     }): Promise<false | undefined>;
     getCurrentMap<T extends RpgMap = RpgMap>(): T | null;
     emit(type: string, value?: any): void;
+    save(): Promise<string>;
+    load(snapshot: string): Promise<void>;
     /**
      * Set the current animation of the player's sprite
      *
@@ -142,36 +146,13 @@ export declare class RpgPlayer extends RpgPlayer_base {
      * });
      * ```
      */
-    showComponentAnimation(id: string, params: any): void;
+    showComponentAnimation(id: string, params?: any): void;
+    showHit(text: string): void;
     /**
-     * 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");
-     * ```
+     * Set the sync schema for the map
+     * @param schema - The schema to set
      */
-    showAnimation(graphic: string, animationName?: string, replaceGraphic?: boolean): void;
-    showHit(text: string): void;
+    setSync(schema: any): void;
 }
 export declare class RpgEvent extends RpgPlayer {
     execMethod(methodName: string, methodData?: any[], instance?: this): Promise<any>;

package/dist/index.d.ts

@@ -7,3 +7,5 @@ export * from './Player/Player';
 export * from './module';
 export * from './rooms/map';
 export * from './presets';
+export * from '@signe/reactive';
+export * from './Gui';