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

package/dist/Player/MoveManager.d.ts

@@ -1,7 +1,8 @@
-import { PlayerCtor, Direction } from '@rpgjs/common';
+import { PlayerCtor, ProjectileType, RpgCommonPlayer, Direction, MovementStrategy } from '@rpgjs/common';
 import { RpgPlayer } from './Player';
 type CallbackTileMove = (player: RpgPlayer, map: any) => Direction[];
 type CallbackTurnMove = (player: RpgPlayer, map: any) => string;
+type Routes = (string | Promise<any> | Direction | Direction[] | Function)[];
 export declare enum Frequency {
     Lowest = 600,
     Lower = 400,
@@ -158,8 +159,148 @@ export declare const Move: MoveList;
  */
 export declare function WithMoveManager<TBase extends PlayerCtor>(Base: TBase): PlayerCtor;
 /**
- * Type helper to extract the interface from the WithMoveManager mixin
- * This provides the type without duplicating method signatures
+ * Interface for Move Manager functionality
+ *
+ * Provides comprehensive movement management capabilities including pathfinding,
+ * physics-based movement, route following, and advanced movement strategies.
+ * This interface defines the public API of the MoveManager mixin.
  */
-export type IMoveManager = InstanceType<ReturnType<typeof WithMoveManager>>;
+export interface IMoveManager {
+    /** Whether the player passes through other players */
+    throughOtherPlayer: boolean;
+    /** Whether the player goes through events or other players */
+    through: boolean;
+    /** Frequency for movement timing (milliseconds between movements) */
+    frequency: number;
+    /**
+     * Add a custom movement strategy to this entity
+     *
+     * @param strategy - The movement strategy to add
+     */
+    addMovement(strategy: MovementStrategy): void;
+    /**
+     * Remove a specific movement strategy from this entity
+     *
+     * @param strategy - The strategy instance to remove
+     * @returns True if the strategy was found and removed
+     */
+    removeMovement(strategy: MovementStrategy): boolean;
+    /**
+     * Remove all active movement strategies from this entity
+     */
+    clearMovements(): void;
+    /**
+     * Check if this entity has any active movement strategies
+     *
+     * @returns True if entity has active movements
+     */
+    hasActiveMovements(): boolean;
+    /**
+     * Get all active movement strategies for this entity
+     *
+     * @returns Array of active movement strategies
+     */
+    getActiveMovements(): MovementStrategy[];
+    /**
+     * Move toward a target player or position using AI pathfinding
+     *
+     * @param target - Target player or position to move toward
+     */
+    moveTo(target: RpgCommonPlayer | {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Stop the current moveTo behavior
+     */
+    stopMoveTo(): void;
+    /**
+     * Perform a dash movement in the specified direction
+     *
+     * @param direction - Normalized direction vector
+     * @param speed - Movement speed (default: 8)
+     * @param duration - Duration in milliseconds (default: 200)
+     */
+    dash(direction: {
+        x: number;
+        y: number;
+    }, speed?: number, duration?: number): void;
+    /**
+     * Apply knockback effect in the specified direction
+     *
+     * @param direction - Normalized direction vector
+     * @param force - Initial knockback force (default: 5)
+     * @param duration - Duration in milliseconds (default: 300)
+     */
+    knockback(direction: {
+        x: number;
+        y: number;
+    }, force?: number, duration?: number): void;
+    /**
+     * Follow a sequence of waypoints
+     *
+     * @param waypoints - Array of x,y positions to follow
+     * @param speed - Movement speed (default: 2)
+     * @param loop - Whether to loop back to start (default: false)
+     */
+    followPath(waypoints: Array<{
+        x: number;
+        y: number;
+    }>, speed?: number, loop?: boolean): void;
+    /**
+     * Apply oscillating movement pattern
+     *
+     * @param direction - Primary oscillation axis (normalized)
+     * @param amplitude - Maximum distance from center (default: 50)
+     * @param period - Time for complete cycle in ms (default: 2000)
+     */
+    oscillate(direction: {
+        x: number;
+        y: number;
+    }, amplitude?: number, period?: number): void;
+    /**
+     * Apply ice movement physics
+     *
+     * @param direction - Target movement direction
+     * @param maxSpeed - Maximum speed when fully accelerated (default: 4)
+     */
+    applyIceMovement(direction: {
+        x: number;
+        y: number;
+    }, maxSpeed?: number): void;
+    /**
+     * Shoot a projectile in the specified direction
+     *
+     * @param type - Type of projectile trajectory
+     * @param direction - Normalized direction vector
+     * @param speed - Projectile speed (default: 200)
+     */
+    shootProjectile(type: ProjectileType, direction: {
+        x: number;
+        y: number;
+    }, speed?: number): void;
+    /**
+     * Give an itinerary to follow using movement strategies
+     *
+     * @param routes - Array of movement instructions to execute
+     * @returns Promise that resolves when all routes are completed
+     */
+    moveRoutes(routes: Routes): Promise<boolean>;
+    /**
+     * Give a path that repeats itself in a loop to a character
+     *
+     * @param routes - Array of movement instructions to repeat infinitely
+     */
+    infiniteMoveRoute(routes: Routes): void;
+    /**
+     * Stop an infinite movement
+     *
+     * @param force - Forces the stop of the infinite movement immediately
+     */
+    breakRoutes(force?: boolean): void;
+    /**
+     * Replay an infinite movement
+     */
+    replayRoutes(): void;
+}
 export {};

package/dist/Player/Player.d.ts

@@ -65,6 +65,7 @@ export declare class RpgPlayer extends RpgPlayer_base {
     constructor();
     _onInit(): void;
     get hooks(): Hooks;
+    get server(): RpgMap | null;
     applyFrames(): void;
     execMethod(method: string, methodData?: any[], target?: any): Promise<any>;
     /**
@@ -310,6 +311,140 @@ export declare class RpgPlayer extends RpgPlayer_base {
      * ```
      */
     stopSound(soundId: string): void;
+    /**
+     * Stop all currently playing sounds for this player
+     *
+     * This method stops all sounds that are currently playing for the player.
+     * Useful when changing maps to prevent sound overlap.
+     *
+     * @example
+     * ```ts
+     * // Stop all sounds before changing map
+     * player.stopAllSounds();
+     * await player.changeMap("new-map");
+     * ```
+     */
+    stopAllSounds(): void;
+    /**
+     * Make the camera follow another player or event
+     *
+     * This method sends an instruction to the client to fix the viewport on another sprite.
+     * The camera will follow the specified player or event, with optional smooth animation.
+     *
+     * ## Design
+     *
+     * The camera follow instruction is sent only to this player's client connection.
+     * This allows each player to have their own camera target, useful for cutscenes,
+     * following NPCs, or focusing on specific events.
+     *
+     * @param otherPlayer - The player or event that the camera should follow
+     * @param options - Camera follow options
+     * @param options.smoothMove - Enable smooth animation. Can be a boolean (default: true) or an object with animation parameters
+     * @param options.smoothMove.time - Time duration for the animation in milliseconds (optional)
+     * @param options.smoothMove.ease - Easing function name. Visit https://easings.net for available functions (optional)
+     *
+     * @example
+     * ```ts
+     * // Follow another player with default smooth animation
+     * player.cameraFollow(otherPlayer, { smoothMove: true });
+     *
+     * // Follow an event with custom smooth animation
+     * player.cameraFollow(npcEvent, {
+     *   smoothMove: {
+     *     time: 1000,
+     *     ease: "easeInOutQuad"
+     *   }
+     * });
+     *
+     * // Follow without animation (instant)
+     * player.cameraFollow(targetPlayer, { smoothMove: false });
+     * ```
+     */
+    cameraFollow(otherPlayer: RpgPlayer | RpgEvent, options?: {
+        smoothMove?: boolean | {
+            time?: number;
+            ease?: string;
+        };
+    }): void;
+    /**
+     * Trigger a flash animation on this player
+     *
+     * This method sends a flash animation event to the client, creating a visual
+     * feedback effect on the player's sprite. The flash can be configured with
+     * various options including type (alpha, tint, or both), duration, cycles, and color.
+     *
+     * ## Design
+     *
+     * The flash is sent as a broadcast event to all clients viewing this player.
+     * This is useful for visual feedback when the player takes damage, receives
+     * a buff, or when an important event occurs.
+     *
+     * @param options - Flash configuration options
+     * @param options.type - Type of flash effect: 'alpha' (opacity), 'tint' (color), or 'both' (default: 'alpha')
+     * @param options.duration - Duration of the flash animation in milliseconds (default: 300)
+     * @param options.cycles - Number of flash cycles (flash on/off) (default: 1)
+     * @param options.alpha - Alpha value when flashing, from 0 to 1 (default: 0.3)
+     * @param options.tint - Tint color when flashing as hex value or color name (default: 0xffffff - white)
+     *
+     * @example
+     * ```ts
+     * // Simple flash with default settings (alpha flash)
+     * player.flash();
+     *
+     * // Flash with red tint when taking damage
+     * player.flash({ type: 'tint', tint: 0xff0000 });
+     *
+     * // Flash with both alpha and tint for dramatic effect
+     * player.flash({
+     *   type: 'both',
+     *   alpha: 0.5,
+     *   tint: 0xff0000,
+     *   duration: 200,
+     *   cycles: 2
+     * });
+     *
+     * // Quick damage flash
+     * player.flash({
+     *   type: 'tint',
+     *   tint: 'red',
+     *   duration: 150,
+     *   cycles: 1
+     * });
+     * ```
+     */
+    flash(options?: {
+        type?: 'alpha' | 'tint' | 'both';
+        duration?: number;
+        cycles?: number;
+        alpha?: number;
+        tint?: number | string;
+    }): void;
+    /**
+     * Set the hitbox of the player for collision detection
+     *
+     * This method defines the hitbox used for collision detection in the physics engine.
+     * The hitbox can be smaller or larger than the visual representation of the player,
+     * allowing for precise collision detection.
+     *
+     * ## Design
+     *
+     * The hitbox is used by the physics engine to detect collisions with other entities,
+     * static obstacles, and shapes. Changing the hitbox will immediately update the
+     * collision detection without affecting the visual appearance of the player.
+     *
+     * @param width - Width of the hitbox in pixels
+     * @param height - Height of the hitbox in pixels
+     *
+     * @example
+     * ```ts
+     * // Set a 20x20 hitbox for precise collision detection
+     * player.setHitbox(20, 20);
+     *
+     * // Set a larger hitbox for easier collision detection
+     * player.setHitbox(40, 40);
+     * ```
+     */
+    setHitbox(width: number, height: number): void;
     /**
      * Set the sync schema for the map
      * @param schema - The schema to set

package/dist/Player/SkillManager.d.ts

@@ -1,4 +1,5 @@
 import { PlayerCtor } from '@rpgjs/common';
+import { RpgPlayer } from './Player';
 /**
  * Skill Manager Mixin
  *
@@ -25,7 +26,45 @@ import { PlayerCtor } from '@rpgjs/common';
  */
 export declare function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase;
 /**
- * Type helper to extract the interface from the WithSkillManager mixin
- * This provides the type without duplicating method signatures
+ * Interface for Skill Manager functionality
+ *
+ * Provides skill management capabilities including learning, forgetting, and using skills.
+ * This interface defines the public API of the SkillManager mixin.
  */
-export type ISkillManager = InstanceType<ReturnType<typeof WithSkillManager>>;
+export interface ISkillManager {
+    /**
+     * Retrieves a learned skill. Returns null if not found
+     *
+     * @param skillClass - Skill class or data id
+     * @returns Instance of SkillClass or null
+     */
+    getSkill(skillClass: any | string): any | null;
+    /**
+     * Learn a skill
+     *
+     * @param skillId - Skill class or data id
+     * @returns Instance of SkillClass
+     * @throws SkillLog.alreadyLearned if the player already knows the skill
+     */
+    learnSkill(skillId: any | string): any;
+    /**
+     * Forget a skill
+     *
+     * @param skillId - Skill class or data id
+     * @returns Instance of SkillClass
+     * @throws SkillLog.notLearned if trying to forget a skill not learned
+     */
+    forgetSkill(skillId: any | string): any;
+    /**
+     * Using a skill
+     *
+     * @param skillId - Skill class or data id
+     * @param otherPlayer - Optional target player(s) to apply skill to
+     * @returns Instance of SkillClass
+     * @throws SkillLog.restriction if player has Effect.CAN_NOT_SKILL
+     * @throws SkillLog.notLearned if player tries to use an unlearned skill
+     * @throws SkillLog.notEnoughSp if player does not have enough SP
+     * @throws SkillLog.chanceToUseFailed if the chance to use the skill has failed
+     */
+    useSkill(skillId: any | string, otherPlayer?: RpgPlayer | RpgPlayer[]): any;
+}

package/dist/Player/StateManager.d.ts

@@ -1,4 +1,8 @@
 import { PlayerCtor } from '@rpgjs/common';
+import { RpgPlayer } from './Player';
+type StateClass = {
+    new (...args: any[]): any;
+};
 /**
  * State Manager Mixin
  *
@@ -26,7 +30,74 @@ import { PlayerCtor } from '@rpgjs/common';
  */
 export declare function WithStateManager<TBase extends PlayerCtor>(Base: TBase): TBase;
 /**
- * Type helper to extract the interface from the WithStateManager mixin
- * This provides the type without duplicating method signatures
+ * Interface for State Manager functionality
+ *
+ * Provides state management capabilities including state defense, efficiency modifiers,
+ * and state application/removal. This interface defines the public API of the StateManager mixin.
  */
-export type IStateManager = InstanceType<ReturnType<typeof WithStateManager>>;
+export interface IStateManager {
+    /**
+     * Gets the defensive capabilities against various states from equipped items
+     *
+     * @returns Array of state defense objects with rate and state properties
+     */
+    statesDefense: {
+        rate: number;
+        state: any;
+    }[];
+    /**
+     * Manages the player's state efficiency modifiers
+     *
+     * @returns Signal containing array of state efficiency objects
+     */
+    statesEfficiency: any;
+    /**
+     * Apply states to a player from skill or item effects
+     *
+     * @param player - The target player to apply states to
+     * @param states - Object containing arrays of states to add or remove
+     */
+    applyStates(player: RpgPlayer, states: {
+        addStates?: Array<{
+            state: any;
+            rate: number;
+        }>;
+        removeStates?: Array<{
+            state: any;
+            rate: number;
+        }>;
+    }): void;
+    /**
+     * Get a state to the player. Returns null if the state is not present
+     *
+     * @param stateClass - The state class constructor or state ID to search for
+     * @returns The state instance if found, null otherwise
+     */
+    getState(stateClass: StateClass | string): any | null;
+    /**
+     * Adds a state to the player
+     *
+     * @param stateClass - The state class constructor or state ID to apply
+     * @param chance - Probability of successful application (0-1, default 1)
+     * @returns The state instance if successfully applied, null if already present
+     * @throws StateLog.addFailed if the chance roll fails
+     */
+    addState(stateClass: StateClass | string, chance?: number): object | null;
+    /**
+     * Remove a state to the player
+     *
+     * @param stateClass - The state class constructor or state ID to remove
+     * @param chance - Probability of successful removal (0-1, default 1)
+     * @throws StateLog.removeFailed if the chance roll fails
+     * @throws StateLog.notApplied if the state is not currently active
+     */
+    removeState(stateClass: StateClass | string, chance?: number): void;
+    /**
+     * Find state efficiency modifier for a specific state class
+     *
+     * @param stateClass - The state class to find efficiency for
+     * @returns The efficiency object if found, undefined otherwise
+     */
+    findStateEfficiency(stateClass: any): any | undefined;
+}
+export {};

package/dist/Player/VariableManager.d.ts

@@ -24,7 +24,51 @@ import { PlayerCtor } from '@rpgjs/common';
  */
 export declare function WithVariableManager<TBase extends PlayerCtor>(Base: TBase): TBase;
 /**
- * Type helper to extract the interface from the WithVariableManager mixin
- * This provides the type without duplicating method signatures
+ * Interface for Variable Manager functionality
+ *
+ * Provides variable management capabilities including storing, retrieving, and managing
+ * key-value pairs for player-specific data. This interface defines the public API
+ * of the VariableManager mixin.
  */
-export type IVariableManager = InstanceType<ReturnType<typeof WithVariableManager>>;
+export interface IVariableManager {
+    /** Map storing all player variables */
+    variables: Map<string, any>;
+    /**
+     * Assign a variable to the player
+     *
+     * @param key - The variable identifier
+     * @param val - The value to store
+     */
+    setVariable(key: string, val: any): void;
+    /**
+     * Get a variable value
+     *
+     * @param key - The variable identifier to retrieve
+     * @returns The stored value or undefined if not found
+     */
+    getVariable<U = any>(key: string): U | undefined;
+    /**
+     * Remove a variable
+     *
+     * @param key - The variable identifier to remove
+     * @returns true if a variable existed and has been removed, false otherwise
+     */
+    removeVariable(key: string): boolean;
+    /**
+     * Check if a variable exists
+     *
+     * @param key - The variable identifier to check
+     * @returns true if the variable exists, false otherwise
+     */
+    hasVariable(key: string): boolean;
+    /**
+     * Get all variable keys
+     *
+     * @returns Array of all variable keys
+     */
+    getVariableKeys(): string[];
+    /**
+     * Clear all variables
+     */
+    clearVariables(): void;
+}