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

package/dist/index.js

@@ -19913,206 +19913,49 @@ function WithMoveManager(Base) {
         baseProto.showComponentAnimation.call(this, id, params);
       }
     }
-    /** 
-    * The player passes through the other players (or vice versa). But the player does not go through the events.
-    * 
-    * ```ts
-    * player.throughOtherPlayer = true
-    * ```
-    * 
-    * @title Go through to other player
-    * @prop {boolean} player.throughOtherPlayer
-    * @default true
-    * @memberof MoveManager
-    * */
     set throughOtherPlayer(value) {
       this._throughOtherPlayer.set(value);
     }
     get throughOtherPlayer() {
       return this._throughOtherPlayer();
     }
-    /** 
-     * The player goes through the event or the other players (or vice versa)
-     * 
-     * ```ts
-     * player.through = true
-     * ```
-     * 
-     * @title Go through the player
-     * @prop {boolean} player.through
-     * @default false
-     * @memberof MoveManager
-     * */
     set through(value) {
       this._through.set(value);
     }
     get through() {
       return this._through();
     }
-    /** 
-     * The frequency allows to put a stop time between each movement in the array of the moveRoutes() method.
-     * The value represents a dwell time in milliseconds. The higher the value, the slower the frequency.
-     * 
-     * ```ts
-     * player.frequency = 400
-     * ```
-     * 
-     * You can use Frequency enum
-     * 
-     * ```ts
-     * import { Frequency } from '@rpgjs/server'
-     * player.frequency = Frequency.Low
-     * ```
-     * 
-     * @title Change Frequency
-     * @prop {number} player.speed
-     * @enum {number}
-     * 
-     * Frequency.Lowest | 600
-     * Frequency.Lower | 400
-     * Frequency.Low | 200
-     * Frequency.High | 100
-     * Frequency.Higher | 50
-     * Frequency.Highest | 25
-     * Frequency.None | 0
-     * @default 0
-     * @memberof MoveManager
-     * */
     set frequency(value) {
       this._frequency.set(value);
     }
     get frequency() {
       return this._frequency();
     }
-    /**
-     * Add a custom movement strategy to this entity
-     * 
-     * Allows adding any custom MovementStrategy implementation.
-     * Multiple strategies can be active simultaneously.
-     * 
-     * @param strategy - The movement strategy to add
-     * 
-     * @example
-     * ```ts
-     * // Add custom movement
-     * const customMove = new LinearMove(5, 0, 1000);
-     * player.addMovement(customMove);
-     * 
-     * // Add multiple movements
-     * player.addMovement(new Dash(8, { x: 1, y: 0 }, 200));
-     * player.addMovement(new Oscillate({ x: 0, y: 1 }, 10, 1000));
-     * ```
-     */
     addMovement(strategy) {
       const map = this.getCurrentMap();
       if (!map) return;
       map.moveManager.add(this.id, strategy);
     }
-    /**
-     * Remove a specific movement strategy from this entity
-     * 
-     * @param strategy - The strategy instance to remove
-     * @returns True if the strategy was found and removed
-     * 
-     * @example
-     * ```ts
-     * const dashMove = new Dash(8, { x: 1, y: 0 }, 200);
-     * player.addMovement(dashMove);
-     * 
-     * // Later, remove the specific movement
-     * const removed = player.removeMovement(dashMove);
-     * console.log('Movement removed:', removed);
-     * ```
-     */
     removeMovement(strategy) {
       const map = this.getCurrentMap();
       if (!map) return false;
       return map.moveManager.remove(this.id, strategy);
     }
-    /**
-     * Remove all active movement strategies from this entity
-     * 
-     * Stops all current movements immediately.
-     * 
-     * @example
-     * ```ts
-     * // Stop all movements when player dies
-     * player.clearMovements();
-     * 
-     * // Clear movements before applying new ones
-     * player.clearMovements();
-     * player.dash({ x: 1, y: 0 });
-     * ```
-     */
     clearMovements() {
       const map = this.getCurrentMap();
       if (!map) return;
       map.moveManager.clear(this.id);
     }
-    /**
-     * Check if this entity has any active movement strategies
-     * 
-     * @returns True if entity has active movements
-     * 
-     * @example
-     * ```ts
-     * // Don't accept input while movements are active
-     * if (!player.hasActiveMovements()) {
-     *   player.dash(inputDirection);
-     * }
-     * 
-     * // Check before adding new movement
-     * if (player.hasActiveMovements()) {
-     *   player.clearMovements();
-     * }
-     * ```
-     */
     hasActiveMovements() {
       const map = this.getCurrentMap();
       if (!map) return false;
       return map.moveManager.hasActiveStrategies(this.id);
     }
-    /**
-     * Get all active movement strategies for this entity
-     * 
-     * @returns Array of active movement strategies
-     * 
-     * @example
-     * ```ts
-     * // Check what movements are currently active
-     * const movements = player.getActiveMovements();
-     * console.log(`Player has ${movements.length} active movements`);
-     * 
-     * // Find specific movement type
-     * const hasDash = movements.some(m => m instanceof Dash);
-     * ```
-     */
     getActiveMovements() {
       const map = this.getCurrentMap();
       if (!map) return [];
       return map.moveManager.getStrategies(this.id);
     }
-    /**
-     * Move toward a target player or position using AI pathfinding
-     * 
-     * Uses SeekAvoid strategy for intelligent pathfinding with obstacle avoidance.
-     * The entity will seek toward the target while avoiding obstacles.
-     * 
-     * @param target - Target player or position to move toward
-     * 
-     * @example
-     * ```ts
-     * // Move toward another player
-     * const targetPlayer = game.getPlayer('player2');
-     * player.moveTo(targetPlayer);
-     * 
-     * // Move toward a specific position
-     * player.moveTo({ x: 300, y: 200 });
-     * 
-     * // Stop the movement later
-     * player.stopMoveTo();
-     * ```
-     */
     moveTo(target) {
       const map = this.getCurrentMap();
       if (!map) return;
@@ -20135,22 +19978,6 @@ function WithMoveManager(Base) {
         new SeekAvoid(engine, () => staticTarget, 80, 140, 80, 48)
       );
     }
-    /**
-     * Stop the current moveTo behavior
-     * 
-     * Removes any active SeekAvoid strategies.
-     * 
-     * @example
-     * ```ts
-     * // Start following a target
-     * player.moveTo(targetPlayer);
-     * 
-     * // Stop following when target is reached
-     * if (distanceToTarget < 10) {
-     *   player.stopMoveTo();
-     * }
-     * ```
-     */
     stopMoveTo() {
       const map = this.getCurrentMap();
       if (!map) return;
@@ -20161,147 +19988,21 @@ function WithMoveManager(Base) {
         }
       });
     }
-    /**
-     * Perform a dash movement in the specified direction
-     * 
-     * Applies high-speed movement for a short duration.
-     * 
-     * @param direction - Normalized direction vector
-     * @param speed - Movement speed (default: 8)
-     * @param duration - Duration in milliseconds (default: 200)
-     * 
-     * @example
-     * ```ts
-     * // Dash right
-     * player.dash({ x: 1, y: 0 });
-     * 
-     * // Dash diagonally with custom speed and duration
-     * player.dash({ x: 0.7, y: 0.7 }, 12, 300);
-     * 
-     * // Dash in input direction
-     * player.dash(inputDirection, 10, 150);
-     * ```
-     */
     dash(direction, speed = 8, duration = 200) {
       this.addMovement(new Dash(speed, direction, duration));
     }
-    /**
-     * Apply knockback effect in the specified direction
-     * 
-     * Creates a push effect that gradually decreases over time.
-     * 
-     * @param direction - Normalized direction vector
-     * @param force - Initial knockback force (default: 5)
-     * @param duration - Duration in milliseconds (default: 300)
-     * 
-     * @example
-     * ```ts
-     * // Knockback from explosion
-     * const explosionDir = { x: -1, y: 0 };
-     * player.knockback(explosionDir, 8, 400);
-     * 
-     * // Light knockback from attack
-     * player.knockback(attackDirection, 3, 200);
-     * ```
-     */
     knockback(direction, force = 5, duration = 300) {
       this.addMovement(new Knockback(direction, force, duration));
     }
-    /**
-     * Follow a sequence of waypoints
-     * 
-     * Entity will move through each waypoint in order.
-     * 
-     * @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)
-     * 
-     * @example
-     * ```ts
-     * // Create a patrol route
-     * const patrolPoints = [
-     *   { x: 100, y: 100 },
-     *   { x: 300, y: 100 },
-     *   { x: 300, y: 300 },
-     *   { x: 100, y: 300 }
-     * ];
-     * player.followPath(patrolPoints, 3, true);
-     * 
-     * // One-time path to destination
-     * player.followPath([{ x: 500, y: 200 }], 4);
-     * ```
-     */
     followPath(waypoints, speed = 2, loop = false) {
       this.addMovement(new PathFollow(waypoints, speed, loop));
     }
-    /**
-     * Apply oscillating movement pattern
-     * 
-     * Entity moves back and forth along the specified axis.
-     * 
-     * @param direction - Primary oscillation axis (normalized)
-     * @param amplitude - Maximum distance from center (default: 50)
-     * @param period - Time for complete cycle in ms (default: 2000)
-     * 
-     * @example
-     * ```ts
-     * // Horizontal oscillation
-     * player.oscillate({ x: 1, y: 0 }, 100, 3000);
-     * 
-     * // Vertical oscillation
-     * player.oscillate({ x: 0, y: 1 }, 30, 1500);
-     * 
-     * // Diagonal oscillation
-     * player.oscillate({ x: 0.7, y: 0.7 }, 75, 2500);
-     * ```
-     */
     oscillate(direction, amplitude = 50, period = 2e3) {
       this.addMovement(new Oscillate(direction, amplitude, period));
     }
-    /**
-     * Apply ice movement physics
-     * 
-     * Creates slippery movement with gradual acceleration and inertia.
-     * Perfect for ice terrains or slippery surfaces.
-     * 
-     * @param direction - Target movement direction
-     * @param maxSpeed - Maximum speed when fully accelerated (default: 4)
-     * 
-     * @example
-     * ```ts
-     * // Apply ice physics when on ice terrain
-     * if (onIceTerrain) {
-     *   player.applyIceMovement(inputDirection, 5);
-     * }
-     * 
-     * // Update direction when input changes
-     * iceMovement.setTargetDirection(newDirection);
-     * ```
-     */
     applyIceMovement(direction, maxSpeed = 4) {
       this.addMovement(new IceMovement(direction, maxSpeed));
     }
-    /**
-     * Shoot a projectile in the specified direction
-     * 
-     * Creates projectile movement with various trajectory types.
-     * 
-     * @param type - Type of projectile trajectory
-     * @param direction - Normalized direction vector
-     * @param speed - Projectile speed (default: 200)
-     * 
-     * @example
-     * ```ts
-     * // Shoot arrow
-     * player.shootProjectile(ProjectileType.Straight, { x: 1, y: 0 }, 300);
-     * 
-     * // Throw grenade with arc
-     * player.shootProjectile(ProjectileType.Arc, { x: 0.7, y: 0.7 }, 150);
-     * 
-     * // Bouncing projectile
-     * player.shootProjectile(ProjectileType.Bounce, { x: 1, y: 0 }, 100);
-     * ```
-     */
     shootProjectile(type, direction, speed = 200) {
       const config = {
         speed,
@@ -20314,49 +20015,6 @@ function WithMoveManager(Base) {
       };
       this.addMovement(new ProjectileMovement(type, config));
     }
-    /**
-     * Give an itinerary to follow using movement strategies
-     * 
-     * Executes a sequence of movements and actions in order. Each route can be:
-     * - A Direction enum value for basic movement
-     * - A string starting with "turn-" for direction changes
-     * - A function that returns directions or actions
-     * - A Promise for async operations
-     * 
-     * The method processes routes sequentially, respecting the entity's frequency
-     * setting for timing between movements.
-     * 
-     * @param routes - Array of movement instructions to execute
-     * @returns Promise that resolves when all routes are completed
-     * 
-     * @example
-     * ```ts
-     * // Basic directional movements
-     * await player.moveRoutes([
-     *   Direction.Right,
-     *   Direction.Up,
-     *   Direction.Left
-     * ]);
-     * 
-     * // Mix of movements and turns
-     * await player.moveRoutes([
-     *   Direction.Right,
-     *   'turn-' + Direction.Up,
-     *   Direction.Up
-     * ]);
-     * 
-     * // Using functions for dynamic behavior
-     * const customMove = (player, map) => [Direction.Right, Direction.Down];
-     * await player.moveRoutes([customMove]);
-     * 
-     * // With async operations
-     * await player.moveRoutes([
-     *   Direction.Right,
-     *   new Promise(resolve => setTimeout(resolve, 1000)), // Wait 1 second
-     *   Direction.Left
-     * ]);
-     * ```
-     */
     moveRoutes(routes) {
       let count = 0;
       let frequence = 0;
@@ -20468,13 +20126,6 @@ function WithMoveManager(Base) {
         executeNextRoute();
       });
     }
-    /**
-     * Utility method to flatten nested route arrays
-     * 
-     * @private
-     * @param routes - Routes array that may contain nested arrays
-     * @returns Flattened array of routes
-     */
     flattenRoutes(routes) {
       return routes.reduce((acc, item) => {
         if (Array.isArray(item)) {
@@ -20483,43 +20134,6 @@ function WithMoveManager(Base) {
         return acc.concat(item);
       }, []);
     }
-    /**
-     * Give a path that repeats itself in a loop to a character
-     * 
-     * Creates an infinite movement pattern that continues until manually stopped.
-     * The routes will repeat in a continuous loop, making it perfect for patrol
-     * patterns, ambient movements, or any repetitive behavior.
-     * 
-     * You can stop the movement at any time with `breakRoutes()` and replay it 
-     * with `replayRoutes()`.
-     * 
-     * @param routes - Array of movement instructions to repeat infinitely
-     * 
-     * @example
-     * ```ts
-     * // Create an infinite random movement pattern
-     * player.infiniteMoveRoute([Move.random()]);
-     * 
-     * // Create a patrol route
-     * player.infiniteMoveRoute([
-     *   Direction.Right,
-     *   Direction.Right,
-     *   Direction.Down,
-     *   Direction.Left,
-     *   Direction.Left,
-     *   Direction.Up
-     * ]);
-     * 
-     * // Mix movements and rotations
-     * player.infiniteMoveRoute([
-     *   Move.turnRight(),
-     *   Direction.Right,
-     *   Move.wait(1),
-     *   Move.turnLeft(),
-     *   Direction.Left
-     * ]);
-     * ```
-     */
     infiniteMoveRoute(routes) {
       this._infiniteRoutes = routes;
       this._isInfiniteRouteActive = true;
@@ -20538,29 +20152,6 @@ function WithMoveManager(Base) {
       };
       executeInfiniteRoute();
     }
-    /**
-     * Stop an infinite movement
-     * 
-     * Works only for infinite movements created with `infiniteMoveRoute()`.
-     * This method stops the current route execution and prevents the next
-     * iteration from starting.
-     * 
-     * @param force - Forces the stop of the infinite movement immediately
-     * 
-     * @example
-     * ```ts
-     * // Start infinite movement
-     * player.infiniteMoveRoute([Move.random()]);
-     * 
-     * // Stop it when player enters combat
-     * if (inCombat) {
-     *   player.breakRoutes(true);
-     * }
-     * 
-     * // Gentle stop (completes current route first)
-     * player.breakRoutes();
-     * ```
-     */
     breakRoutes(force = false) {
       this._isInfiniteRouteActive = false;
       if (force) {
@@ -20571,32 +20162,6 @@ function WithMoveManager(Base) {
         this._finishRoute = null;
       }
     }
-    /**
-     * Replay an infinite movement
-     * 
-     * Works only for infinite movements that were previously created with 
-     * `infiniteMoveRoute()`. If the route was stopped with `breakRoutes()`, 
-     * you can restart it with this method using the same route configuration.
-     * 
-     * @example
-     * ```ts
-     * // Create infinite movement
-     * player.infiniteMoveRoute([Move.random()]);
-     * 
-     * // Stop it temporarily
-     * player.breakRoutes(true);
-     * 
-     * // Resume the same movement pattern
-     * player.replayRoutes();
-     * 
-     * // Stop and start with different conditions
-     * if (playerNearby) {
-     *   player.breakRoutes();
-     * } else {
-     *   player.replayRoutes();
-     * }
-     * ```
-     */
     replayRoutes() {
       if (this._infiniteRoutes && !this._isInfiniteRouteActive) {
         this.infiniteMoveRoute(this._infiniteRoutes);
@@ -20903,168 +20468,21 @@ function WithVariableManager(Base) {
       super(...arguments);
       this.variables = /* @__PURE__ */ new Map();
     }
-    /** 
-     * Assign a variable to the player
-     * 
-     * Stores a key-value pair in the player's variable map. This is useful for
-     * tracking game state, quest progress, flags, and other player-specific data.
-     * The variable system provides a flexible way to store any type of data
-     * associated with the player that persists throughout the game session.
-     * 
-     * @param key - The variable identifier (string key to reference the variable)
-     * @param val - The value to store (can be any type: boolean, number, string, object, array)
-     * @returns void
-     * 
-     * @example
-     * ```ts
-     * // Set different types of variables
-     * player.setVariable('CHEST_OPENED', true);
-     * player.setVariable('playerLevel', 5);
-     * player.setVariable('questProgress', { step: 1, completed: false });
-     * player.setVariable('inventory', ['sword', 'potion', 'key']);
-     * player.setVariable('lastSaveTime', new Date().toISOString());
-     * ```
-     */
     setVariable(key, val) {
       this.variables.set(key, val);
     }
-    /** 
-     * Get a variable value
-     * 
-     * Retrieves the value associated with the given key from the player's variables.
-     * Returns undefined if the variable doesn't exist. This method is type-safe
-     * and can be used with generic types for better TypeScript support.
-     * 
-     * @param key - The variable identifier to retrieve
-     * @returns The stored value or undefined if not found
-     * 
-     * @example
-     * ```ts
-     * // Get variables with type inference
-     * const hasKey = player.getVariable('CHEST_OPENED'); // boolean | undefined
-     * const level = player.getVariable('playerLevel'); // number | undefined
-     * const quest = player.getVariable('questProgress'); // object | undefined
-     * const missing = player.getVariable('nonexistent'); // undefined
-     * 
-     * // Use with default values
-     * const level = player.getVariable('playerLevel') ?? 1;
-     * const isChestOpened = player.getVariable('CHEST_OPENED') ?? false;
-     * ```
-     */
     getVariable(key) {
       return this.variables.get(key);
     }
-    /** 
-     * Remove a variable
-     * 
-     * Deletes a variable from the player's variable map. This is useful for
-     * cleaning up temporary flags, resetting certain game states, or managing
-     * memory by removing unused variables. The method returns a boolean indicating
-     * whether the variable existed and was successfully removed.
-     * 
-     * @param key - The variable identifier to remove
-     * @returns true if a variable existed and has been removed, false if the variable does not exist
-     * 
-     * @example
-     * ```ts
-     * // Remove variables and check if they existed
-     * const removed = player.removeVariable('CHEST_OPENED'); // true if existed
-     * const notFound = player.removeVariable('nonexistent'); // false
-     * 
-     * // Clean up temporary variables
-     * player.removeVariable('tempQuestFlag');
-     * player.removeVariable('battleTempData');
-     * 
-     * // Conditional removal
-     * if (player.getVariable('questCompleted')) {
-     *   player.removeVariable('questProgress');
-     * }
-     * ```
-     */
     removeVariable(key) {
       return this.variables.delete(key);
     }
-    /**
-     * Check if a variable exists
-     * 
-     * Determines whether a variable with the given key exists in the player's
-     * variable map, regardless of its value (including falsy values like false, 0, '').
-     * This is useful when you need to distinguish between a variable that doesn't
-     * exist and one that has a falsy value.
-     * 
-     * @param key - The variable identifier to check
-     * @returns true if the variable exists, false otherwise
-     * 
-     * @example
-     * ```ts
-     * // Check variable existence
-     * player.setVariable('flag', false);
-     * player.hasVariable('flag'); // true (even though value is false)
-     * player.hasVariable('missing'); // false
-     * 
-     * // Use in conditional logic
-     * if (player.hasVariable('questStarted')) {
-     *   // Quest has been started, check progress
-     *   const progress = player.getVariable('questProgress');
-     * } else {
-     *   // Quest not started yet
-     *   player.setVariable('questStarted', true);
-     * }
-     * ```
-     */
     hasVariable(key) {
       return this.variables.has(key);
     }
-    /**
-     * Get all variable keys
-     * 
-     * Returns an array of all variable keys currently stored for this player.
-     * This is useful for debugging, serialization, or iterating over all variables.
-     * The keys are returned in insertion order.
-     * 
-     * @returns Array of all variable keys
-     * 
-     * @example
-     * ```ts
-     * // Get all variable keys
-     * const keys = player.getVariableKeys();
-     * console.log('Player has variables:', keys);
-     * 
-     * // Iterate over all variables
-     * keys.forEach(key => {
-     *   const value = player.getVariable(key);
-     *   console.log(`${key}: ${value}`);
-     * });
-     * 
-     * // Filter specific variable types
-     * const questKeys = keys.filter(key => key.startsWith('quest_'));
-     * ```
-     */
     getVariableKeys() {
       return Array.from(this.variables.keys());
     }
-    /**
-     * Clear all variables
-     * 
-     * Removes all variables from the player's variable map. This is useful for
-     * resetting the player state, cleaning up before saving, or starting fresh.
-     * Use with caution as this operation cannot be undone.
-     * 
-     * @returns void
-     * 
-     * @example
-     * ```ts
-     * // Clear all variables (use with caution)
-     * player.clearVariables();
-     * 
-     * // Clear variables conditionally
-     * if (gameReset) {
-     *   player.clearVariables();
-     *   // Re-initialize essential variables
-     *   player.setVariable('gameStarted', true);
-     * }
-     * ```
-     */
     clearVariables() {
       this.variables.clear();
     }
@@ -21673,42 +21091,10 @@ class StateLog {
 
 function WithItemManager(Base) {
   return class extends Base {
-    /**
-     * Retrieves the information of an object: the number and the instance
-     * @title Get Item
-     * @method player.getItem(itemClass)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * player.addItem(Potion, 5)
-     * const inventory = player.getItem(Potion)
-     * console.log(inventory) // { nb: 5, item: <instance of Potion> }
-     *  ```
-     */
     getItem(itemClass) {
       const index = this._getItemIndex(itemClass);
       return this.items()[index];
     }
-    /**
-     * Check if the player has the item in his inventory.
-     * @title Has Item
-     * @method player.hasItem(itemClass)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @returns {boolean}
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * player.hasItem(Potion) // false
-     *  ```
-     */
     hasItem(itemClass) {
       return !!this.getItem(itemClass);
     }
@@ -21720,62 +21106,6 @@ function WithItemManager(Base) {
         return isInstanceOf(it, itemClass);
       });
     }
-    /**
-     * Add an item in the player's inventory. You can give more than one by specifying `nb`
-     *
-     * Supports three ways to add items:
-     * 1. **String**: Pass a string ID to retrieve the item from the database (requires item to be registered in `@RpgModule` database).
-     * 2. **Class**: Pass an item class (e.g., `Potion`). The class will be instantiated and automatically added to the map's database if not already present.
-     * 3. **Object**: Pass an item object with properties and hooks directly. The object will be automatically added to the map's database if not already present.
-     *
-     * For classes and objects, if they don't exist in the database, they are automatically added using `map.addInDatabase()`.
-     * This allows dynamic item creation without requiring pre-registration in the module database.
-     *
-     * `onAdd()` method is called on the ItemClass or ItemObject
-     *
-     * @title Add Item
-     * @method player.addItem(item,nb=1)
-     * @param {ItemClass | ItemObject | string} item - Item class, object, or string identifier
-     * @param {number} [nb] Default 1
-     * @returns {Item} The item instance added to inventory
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     * 
-     * // Using string ID (retrieves from database - item must be in @RpgModule database)
-     * player.addItem('Potion', 5)
-     * 
-     * // Using class (creates instance, auto-adds to map database if not present)
-     * player.addItem(Potion, 5)
-     * 
-     * // Using object directly (auto-adds to map database if not present)
-     * player.addItem({
-     *   id: 'custom-potion',
-     *   name: 'Custom Potion',
-     *   description: 'A custom potion',
-     *   price: 150,
-     *   hpValue: 50,
-     *   consumable: true,
-     *   onAdd(player) {
-     *     console.log('Custom potion added!');
-     *   },
-     *   onUse(player) {
-     *     player.hp += 50;
-     *   }
-     * }, 3)
-     * 
-     * // Object without ID (auto-generates ID and adds to database)
-     * player.addItem({
-     *   name: 'Dynamic Item',
-     *   price: 100,
-     *   onUse(player) {
-     *     console.log('Dynamic item used!');
-     *   }
-     * })
-     *  ```
-     */
     addItem(item, nb = 1) {
       const map = this.getCurrentMap();
       if (!map) {
@@ -21835,38 +21165,6 @@ function WithItemManager(Base) {
       this["execMethod"]("onAdd", [this], hookTarget);
       return instance;
     }
-    /**
-     * Deletes an item. Decreases the value `nb`. If the number falls to 0, then the item is removed from the inventory. The method then returns `undefined`
-     *
-     * `onRemove()` method is called on the ItemClass
-     *
-     * @title Remove Item
-     * @method player.removeItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
-     * @param {number} [nb] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass } | undefined}
-     * @throws {ItemLog} notInInventory
-     * If the object is not in the inventory, an exception is raised
-     *  ```
-     * {
-     *      id: ITEM_NOT_INVENTORY,
-     *      msg: '...'
-     * }
-     * ```
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *    player.removeItem(Potion, 5)
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
     removeItem(itemClass, nb = 1) {
       const itemIndex = this._getItemIndex(itemClass);
       if (itemIndex == -1) {
@@ -21883,50 +21181,6 @@ function WithItemManager(Base) {
       this["execMethod"]("onRemove", [this], hookTarget);
       return this.items()[itemIndex];
     }
-    /**
-     * Purchases an item and reduces the amount of gold
-     *
-     * `onAdd()` method is called on the ItemClass
-     *
-     * @title Buy Item
-     * @method player.buyItem(item,nb=1)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @param {number} [nb] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @throws {ItemLog} haveNotPrice
-     * If you have not set a price on the item
-     *  ```
-     * {
-     *      id: NOT_PRICE,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notEnoughGold
-     * If the player does not have enough money
-     *  ```
-     * {
-     *      id: NOT_ENOUGH_GOLD,
-     *      msg: '...'
-     * }
-     * ```
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *    // Using class
-     *    player.buyItem(Potion)
-     *    
-     *    // Using string ID
-     *    player.buyItem('Potion')
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
     buyItem(item, nb = 1) {
       let itemId;
       let data;
@@ -21956,58 +21210,6 @@ function WithItemManager(Base) {
       this._gold.update((gold) => gold - totalPrice);
       return this.addItem(item, nb);
     }
-    /**
-     * Sell an item and the player wins the amount of the item divided by 2
-     *
-     * `onRemove()` method is called on the ItemClass
-     *
-     * @title Sell Item
-     * @method player.sellItem(item,nb=1)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @param {number} [nbToSell] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @throws {ItemLog} haveNotPrice
-     * If you have not set a price on the item
-     *   ```
-     * {
-     *      id: NOT_PRICE,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notInInventory
-     * If the object is not in the inventory, an exception is raised
-     *  ```
-     * {
-     *      id: ITEM_NOT_INVENTORY,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} tooManyToSell
-     * If the number of items for sale exceeds the number of actual items in the inventory
-     *  ```
-     * {
-     *      id: TOO_MANY_ITEM_TO_SELL,
-     *      msg: '...'
-     * }
-     * ```
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *     player.addItem(Potion)
-     *     // Using class
-     *     player.sellItem(Potion)
-     *     // Using string ID
-     *     player.sellItem('Potion')
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
     sellItem(itemClass, nbToSell = 1) {
       const itemId = isString(itemClass) ? itemClass : itemClass.name;
       const data = this.databaseById(itemId);
@@ -22038,100 +21240,15 @@ function WithItemManager(Base) {
       }
       return nb;
     }
-    /**
-     * recover the attack sum of items equipped on the player.
-     *
-     * @title Get the player's attack
-     * @prop {number} player.atk
-     * @memberof ItemManager
-     */
     get atk() {
       return this.getParamItem(ATK);
     }
-    /**
-     * recover the physic defense sum of items equipped on the player.
-     *
-     * @title Get the player's pdef
-     * @prop {number} player.pdef
-     * @memberof ItemManager
-     */
     get pdef() {
       return this.getParamItem(PDEF);
     }
-    /**
-     * recover the skill defense sum of items equipped on the player.
-     *
-     * @title Get the player's sdef
-     * @prop {number} player.sdef
-     * @memberof ItemManager
-     */
     get sdef() {
       return this.getParamItem(SDEF);
     }
-    /**
-     *  Use an object. Applies effects and states. Removes the object from the inventory then
-     *
-     * `onUse()` method is called on the ItemClass (If the use has worked)
-     * `onRemove()` method is called on the ItemClass
-     *
-     * @title Use an Item
-     * @method player.useItem(item,nb=1)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @throws {ItemLog} restriction
-     * If the player has the `Effect.CAN_NOT_ITEM` effect
-     *   ```
-     * {
-     *      id: RESTRICTION_ITEM,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notInInventory
-     * If the object is not in the inventory, an exception is raised
-     *  ```
-     * {
-     *      id: ITEM_NOT_INVENTORY,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notUseItem
-     * If the `consumable` property is on false
-     *  ```
-     * {
-     *      id: NOT_USE_ITEM,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} chanceToUseFailed
-     * Chance to use the item has failed. Chances of use is defined with `ItemClass.hitRate`
-     *  ```
-     * {
-     *      id: USE_CHANCE_ITEM_FAILED,
-     *      msg: '...'
-     * }
-     * ```
-     * > the item is still deleted from the inventory
-     *
-     * `onUseFailed()` method is called on the ItemClass
-     *
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *     player.addItem(Potion)
-     *     // Using class
-     *     player.useItem(Potion)
-     *     // Using string ID
-     *     player.useItem('Potion')
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
     useItem(itemClass) {
       const itemId = isString(itemClass) ? itemClass : itemClass.name;
       const inventory = this.getItem(itemClass);
@@ -22158,58 +21275,6 @@ function WithItemManager(Base) {
       this.removeItem(itemClass);
       return inventory;
     }
-    /**
-     * Equips a weapon or armor on a player. Think first to add the item in the inventory with the `addItem()` method before equipping the item.
-     * 
-     * `onEquip()` method is called on the ItemClass
-     * 
-     * @title Equip Weapon or Armor
-     * @method player.equip(itemClass,equip=true)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @param {number} [equip] Equip the object if true or un-equipped if false
-     * @returns {void}
-     * @throws {ItemLog} notInInventory 
-     * If the item is not in the inventory
-     *  ```
-        {
-            id: ITEM_NOT_INVENTORY,
-            msg: '...'
-        }
-        ```
-     * @throws {ItemLog} invalidToEquiped 
-        If the item is not by a weapon or armor
-        ```
-        {
-            id: INVALID_ITEM_TO_EQUIP,
-            msg: '...'
-        }
-        ```
-    * @throws {ItemLog} isAlreadyEquiped 
-        If the item Is already equipped
-        ```
-        {
-            id: ITEM_ALREADY_EQUIPED,
-            msg: '...'
-        }
-        ```
-     * @memberof ItemManager
-     * @example
-     * 
-     * ```ts
-     * import Sword from 'your-database/sword'
-     * 
-     * try {
-     *      player.addItem(Sword)
-     *      // Using class
-     *      player.equip(Sword)
-     *      // Using string ID
-     *      player.equip('Sword')
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
     equip(itemClass, equip = true) {
       const itemId = isString(itemClass) ? itemClass : itemClass.name;
       const inventory = this.getItem(itemClass);
@@ -22259,69 +21324,9 @@ var Effect = /* @__PURE__ */ ((Effect2) => {
 })(Effect || {});
 function WithEffectManager(Base) {
   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) {
       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() {
       const getEffects = (prop) => {
         return arrayFlat(this[prop]().map((el) => el.effects || []));
@@ -22332,39 +21337,6 @@ function WithEffectManager(Base) {
         ...getEffects("equipments")
       ]);
     }
-    /**
-     * 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);
     }
@@ -22377,101 +21349,15 @@ function WithElementManager(Base) {
       super(...arguments);
       this._elementsEfficiency = [];
     }
-    /**
-     * 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'
-     *
-     * enum Elements {
-     *   Fire = 'fire'
-     * }
-     *
-     * @Armor({
-     *      name: 'Shield',
-     *      elementsDefense: [{ rate: 1, element: Elements.Fire }]
-     * })
-     * class Shield {}
-     *
-     * @Armor({
-     *      name: 'FireShield',
-     *      elementsDefense: [{ rate: 0.5, element: Elements.Fire }]
-     * })
-     * class FireShield {}
-     *
-     * player.addItem(Shield)
-     * player.addItem(FireShield)
-     * player.equip(Shield)
-     * 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}`);
-     * }
-     * ```
-     */
     get elementsDefense() {
       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'
-     *
-     * enum Elements {
-     *   Fire = 'fire',
-     *   Ice = 'ice'
-     * }
-     *
-     * @Class({
-     *      name: 'Fighter',
-     *      elementsEfficiency: [{ rate: 1, element: Elements.Fire }]
-     * })
-     * class Hero {}
-     *
-     * player.setClass(Hero)
-     *
-     * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }]
-     *
-     * 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));
-     * ```
-     */
     get elementsEfficiency() {
       if (this._class()) {
+        const classData = this._class();
         return [
           ...this._elementsEfficiency,
-          ...this._class()?.elementsEfficiency || []
+          ...classData?.elementsEfficiency || []
         ];
       }
       return this._elementsEfficiency;
@@ -22479,33 +21365,6 @@ function WithElementManager(Base) {
     set elementsEfficiency(val) {
       this._elementsEfficiency = val;
     }
-    /**
-     * 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})`);
-     * ```
-     */
     get elements() {
       let elements = [];
       for (let item of this.equipments()) {
@@ -22515,40 +21374,6 @@ function WithElementManager(Base) {
       }
       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) {
       const atkPlayerElements = otherPlayer.elements;
       const playerElements = this.elementsEfficiency;
@@ -22589,49 +21414,10 @@ function WithSkillManager(Base) {
         return isInstanceOf(skill, skillClass);
       });
     }
-    /**
-     * Retrieves a learned skill. Returns null, if not found
-     * ```ts
-     * import Fire from 'your-database/skills/fire'
-     *
-     * player.getSkill(Fire)
-     *  ```
-     *
-     * @title Get Skill
-     * @method player.getSkill(skillClass)
-     * @param {SkillClass | string} skillClass or data id
-     * @returns {instance of SkillClass | null}
-     * @memberof SkillManager
-     */
     getSkill(skillClass) {
       const index = this._getSkillIndex(skillClass);
       return this.skills()[index] ?? null;
     }
-    /**
-         * Learn a skill. Attributes the coefficient 1 to the parameter INT (intelligence) if cd is not present on the class.
-         * 
-         * `onLearn()` method is called on the SkillClass
-         * 
-         * ```ts
-         * import Fire from 'your-database/skills/fire'
-         * 
-         * player.learnSkill(Fire)
-         *  ```
-         * 
-         * @title Learn Skill
-         * @method player.learnSkill(skillClass)
-         * @param {SkillClass | string} skillId or data id
-         * @throws {SkillLog} alreadyLearned
-         *  If the player already knows the skill
-         *  ```
-            {
-                id: SKILL_ALREADY_LEARNED,
-                msg: '...'
-            }
-            ```
-         * @returns {instance of SkillClass}
-         * @memberof SkillManager
-         */
     learnSkill(skillId) {
       if (this.getSkill(skillId)) {
         throw SkillLog.alreadyLearned(skillId);
@@ -22640,37 +21426,7 @@ function WithSkillManager(Base) {
       this.skills().push(instance);
       this["execMethod"]("onLearn", [this], instance);
       return instance;
-    }
-    /**
-     * Forget a skill
-     *
-     * `onForget()` method is called on the SkillClass
-     *
-     * ```ts
-     * import Fire from 'your-database/skills/fire'
-     *
-     * try {
-     *      player.forgetSkill(Fire)
-     * }
-     * catch (err) {
-     *      console.log(err)
-     * }
-     *  ```
-     *
-     * @title Forget Skill
-     * @method player.learnSkill(skillClass)
-     * @param {SkillClass | string} skillId or data id
-     * @throws {SkillLog} notLearned
-     * If trying to forget a skill not learned
-     *  ```
-     * {
-     *      id: SKILL_NOT_LEARNED,
-     *      msg: '...'
-     * }
-     * ```
-     * @returns {instance of SkillClass}
-     * @memberof SkillManager
-     */
+    }
     forgetSkill(skillId) {
       if (isString(skillId)) skillId = this.databaseById(skillId);
       const index = this._getSkillIndex(skillId);
@@ -22682,81 +21438,6 @@ function WithSkillManager(Base) {
       this["execMethod"]("onForget", [this], instance);
       return instance;
     }
-    /**
-     * Using a skill
-     *
-     * `onUse()` method is called on the SkillClass
-     *
-     * If other players are indicated then damage will be done to these other players. The method `applyDamage()` will be executed
-     *
-     * ```ts
-     * import Fire from 'your-database/skills/fire'
-     *
-     * try {
-     *      player.useSkill(Fire)
-     * }
-     * catch (err) {
-     *      console.log(err)
-     * }
-     *  ```
-     *
-     * or
-     *
-     *
-     * * ```ts
-     * import Fire from 'your-database/skills/fire'
-     *
-     * try {
-     *      player.useSkill(Fire, otherPlayer)
-     * }
-     * catch (err) {
-     *      console.log(err)
-     * }
-     *  ```
-     *
-     * @title Use Skill
-     * @method player.useSkill(skillClass,otherPlayer)
-     * @param {SkillClass | string} skillId or data id
-     * @param {Array<RpgPlayer> | RpgPlayer} [otherPlayer]
-     * @throws {SkillLog} restriction
-     * If the player has the `Effect.CAN_NOT_SKILL` effect
-     *  ```
-     * {
-     *      id: RESTRICTION_SKILL,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {SkillLog} notLearned
-     * If the player tries to use an unlearned skill
-     *  ```
-     * {
-     *      id: SKILL_NOT_LEARNED,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {SkillLog} notEnoughSp
-     * If the player does not have enough SP to use the skill
-     *  ```
-     * {
-     *      id: NOT_ENOUGH_SP,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {SkillLog} chanceToUseFailed
-     * If the chance to use the skill has failed (defined with the `hitRate` property)
-     *  ```
-     * {
-     *      id: USE_CHANCE_SKILL_FAILED,
-     *      msg: '...'
-     * }
-     * ```
-     *
-     * `onUseFailed()` method is called on the SkillClass
-     *
-     * @returns {instance of SkillClass}
-     * @memberof SkillManager
-     * @todo
-     */
     useSkill(skillId, otherPlayer) {
       const skill = this.getSkill(skillId);
       if (this.hasEffect(Effect.CAN_NOT_SKILL)) {
@@ -22792,42 +21473,11 @@ function WithSkillManager(Base) {
 
 function WithBattleManager(Base) {
   return class extends Base {
-    /**
-     * 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.
-     * The attack formula is already defined but you can customize it in the server options.
-     * This method handles all aspects of damage calculation including critical hits,
-     * elemental vulnerabilities, guard effects, and applies the final damage to HP.
-     *
-     * @param attackerPlayer - The attacking player who deals the damage
-     * @param skill - Optional skill object for magical attacks, if not provided uses physical attack
-     * @returns Object containing damage details and special effects that occurred
-     * 
-     * @example
-     * ```ts
-     * // Physical attack
-     * const result = player.applyDamage(attackerPlayer);
-     * console.log(`Physical damage: ${result.damage}, Critical: ${result.critical}`);
-     * 
-     * // Magical attack with skill
-     * const fireSkill = { id: 'fire', power: 50, element: 'fire' };
-     * const magicResult = player.applyDamage(attackerPlayer, fireSkill);
-     * console.log(`Magic damage: ${magicResult.damage}, Vulnerable: ${magicResult.elementVulnerable}`);
-     * 
-     * // Check for guard effects
-     * if (result.guard) {
-     *   console.log('Attack was partially blocked!');
-     * }
-     * if (result.superGuard) {
-     *   console.log('Attack was heavily reduced by super guard!');
-     * }
-     * ```
-     */
     applyDamage(attackerPlayer, skill) {
+      const self = this;
       const getParam = (player) => {
         const params = {};
-        this.parameters.forEach((val, key) => {
+        Object.keys(self.parameters).forEach((key) => {
           params[key] = player.param[key];
         });
         return {
@@ -22843,26 +21493,25 @@ function WithBattleManager(Base) {
       let superGuard = false;
       let elementVulnerable = false;
       const paramA = getParam(attackerPlayer);
-      const paramB = getParam(this);
-      console.log(paramA, paramB);
+      const paramB = getParam(self);
       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.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) {
@@ -22871,8 +21520,8 @@ function WithBattleManager(Base) {
           damage = newDamage;
         }
       }
-      if (this.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) {
@@ -22881,11 +21530,11 @@ function WithBattleManager(Base) {
           damage = newDamage;
         }
       }
-      if (this.hasEffect(Effect.SUPER_GUARD)) {
+      if (self.hasEffect(Effect.SUPER_GUARD)) {
         damage /= 4;
         superGuard = true;
       }
-      this.hp -= damage;
+      self.hp -= damage;
       return {
         damage,
         critical,
@@ -22921,87 +21570,21 @@ function WithBattleManager(Base) {
      * ```
      */
     getFormulas(name) {
-      const map = this.getCurrentMap();
-      return map.damageFormulas[name];
+      const self = this;
+      const map = self.getCurrentMap();
+      return map?.damageFormulas[name];
     }
   };
 }
 
 function WithClassManager(Base) {
   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) {
       if (isString(_class)) _class = this.databaseById(_class);
       const classInstance = new _class();
       this["execMethod"]("onSet", [this], classInstance);
       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) {
       if (isString(actorClass)) actorClass = this.databaseById(actorClass);
       const actor = new actorClass();
@@ -23028,137 +21611,15 @@ function WithStateManager(Base) {
       super(...arguments);
       this._statesEfficiency = signal$1([]);
     }
-    /**
-     * Recovers the player's states defense on inventory.  This list is generated from the `statesDefense` 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 states from equipped items.
-     * The system automatically consolidates multiple defensive items, keeping only
-     * the highest protection rate for each state type. This provides comprehensive
-     * protection against debuffs and negative status effects.
-     * 
-     * @returns Array of state defense objects with rate and state properties
-     * 
-     * @example
-     * ```ts
-     * import { Armor, State } from '@rpgjs/server'
-     *
-     * @State({
-     *      name: 'Paralyze'
-     * })
-     * class Paralyze {}
-     *
-     * @Armor({
-     *      name: 'Shield',
-     *      statesDefense: [{ rate: 1, state: Paralyze }]
-     * })
-     * class Shield {}
-     *
-     * @Armor({
-     *      name: 'FireShield',
-     *      statesDefense: [{ rate: 0.5, state: Paralyze }]
-     * })
-     * class FireShield {}
-     *
-     * player.addItem(Shield)
-     * player.addItem(FireShield)
-     * player.equip(Shield)
-     * player.equip(FireShield)
-     *
-     * console.log(player.statesDefense) // [{ rate: 1, state: instance of Paralyze }]
-     * 
-     * // Check specific state defense
-     * const paralyzeDefense = player.statesDefense.find(def => def.state instanceof Paralyze);
-     * if (paralyzeDefense) {
-     *   console.log(`Paralyze defense rate: ${paralyzeDefense.rate}`);
-     * }
-     * ```
-     */
     get statesDefense() {
       return this.getFeature("statesDefense", "state");
     }
-    /**
-     * Set or retrieves all the states where the player is vulnerable or not.
-     *
-     * Manages the player's state efficiency modifiers, which determine how
-     * effective different states 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 state efficiency objects with rate and state properties
-     * 
-     * @example
-     * ```ts
-     * import { Class, State } from '@rpgjs/server'
-     *
-     * @State({
-     *      name: 'Paralyze'
-     * })
-     * class Paralyze {}
-     *
-     * @State({
-     *      name: 'Sleep'
-     * })
-     * class Sleep {}
-     *
-     * @Class({
-     *      name: 'Fighter',
-     *      statesEfficiency: [{ rate: 1, state: Paralyze }]
-     * })
-     * class Hero {}
-     *
-     * player.setClass(Hero)
-     *
-     * console.log(player.statesEfficiency) // [{ rate: 1, instance of Paralyze }]
-     *
-     * player.statesEfficiency = [{ rate: 2, state: Sleep }]
-     *
-     * console.log(player.statesEfficiency) // [{ rate: 1, state: instance of Paralyze }, { rate: 2, state: instance of Sleep }]
-     * 
-     * // Check for vulnerabilities
-     * const vulnerabilities = player.statesEfficiency.filter(eff => eff.rate > 1);
-     * console.log('Vulnerable to states:', vulnerabilities.map(v => v.state.name));
-     * 
-     * // Check for resistances
-     * const resistances = player.statesEfficiency.filter(eff => eff.rate < 1);
-     * console.log('Resistant to states:', resistances.map(r => r.state.name));
-     * ```
-     */
     get statesEfficiency() {
       return this._statesEfficiency;
     }
     set statesEfficiency(val) {
       this._statesEfficiency = val;
     }
-    /**
-     * Apply states to a player from skill or item effects
-     * 
-     * Processes state application and removal based on skill or item effects.
-     * This method handles both adding beneficial states and removing negative ones,
-     * with proper chance calculation and resistance checks.
-     * 
-     * @param player - The target player to apply states to
-     * @param states - Object containing arrays of states to add or remove
-     * 
-     * @example
-     * ```ts
-     * // Apply states from a healing skill
-     * const healingStates = {
-     *   addStates: [{ state: Regeneration, rate: 0.8 }],
-     *   removeStates: [{ state: Poison, rate: 1.0 }]
-     * };
-     * player.applyStates(targetPlayer, healingStates);
-     * 
-     * // Apply debuff from an enemy attack
-     * const debuffStates = {
-     *   addStates: [
-     *     { state: Paralyze, rate: 0.3 },
-     *     { state: Slow, rate: 0.5 }
-     *   ]
-     * };
-     * player.applyStates(targetPlayer, debuffStates);
-     * ```
-     */
     applyStates(player, { addStates, removeStates }) {
       if (addStates) {
         for (let { state, rate } of addStates) {
@@ -23171,40 +21632,6 @@ function WithStateManager(Base) {
         }
       }
     }
-    /**
-     * Get a state to the player. Returns `null` if the state is not present on the player
-     * 
-     * Retrieves a specific state instance from the player's active states.
-     * This is useful for checking state properties, duration, or performing
-     * state-specific operations. Returns null if the state is not currently active.
-     * 
-     * @param stateClass - The state class constructor or state ID to search for
-     * @returns The state instance if found, null otherwise
-     * 
-     * @example
-     * ```ts
-     * import Paralyze from 'your-database/states/paralyze'
-     *
-     * // Check if player has a specific state
-     * const paralyzeState = player.getState(Paralyze);
-     * if (paralyzeState) {
-     *   console.log('Player is paralyzed');
-     *   console.log('Remaining duration:', paralyzeState.duration);
-     * }
-     * 
-     * // Check using string ID
-     * const poisonState = player.getState('poison');
-     * if (poisonState) {
-     *   console.log('Player is poisoned');
-     * }
-     * 
-     * // Use in conditional logic
-     * if (player.getState(Sleep)) {
-     *   console.log('Player cannot act while sleeping');
-     *   return; // Skip player turn
-     * }
-     * ```
-     */
     getState(stateClass) {
       if (isString(stateClass)) stateClass = this.databaseById(stateClass);
       return this.states().find((state) => {
@@ -23214,54 +21641,6 @@ function WithStateManager(Base) {
         return isInstanceOf(state, stateClass);
       });
     }
-    /**
-     * Adds a state to the player. Set the chance between 0 and 1 that the state can apply
-     * 
-     * Attempts to apply a state to the player with a specified success chance.
-     * The method considers state resistance, efficiency modifiers, and random chance
-     * to determine if the state is successfully applied. If successful, the state
-     * is added to the player's active states list.
-     * 
-     * @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
-     * 
-     * @example
-     * ```ts
-     * import Paralyze from 'your-database/states/paralyze'
-     *
-     * try {
-     *   // Attempt to apply paralyze with 100% chance
-     *   const state = player.addState(Paralyze);
-     *   if (state) {
-     *     console.log('Paralyze applied successfully');
-     *   }
-     * } catch (err) {
-     *   console.log('Failed to apply paralyze:', err.msg);
-     * }
-     * 
-     * // Apply with reduced chance
-     * try {
-     *   player.addState(Poison, 0.3); // 30% chance
-     * } catch (err) {
-     *   console.log('Poison application failed');
-     * }
-     * 
-     * // Apply multiple states with different chances
-     * const debuffs = [
-     *   { state: Slow, chance: 0.8 },
-     *   { state: Weak, chance: 0.6 }
-     * ];
-     * debuffs.forEach(({ state, chance }) => {
-     *   try {
-     *     player.addState(state, chance);
-     *   } catch (err) {
-     *     // Handle failed applications
-     *   }
-     * });
-     * ```
-     */
     addState(stateClass, chance = 1) {
       const state = this.getState(stateClass);
       if (isString(stateClass)) {
@@ -23278,52 +21657,6 @@ function WithStateManager(Base) {
       }
       return null;
     }
-    /**
-     * Remove a state to the player. Set the chance between 0 and 1 that the state can be removed
-     * 
-     * Attempts to remove a state from the player with a specified success chance.
-     * This is useful for cure spells, items, or time-based state removal.
-     * The method considers removal resistance and random chance.
-     * 
-     * @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
-     * 
-     * @example
-     * ```ts
-     * import Paralyze from 'your-database/states/paralyze'
-     *
-     * try {
-     *   // Attempt to remove paralyze with 100% chance
-     *   player.removeState(Paralyze);
-     *   console.log('Paralyze removed successfully');
-     * } catch (err) {
-     *   if (err.id === 'STATE_NOT_APPLIED') {
-     *     console.log('Player was not paralyzed');
-     *   } else {
-     *     console.log('Failed to remove paralyze:', err.msg);
-     *   }
-     * }
-     * 
-     * // Remove with reduced chance (for weak cure spells)
-     * try {
-     *   player.removeState(Poison, 0.7); // 70% chance
-     * } catch (err) {
-     *   console.log('Cure failed');
-     * }
-     * 
-     * // Remove all negative states (cure-all effect)
-     * const negativeStates = [Poison, Paralyze, Sleep, Slow];
-     * negativeStates.forEach(state => {
-     *   try {
-     *     player.removeState(state);
-     *   } catch (err) {
-     *     // State wasn't active, continue
-     *   }
-     * });
-     * ```
-     */
     removeState(stateClass, chance = 1) {
       const index = this.states().findIndex((state) => {
         if (isString(stateClass)) {
@@ -23340,12 +21673,6 @@ function WithStateManager(Base) {
         throw StateLog.notApplied(stateClass);
       }
     }
-    /**
-     * 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) {
       return this.statesEfficiency().find(
         (state) => isInstanceOf(state.state, stateClass)
@@ -23443,6 +21770,10 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   get hooks() {
     return inject$1(this.context, ModulesToken);
   }
+  // compatibility with v4
+  get server() {
+    return this.map;
+  }
   applyFrames() {
     this._frames.set(this.frames);
     this.frames = [];
@@ -24034,6 +22365,186 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     };
     this.emit("stopSound", data);
   }
+  /**
+   * 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() {
+    const map2 = this.getCurrentMap();
+    if (!map2) return;
+    this.emit("stopAllSounds", {});
+  }
+  /**
+   * 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, options) {
+    const map2 = this.getCurrentMap();
+    if (!map2) return;
+    const data = {
+      targetId: otherPlayer.id
+    };
+    if (options?.smoothMove !== void 0) {
+      if (typeof options.smoothMove === "boolean") {
+        data.smoothMove = options.smoothMove;
+      } else {
+        data.smoothMove = {
+          enabled: true,
+          ...options.smoothMove
+        };
+      }
+    } else {
+      data.smoothMove = true;
+    }
+    this.emit("cameraFollow", data);
+  }
+  /**
+   * 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) {
+    const map2 = this.getCurrentMap();
+    if (!map2) return;
+    const flashOptions = {
+      type: options?.type || "alpha",
+      duration: options?.duration ?? 300,
+      cycles: options?.cycles ?? 1,
+      alpha: options?.alpha ?? 0.3,
+      tint: options?.tint ?? 16777215
+    };
+    map2.$broadcast({
+      type: "flash",
+      value: {
+        object: this.id,
+        ...flashOptions
+      }
+    });
+  }
+  /**
+   * 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, height) {
+    if (typeof width !== "number" || width <= 0) {
+      throw new Error("setHitbox: width must be a positive number");
+    }
+    if (typeof height !== "number" || height <= 0) {
+      throw new Error("setHitbox: height must be a positive number");
+    }
+    this.hitbox.set({
+      w: width,
+      h: height
+    });
+    const map2 = this.getCurrentMap();
+    if (map2 && map2.physic) {
+      const topLeftX = this.x();
+      const topLeftY = this.y();
+      map2.updateHitbox(this.id, topLeftX, topLeftY, width, height);
+    }
+  }
   /**
    * Set the sync schema for the map
    * @param schema - The schema to set
@@ -27587,10 +26098,72 @@ let RpgMap = class extends RpgCommonMap {
     super();
     this.players = signal$1({});
     this.events = signal$1({});
+    /** 
+     * Signal containing the map's database of items, classes, and other game data
+     * 
+     * This database can be dynamically populated using `addInDatabase()` and
+     * `removeInDatabase()` methods. It's used to store game entities like items,
+     * classes, skills, etc. that are specific to this map.
+     * 
+     * @example
+     * ```ts
+     * // Add data to database
+     * map.addInDatabase('Potion', PotionClass);
+     * 
+     * // Access database
+     * const potion = map.database()['Potion'];
+     * ```
+     */
     this.database = signal$1({});
+    /** 
+     * Array of map configurations - can contain MapOptions objects or instances of map classes
+     * 
+     * This array stores the configuration for this map and any related maps.
+     * It's populated when the map is loaded via `updateMap()`.
+     */
     this.maps = [];
+    /** 
+     * Array of sound IDs to play when players join the map
+     * 
+     * These sounds are automatically played for each player when they join the map.
+     * Sounds must be defined on the client side.
+     * 
+     * @example
+     * ```ts
+     * // Set sounds for the map
+     * map.sounds = ['background-music', 'ambient-forest'];
+     * ```
+     */
+    this.sounds = [];
+    /** 
+     * BehaviorSubject that completes when the map data is ready
+     * 
+     * This subject is used to signal when the map has finished loading all its data.
+     * Players wait for this to complete before the map is fully initialized.
+     * 
+     * @example
+     * ```ts
+     * // Wait for map data to be ready
+     * map.dataIsReady$.subscribe(() => {
+     *   console.log('Map is ready!');
+     * });
+     * ```
+     */
     this.dataIsReady$ = new BehaviorSubject$1(void 0);
+    /** 
+     * Global configuration object for the map
+     * 
+     * This object contains configuration settings that apply to the entire map.
+     * It's populated from the map data when `updateMap()` is called.
+     */
     this.globalConfig = {};
+    /** 
+     * Damage formulas configuration for the map
+     * 
+     * Contains formulas for calculating damage from skills, physical attacks,
+     * critical hits, and element coefficients. Default formulas are merged
+     * with custom formulas when the map is loaded.
+     */
     this.damageFormulas = {};
     /** Internal: Map of shapes by name */
     this._shapes = /* @__PURE__ */ new Map();
@@ -27712,7 +26285,31 @@ let RpgMap = class extends RpgCommonMap {
       activeCollisions.delete(collisionKey);
     });
   }
-  // autoload by @signe/room
+  /**
+   * Intercepts and modifies packets before they are sent to clients
+   * 
+   * This method is automatically called by @signe/room for each packet sent to clients.
+   * It adds timestamp and acknowledgment information to sync packets for client-side
+   * prediction reconciliation. This helps with network synchronization and reduces
+   * perceived latency.
+   * 
+   * ## Architecture
+   * 
+   * Adds metadata to packets:
+   * - `timestamp`: Current server time for client-side prediction
+   * - `ack`: Acknowledgment info with last processed frame and authoritative position
+   * 
+   * @param player - The player receiving the packet
+   * @param packet - The packet data to intercept
+   * @param conn - The connection object
+   * @returns Modified packet with timestamp and ack info, or null if player is invalid
+   * 
+   * @example
+   * ```ts
+   * // This method is called automatically by the framework
+   * // You typically don't call it directly
+   * ```
+   */
   interceptorPacket(player, packet, conn) {
     let obj = {};
     if (!player) {
@@ -27741,37 +26338,174 @@ let RpgMap = class extends RpgCommonMap {
       }
     };
   }
+  /**
+   * Called when a player joins the map
+   * 
+   * This method is automatically called by @signe/room when a player connects to the map.
+   * It initializes the player's connection, sets up the map context, and waits for
+   * the map data to be ready before playing sounds and triggering hooks.
+   * 
+   * ## Architecture
+   * 
+   * 1. Sets player's map reference and context
+   * 2. Initializes the player
+   * 3. Waits for map data to be ready
+   * 4. Plays map sounds for the player
+   * 5. Triggers `server-player-onJoinMap` hook
+   * 
+   * @param player - The player joining the map
+   * @param conn - The connection object for the player
+   * 
+   * @example
+   * ```ts
+   * // This method is called automatically by the framework
+   * // You can listen to the hook to perform custom logic
+   * server.addHook('server-player-onJoinMap', (player, map) => {
+   *   console.log(`Player ${player.id} joined map ${map.id}`);
+   * });
+   * ```
+   */
   onJoin(player, conn) {
     player.map = this;
     player.context = context$1;
     player.conn = conn;
     player._onInit();
     this.dataIsReady$.pipe(
-      finalize$1(() => {
-        this.hooks.callHooks("server-player-onJoinMap", player, this).subscribe();
+      finalize$1(async () => {
+        if (this.stopAllSoundsBeforeJoin) {
+          player.stopAllSounds();
+        }
+        this.sounds.forEach((sound) => player.playSound(sound, { loop: true }));
+        await lastValueFrom(this.hooks.callHooks("server-map-onJoin", player, this));
+        if (typeof this._onJoin === "function") {
+          await this._onJoin(player);
+        }
+        await lastValueFrom(this.hooks.callHooks("server-player-onJoinMap", player, this));
       })
     ).subscribe();
   }
-  onLeave(player, conn) {
-    this.hooks.callHooks("server-player-onLeaveMap", player, this).subscribe();
+  /**
+   * Called when a player leaves the map
+   * 
+   * This method is automatically called by @signe/room when a player disconnects from the map.
+   * It cleans up the player's pending inputs and triggers the appropriate hooks.
+   * 
+   * ## Architecture
+   * 
+   * 1. Triggers `server-player-onLeaveMap` hook
+   * 2. Clears pending inputs to prevent processing after disconnection
+   * 
+   * @param player - The player leaving the map
+   * @param conn - The connection object for the player
+   * 
+   * @example
+   * ```ts
+   * // This method is called automatically by the framework
+   * // You can listen to the hook to perform custom cleanup
+   * server.addHook('server-player-onLeaveMap', (player, map) => {
+   *   console.log(`Player ${player.id} left map ${map.id}`);
+   * });
+   * ```
+   */
+  async onLeave(player, conn) {
+    await lastValueFrom(this.hooks.callHooks("server-map-onLeave", player, this));
+    if (typeof this._onLeave === "function") {
+      await this._onLeave(player);
+    }
+    await lastValueFrom(this.hooks.callHooks("server-player-onLeaveMap", player, this));
     player.pendingInputs = [];
   }
+  /**
+   * Get the hooks system for this map
+   * 
+   * Returns the dependency-injected Hooks instance that allows you to trigger
+   * and listen to various game events.
+   * 
+   * @returns The Hooks instance for this map
+   * 
+   * @example
+   * ```ts
+   * // Trigger a custom hook
+   * map.hooks.callHooks('custom-event', data).subscribe();
+   * ```
+   */
   get hooks() {
     return inject$1(context$1, ModulesToken);
   }
+  /**
+   * Get the width of the map in pixels
+   * 
+   * @returns The width of the map in pixels, or 0 if not loaded
+   * 
+   * @example
+   * ```ts
+   * const width = map.widthPx;
+   * console.log(`Map width: ${width}px`);
+   * ```
+   */
   get widthPx() {
     return this.data()?.width ?? 0;
   }
+  /**
+   * Get the height of the map in pixels
+   * 
+   * @returns The height of the map in pixels, or 0 if not loaded
+   * 
+   * @example
+   * ```ts
+   * const height = map.heightPx;
+   * console.log(`Map height: ${height}px`);
+   * ```
+   */
   get heightPx() {
     return this.data()?.height ?? 0;
   }
+  /**
+   * Get the unique identifier of the map
+   * 
+   * @returns The map ID, or empty string if not loaded
+   * 
+   * @example
+   * ```ts
+   * const mapId = map.id;
+   * console.log(`Current map: ${mapId}`);
+   * ```
+   */
   get id() {
     return this.data()?.id ?? "";
   }
+  /**
+   * Get the X position of this map in the world coordinate system
+   * 
+   * This is used when maps are part of a larger world map. The world position
+   * indicates where this map is located relative to other maps.
+   * 
+   * @returns The X position in world coordinates, or 0 if not in a world
+   * 
+   * @example
+   * ```ts
+   * const worldX = map.worldX;
+   * console.log(`Map is at world position (${worldX}, ${map.worldY})`);
+   * ```
+   */
   get worldX() {
     const worldMaps = this.getWorldMapsManager?.();
     return worldMaps?.getMapInfo(this.id)?.worldX ?? 0;
   }
+  /**
+   * Get the Y position of this map in the world coordinate system
+   * 
+   * This is used when maps are part of a larger world map. The world position
+   * indicates where this map is located relative to other maps.
+   * 
+   * @returns The Y position in world coordinates, or 0 if not in a world
+   * 
+   * @example
+   * ```ts
+   * const worldY = map.worldY;
+   * console.log(`Map is at world position (${map.worldX}, ${worldY})`);
+   * ```
+   */
   get worldY() {
     const worldMaps = this.getWorldMapsManager?.();
     return worldMaps?.getMapInfo(this.id)?.worldY ?? 0;
@@ -27828,6 +26562,26 @@ let RpgMap = class extends RpgCommonMap {
           ...map.events
         ];
       }
+      if (mapFound?.sounds) {
+        this.sounds = [
+          ...map.sounds ?? [],
+          ...mapFound.sounds
+        ];
+      } else {
+        this.sounds = map.sounds ?? [];
+      }
+      if (mapFound?.onLoad) {
+        this._onLoad = mapFound.onLoad;
+      }
+      if (mapFound?.onJoin) {
+        this._onJoin = mapFound.onJoin;
+      }
+      if (mapFound?.onLeave) {
+        this._onLeave = mapFound.onLeave;
+      }
+      if (mapFound?.stopAllSoundsBeforeJoin !== void 0) {
+        this.stopAllSoundsBeforeJoin = mapFound.stopAllSoundsBeforeJoin;
+      }
     }
     await lastValueFrom(this.hooks.callHooks("server-map-onBeforeUpdate", map, this));
     this.loadPhysic();
@@ -27835,6 +26589,10 @@ let RpgMap = class extends RpgCommonMap {
       await this.createDynamicEvent(event);
     }
     this.dataIsReady$.complete();
+    await lastValueFrom(this.hooks.callHooks("server-map-onLoad", this));
+    if (typeof this._onLoad === "function") {
+      await this._onLoad();
+    }
   }
   async updateWorld(request) {
     let worldId = "";
@@ -27972,6 +26730,26 @@ let RpgMap = class extends RpgCommonMap {
       inputs: processedInputs
     };
   }
+  /**
+   * Main game loop that processes player inputs
+   * 
+   * This private method runs continuously every 50ms to process pending inputs
+   * for all players on the map. It ensures inputs are processed in order and
+   * prevents concurrent processing for the same player.
+   * 
+   * ## Architecture
+   * 
+   * - Runs every 50ms for responsive input processing
+   * - Processes inputs for each player with pending inputs
+   * - Uses a flag to prevent concurrent processing for the same player
+   * - Calls `processInput()` to handle anti-cheat validation and movement
+   * 
+   * @example
+   * ```ts
+   * // This method is called automatically in the constructor
+   * // You typically don't call it directly
+   * ```
+   */
   loop() {
     setInterval(async () => {
       for (const player of this.getPlayers()) {
@@ -27988,7 +26766,21 @@ let RpgMap = class extends RpgCommonMap {
     }, 50);
   }
   /**
-   * Get a world manager by id (if multiple supported in future)
+   * Get a world manager by id
+   * 
+   * Returns the world maps manager for the given world ID. Currently, only
+   * one world manager is supported per map instance.
+   * 
+   * @param id - The world ID (currently unused, returns the single manager)
+   * @returns The WorldMapsManager instance, or null if not initialized
+   * 
+   * @example
+   * ```ts
+   * const worldManager = map.getWorldMaps('my-world');
+   * if (worldManager) {
+   *   const mapInfo = worldManager.getMapInfo('map1');
+   * }
+   * ```
    */
   getWorldMaps(id) {
     if (!this.worldMapsManager) return null;
@@ -27996,6 +26788,20 @@ let RpgMap = class extends RpgCommonMap {
   }
   /**
    * Delete a world manager by id
+   * 
+   * Removes the world maps manager from this map instance. Currently, only
+   * one world manager is supported, so this clears the single manager.
+   * 
+   * @param id - The world ID (currently unused)
+   * @returns true if the manager was deleted, false if it didn't exist
+   * 
+   * @example
+   * ```ts
+   * const deleted = map.deleteWorldMaps('my-world');
+   * if (deleted) {
+   *   console.log('World manager removed');
+   * }
+   * ```
    */
   deleteWorldMaps(id) {
     if (!this.worldMapsManager) return false;
@@ -28004,6 +26810,26 @@ let RpgMap = class extends RpgCommonMap {
   }
   /**
    * Create a world manager dynamically
+   * 
+   * Creates a new WorldMapsManager instance and configures it with the provided
+   * map configurations. This is used when loading world data from Tiled or
+   * other map editors.
+   * 
+   * @param world - World configuration object
+   * @param world.id - Optional world identifier
+   * @param world.maps - Array of map configurations for the world
+   * @returns The newly created WorldMapsManager instance
+   * 
+   * @example
+   * ```ts
+   * const manager = map.createDynamicWorldMaps({
+   *   id: 'my-world',
+   *   maps: [
+   *     { id: 'map1', worldX: 0, worldY: 0, width: 800, height: 600 },
+   *     { id: 'map2', worldX: 800, worldY: 0, width: 800, height: 600 }
+   *   ]
+   * });
+   * ```
    */
   createDynamicWorldMaps(world) {
     const manager = new WorldMapsManager();
@@ -28013,6 +26839,22 @@ let RpgMap = class extends RpgCommonMap {
   }
   /**
    * Update world maps by id. Auto-create when missing.
+   * 
+   * Updates the world maps configuration. If the world manager doesn't exist,
+   * it is automatically created. This is useful for dynamically loading world
+   * data or updating map positions.
+   * 
+   * @param id - The world ID
+   * @param maps - Array of map configurations to update
+   * @returns Promise that resolves when the update is complete
+   * 
+   * @example
+   * ```ts
+   * await map.updateWorldMaps('my-world', [
+   *   { id: 'map1', worldX: 0, worldY: 0, width: 800, height: 600 },
+   *   { id: 'map2', worldX: 800, worldY: 0, width: 800, height: 600 }
+   * ]);
+   * ```
    */
   async updateWorldMaps(id, maps) {
     let world = this.getWorldMaps(id);
@@ -28168,24 +27010,159 @@ let RpgMap = class extends RpgCommonMap {
     this.events()[id] = eventInstance;
     await eventInstance.execMethod("onInit");
   }
+  /**
+   * Get an event by its ID
+   * 
+   * Returns the event with the specified ID, or undefined if not found.
+   * The return type can be narrowed using TypeScript generics.
+   * 
+   * @param eventId - The unique identifier of the event
+   * @returns The event instance, or undefined if not found
+   * 
+   * @example
+   * ```ts
+   * // Get any event
+   * const event = map.getEvent('npc-1');
+   * 
+   * // Get event with type narrowing
+   * const npc = map.getEvent<MyNPC>('npc-1');
+   * if (npc) {
+   *   npc.speak('Hello!');
+   * }
+   * ```
+   */
   getEvent(eventId) {
     return this.events()[eventId];
   }
+  /**
+   * Get a player by their ID
+   * 
+   * Returns the player with the specified ID, or undefined if not found.
+   * 
+   * @param playerId - The unique identifier of the player
+   * @returns The player instance, or undefined if not found
+   * 
+   * @example
+   * ```ts
+   * const player = map.getPlayer('player-123');
+   * if (player) {
+   *   console.log(`Player ${player.name} is on the map`);
+   * }
+   * ```
+   */
   getPlayer(playerId) {
     return this.players()[playerId];
   }
+  /**
+   * Get all players currently on the map
+   * 
+   * Returns an array of all players that are currently connected to this map.
+   * 
+   * @returns Array of all RpgPlayer instances on the map
+   * 
+   * @example
+   * ```ts
+   * const players = map.getPlayers();
+   * console.log(`There are ${players.length} players on the map`);
+   * 
+   * players.forEach(player => {
+   *   console.log(`- ${player.name}`);
+   * });
+   * ```
+   */
   getPlayers() {
     return Object.values(this.players());
   }
+  /**
+   * Get all events on the map
+   * 
+   * Returns an array of all events (NPCs, objects, etc.) that are currently
+   * on this map.
+   * 
+   * @returns Array of all RpgEvent instances on the map
+   * 
+   * @example
+   * ```ts
+   * const events = map.getEvents();
+   * console.log(`There are ${events.length} events on the map`);
+   * 
+   * events.forEach(event => {
+   *   console.log(`- ${event.name} at (${event.x}, ${event.y})`);
+   * });
+   * ```
+   */
   getEvents() {
     return Object.values(this.events());
   }
+  /**
+   * Get the first event that matches a condition
+   * 
+   * Searches through all events on the map and returns the first one that
+   * matches the provided callback function.
+   * 
+   * @param cb - Callback function that returns true for the desired event
+   * @returns The first matching event, or undefined if none found
+   * 
+   * @example
+   * ```ts
+   * // Find an event by name
+   * const npc = map.getEventBy(event => event.name === 'Merchant');
+   * 
+   * // Find an event at a specific position
+   * const chest = map.getEventBy(event => 
+   *   event.x === 100 && event.y === 200
+   * );
+   * ```
+   */
   getEventBy(cb) {
     return this.getEventsBy(cb)[0];
   }
+  /**
+   * Get all events that match a condition
+   * 
+   * Searches through all events on the map and returns all events that
+   * match the provided callback function.
+   * 
+   * @param cb - Callback function that returns true for desired events
+   * @returns Array of all matching events
+   * 
+   * @example
+   * ```ts
+   * // Find all NPCs
+   * const npcs = map.getEventsBy(event => event.name.startsWith('NPC-'));
+   * 
+   * // Find all events in a specific area
+   * const nearbyEvents = map.getEventsBy(event => 
+   *   event.x >= 0 && event.x <= 100 &&
+   *   event.y >= 0 && event.y <= 100
+   * );
+   * ```
+   */
   getEventsBy(cb) {
     return this.getEvents().filter(cb);
   }
+  /**
+   * Remove an event from the map
+   * 
+   * Removes the event with the specified ID from the map. The event will
+   * be removed from the synchronized events signal, causing it to disappear
+   * on all clients.
+   * 
+   * @param eventId - The unique identifier of the event to remove
+   * 
+   * @example
+   * ```ts
+   * // Remove an event
+   * map.removeEvent('npc-1');
+   * 
+   * // Remove event after interaction
+   * const chest = map.getEvent('chest-1');
+   * if (chest) {
+   *   // ... do something with chest ...
+   *   map.removeEvent('chest-1');
+   * }
+   * ```
+   */
   removeEvent(eventId) {
     delete this.events()[eventId];
   }
@@ -28267,16 +27244,44 @@ let RpgMap = class extends RpgCommonMap {
       animationName
     });
   }
-  /**
-   * Set the sync schema for the map
-   * @param schema - The schema to set
-   */
   /**
    * Configure runtime synchronized properties on the map
-   *
-   * Design
+   * 
+   * This method allows you to dynamically add synchronized properties to the map
+   * that will be automatically synced with clients. The schema follows the same
+   * structure as module properties with `$initial`, `$syncWithClient`, and `$permanent` options.
+   * 
+   * ## Architecture
+   * 
    * - Reads a schema object shaped like module props
    * - Creates typed sync signals with @signe/sync
+   * - Properties are accessible as `map.propertyName`
+   * 
+   * @param schema - Schema object defining the properties to sync
+   * @param schema[key].$initial - Initial value for the property
+   * @param schema[key].$syncWithClient - Whether to sync this property to clients
+   * @param schema[key].$permanent - Whether to persist this property
+   * 
+   * @example
+   * ```ts
+   * // Add synchronized properties to the map
+   * map.setSync({
+   *   weather: {
+   *     $initial: 'sunny',
+   *     $syncWithClient: true,
+   *     $permanent: false
+   *   },
+   *   timeOfDay: {
+   *     $initial: 12,
+   *     $syncWithClient: true,
+   *     $permanent: false
+   *   }
+   * });
+   * 
+   * // Use the properties
+   * map.weather.set('rainy');
+   * const currentWeather = map.weather();
+   * ```
    */
   setSync(schema) {
     for (let key in schema) {
@@ -28559,6 +27564,64 @@ let RpgMap = class extends RpgCommonMap {
       player.stopSound(soundId);
     });
   }
+  /**
+   * Shake the map for all players
+   * 
+   * This method triggers a shake animation on the map for all players currently on the map.
+   * The shake effect creates a visual feedback that can be used for earthquakes, explosions,
+   * impacts, or any dramatic event that should affect the entire map visually.
+   * 
+   * ## Architecture
+   * 
+   * Broadcasts a shake event to all clients connected to the map. Each client receives
+   * the shake configuration and triggers the shake animation on the map container using
+   * Canvas Engine's shake directive.
+   * 
+   * @param options - Optional shake configuration
+   * @param options.intensity - Shake intensity in pixels (default: 10)
+   * @param options.duration - Duration of the shake animation in milliseconds (default: 500)
+   * @param options.frequency - Number of shake oscillations during the animation (default: 10)
+   * @param options.direction - Direction of the shake - 'x', 'y', or 'both' (default: 'both')
+   * 
+   * @example
+   * ```ts
+   * // Basic shake with default settings
+   * map.shakeMap();
+   * 
+   * // Intense earthquake effect
+   * map.shakeMap({
+   *   intensity: 25,
+   *   duration: 1000,
+   *   frequency: 15,
+   *   direction: 'both'
+   * });
+   * 
+   * // Horizontal shake for side impact
+   * map.shakeMap({
+   *   intensity: 15,
+   *   duration: 400,
+   *   direction: 'x'
+   * });
+   * 
+   * // Vertical shake for ground impact
+   * map.shakeMap({
+   *   intensity: 20,
+   *   duration: 600,
+   *   direction: 'y'
+   * });
+   * ```
+   */
+  shakeMap(options) {
+    this.$broadcast({
+      type: "shakeMap",
+      value: {
+        intensity: options?.intensity ?? 10,
+        duration: options?.duration ?? 500,
+        frequency: options?.frequency ?? 10,
+        direction: options?.direction ?? "both"
+      }
+    });
+  }
 };
 __decorateClass$1([
   users$1(RpgPlayer)
@@ -28894,6 +27957,14 @@ function provideServerModules(modules) {
     const mainModuleServer = findModules(context, "Server");
     modules2 = [...mainModuleServer, ...modules2];
     modules2 = modules2.map((module) => {
+      if (typeof module === "function") {
+        const instance = new module();
+        const moduleObj = {};
+        for (const key in instance) {
+          moduleObj[key] = instance[key];
+        }
+        module = moduleObj;
+      }
       if ("server" in module) {
         module = module.server;
       }
@@ -28914,7 +27985,27 @@ function provideServerModules(modules) {
           maps: {
             load: (engine) => {
               maps.forEach((map) => {
-                engine.maps.push(map);
+                let mapInstance;
+                if (typeof map === "function") {
+                  const MapClass = map;
+                  mapInstance = {
+                    id: MapClass.prototype?.id ?? MapClass.id,
+                    file: MapClass.prototype?.file ?? MapClass.file,
+                    type: MapClass.type,
+                    name: MapClass.prototype?.name,
+                    sounds: MapClass.prototype?.sounds,
+                    lowMemory: MapClass.prototype?.lowMemory,
+                    stopAllSoundsBeforeJoin: MapClass.prototype?.stopAllSoundsBeforeJoin,
+                    events: MapClass.prototype?._events,
+                    syncSchema: MapClass.prototype?.$schema,
+                    onLoad: MapClass.prototype?.onLoad,
+                    onJoin: MapClass.prototype?.onJoin,
+                    onLeave: MapClass.prototype?.onLeave
+                  };
+                } else {
+                  mapInstance = map;
+                }
+                engine.maps.push(mapInstance);
               });
             }
           }
@@ -28966,11 +28057,21 @@ function MapData(options) {
     target.prototype.id = options.id;
     target.prototype.sounds = options.sounds;
     target.prototype.lowMemory = options.lowMemory;
+    target.prototype.stopAllSoundsBeforeJoin = options.stopAllSoundsBeforeJoin;
     target.prototype.$schema = {};
     if (options.syncSchema) {
       target.prototype.$schema = options.syncSchema;
     }
     target.prototype._events = options.events;
+    if (options.onLoad) {
+      target.prototype.onLoad = options.onLoad;
+    }
+    if (options.onJoin) {
+      target.prototype.onJoin = options.onJoin;
+    }
+    if (options.onLeave) {
+      target.prototype.onLeave = options.onLeave;
+    }
   };
 }