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

package/dist/index.js

@@ -26158,7 +26158,7 @@ function WithMoveManager(Base) {
   return class extends Base {
     constructor() {
       super(...arguments);
-      // Private properties for infinite route management
+      // Properties for infinite route management
       this._infiniteRoutes = null;
       this._finishRoute = null;
       this._isInfiniteRouteActive = false;
@@ -26962,123 +26962,16 @@ class NotificationGui extends Gui {
 }
 
 function WithGuiManager(Base) {
-  return class extends Base {
+  class GuiManagerMixin extends Base {
     constructor() {
       super(...arguments);
       this._gui = {};
     }
-    /**
-     * Show a text. This is a graphical interface already built. Opens the GUI named `rpg-dialog`
-     *
-     * ```ts
-     * player.showText('Hello World')
-     * ```
-     *
-     * The method returns a promise. It is resolved when the dialog box is closed.
-     *
-     * ```ts
-     * await player.showText('Hello World')
-     * // dialog box is closed, then ...
-     * ```
-     *
-     * **Option: position**
-     *
-     * You can define how the dialog box is displayed:
-     * - top
-     * - middle
-     * - bottom
-     *
-     * (bottom by default)
-     *
-     * ```ts
-     * player.showText('Hello World', {
-     *      position: 'top'
-     * })
-     * ```
-     *
-     * **Option: fullWidth**
-     *
-     * `boolean` (true by default)
-     *
-     * Indicate that the dialog box will take the full width of the screen.
-     *
-     * ```ts
-     * player.showText('Hello World', {
-     *      fullWidth: true
-     * })
-     * ```
-     *
-     * **Option: autoClose**
-     *
-     * `boolean` (false by default)
-     *
-     * If false, the user will have to press Enter to close the dialog box.
-     *
-     *  ```ts
-     * player.showText('Hello World', {
-     *      autoClose: true
-     * })
-     * ```
-     *
-     * **Option: typewriterEffect**
-     *
-     * `boolean` (true by default)
-     *
-     * Performs a typewriter effect
-     *
-     *  ```ts
-     * player.showText('Hello World', {
-     *      typewriterEffect: false
-     * })
-     * ```
-     *
-     * **Option: talkWith**
-     *
-     * `RpgPlayer` (nothing by default)
-     *
-     * If you specify the event or another player, the other player will stop his or her movement and look in the player's direction.
-     *
-     *  ```ts
-     * // Code in an event
-     * player.showText('Hello World', {
-     *      talkWith: this
-     * })
-     * ```
-     *
-     * @title Show Text
-     * @method player.showText(text,options)
-     * @param {string} text
-     * @param {object} [options] the different options, see usage below
-     * @returns {Promise}
-     * @memberof GuiManager
-     */
     showText(msg, options = {}) {
       const gui = new DialogGui(this);
       this._gui[gui.id] = gui;
       return gui.openDialog(msg, options);
     }
-    /**
-     * Shows a dialog box with a choice. Opens the GUI named `rpg-dialog`
-     *
-     * ```ts
-     * const choice = await player.showChoices('What color do you prefer?', [
-     *      { text: 'Black', value: 'black' },
-     *      { text: 'Rather the blue', value: 'blue' },
-     *      { text: 'I don\'t have a preference!', value: 'none' }
-     * ])
-     *
-     * // If the player selects the first
-     * console.log(choice) // { text: 'Black', value: 'black' }
-     * ```
-     *
-     * @title Show Choices
-     * @method player.showChoices(text,choices)
-     * @param {string} text
-     * @param {Array<{ text: string, value: any }>} choices
-     * @param {object} [options] Same options as the openDialog method
-     * @returns {Promise<Choice | null>}
-     * @memberof GuiManager
-     */
     showChoices(msg, choices, options) {
       return this.showText(msg, {
         choices,
@@ -27088,19 +26981,6 @@ function WithGuiManager(Base) {
         return choices[indexSelected];
       });
     }
-    /**
-     * Displays a notification . Opens the GUI named `rpg-notification`
-     *
-     * @title Displays a notification
-     * @method player.showNotification()
-     * @param {string} message - The message to display in the notification
-     * @param {object} options - An object containing options for the notification
-     * @param {number} options.time - The time to display the notification for (in ms). Default: 2000ms
-     * @param {string} options.icon - The icon to display in the notification. Put the identifier of the spritesheet (defined on the client side)
-     * @param {string} options.sound - The sound to play when the notification is shown. Set the sound ID (defined on the client side)
-     * @returns {void}
-     * @memberof GuiManager
-     */
     showNotification(message, options = {}) {
       const gui = new NotificationGui(this);
       this._gui[gui.id] = gui;
@@ -27110,14 +26990,6 @@ function WithGuiManager(Base) {
       };
       return gui.open(data);
     }
-    /**
-     * Calls main menu. Opens the GUI named `rpg-main-menu`
-     *
-     * @title Call Main Menu
-     * @method player.callMainMenu()
-     * @returns {void}
-     * @memberof GuiManager
-     */
     callMainMenu() {
       const gui = new MenuGui(this);
       this._gui[gui.id] = gui;
@@ -27250,23 +27122,12 @@ function WithGuiManager(Base) {
       const _players = players || this;
       this._attachedGui(_players, false);
     }
-  };
+  }
+  return GuiManagerMixin;
 }
 
 function WithGoldManager(Base) {
   return class extends Base {
-    /** 
-     * You can change the game money
-     * 
-     * ```ts
-     * player.gold += 100
-     * ```
-     * 
-     * @title Change Gold
-     * @prop {number} player.gold
-     * @default 0
-     * @memberof GoldManager
-     * */
     set gold(val) {
       if (val < 0) {
         val = 0;
@@ -27288,52 +27149,168 @@ function WithVariableManager(Base) {
     /** 
      * 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
-     * player.setVariable('OPEN_CHEST', true)
+     * // 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());
      * ```
-     * 
-     * @title Set variable
-     * @method player.setVariable(key,val)
-     * @param {string} key
-     * @param {any} val
-     * @returns {void}
-     * @memberof VariableManager
-     * */
+     */
     setVariable(key, val) {
       this.variables.set(key, val);
     }
     /** 
-     * Get a variable
+     * 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
-     * const val = player.getVariable('OPEN_CHEST')
-     * ```
+     * // 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
      * 
-     * @title Get variable
-     * @method player.setVariable(key,val)
-     * @param {string} key
-     * @returns {any} 
-     * @memberof VariableManager
-     * */
+     * // 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
-     * player.removeVariable('OPEN_CHEST')
-     * ```
+     * // Remove variables and check if they existed
+     * const removed = player.removeVariable('CHEST_OPENED'); // true if existed
+     * const notFound = player.removeVariable('nonexistent'); // false
      * 
-     * @title Remove variable
-     * @method player.removeVariable(key)
-     * @param {string} key
-     * @returns {boolean} true if a variable existed and has been removed, or false if the variable does not exist.
-     * @memberof VariableManager
-     * */
+     * // 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();
+    }
   };
 }
 
@@ -27886,278 +27863,53 @@ class StateLog {
   }
 }
 
-function WithStateManager(Base) {
+function WithItemManager(Base) {
   return class extends Base {
-    constructor() {
-      super(...arguments);
-      this._statesEfficiency = signal$2([]);
-    }
     /**
-     * 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.
+     * 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 { 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)
+     * import Potion from 'your-database/potion'
      *
-     * console.log(player.statesDefense) // [{ rate: 1, state: instance of Paralyze }]
-     * ```
-     * @title Get States Defense
-     * @prop {Array<{ rate: number, state: StateClass}>} player.statesDefense
-     * @readonly
-     * @memberof StateManager
-     * */
-    get statesDefense() {
-      return this.getFeature("statesDefense", "state");
+     * 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];
     }
     /**
-     * Set or retrieves all the states where the player is vulnerable or not.
-     *
-     * ```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 }]
+     * 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
      *
-     * console.log(player.statesEfficiency) // [{ rate: 1, state: instance of Paralyze }, { rate: 2, state: instance of Sleep }]
-     * ```
-     * @title Set/Get States Efficiency
-     * @prop {Array<{ rate: number, state: StateClass}>} player.statesEfficiency
-     * @memberof StateManager
-     * */
-    get statesEfficiency() {
-      return this._statesEfficiency;
-    }
-    set statesEfficiency(val) {
-      this._statesEfficiency = val;
-    }
-    applyStates(player, { addStates, removeStates }) {
-      if (addStates) {
-        for (let { state, rate } of addStates) {
-          player.addState(state, rate);
-        }
-      }
-      if (removeStates) {
-        for (let { state, rate } of removeStates) {
-          player.removeState(state, rate);
-        }
-      }
-    }
-    /**
-     * Get a state to the player. Returns `null` if the state is not present on the player
      * ```ts
-     * import Paralyze from 'your-database/states/paralyze'
+     * import Potion from 'your-database/potion'
      *
-     * player.getState(Paralyze)
+     * player.hasItem(Potion) // false
      *  ```
-     *
-     * @title Get State
-     * @method player.getState(stateClass)
-     * @param {StateClass | string} stateClass or state id
-     * @returns {instance of StateClass | null}
-     * @memberof StateManager
      */
-    getState(stateClass) {
-      if (isString(stateClass)) stateClass = this.databaseById(stateClass);
-      return this.states().find((state) => {
-        if (isString(stateClass)) {
-          return state.id == stateClass;
+    hasItem(itemClass) {
+      return !!this.getItem(itemClass);
+    }
+    _getItemIndex(itemClass) {
+      return this.items().findIndex((it) => {
+        if (isString(itemClass)) {
+          return it.id() == itemClass;
         }
-        return isInstanceOf(state, stateClass);
-      });
-    }
-    /**
-     * Adds a state to the player. Set the chance between 0 and 1 that the state can apply
-     * ```ts
-     * import Paralyze from 'your-database/states/paralyze'
-     *
-     * try {
-     *      player.addState(Paralyze)
-     * }
-     * catch (err) {
-     *      console.log(err)
-     * }
-     *  ```
-     *
-     * @title Add State
-     * @method player.addState(stateClass,chance=1)
-     * @param {StateClass | string} stateClass state class or state id
-     * @param {number} [chance] 1 by default
-     * @throws {StateLog} addFailed
-     * If the chance to add the state has failed (defined with the `chance` param)
-     *  ```
-     * {
-     *      id: ADD_STATE_FAILED,
-     *      msg: '...'
-     * }
-     * ```
-     * @returns {instance of StateClass}
-     * @memberof StateManager
-     * @todo
-     */
-    addState(stateClass, chance = 1) {
-      const state = this.getState(stateClass);
-      if (isString(stateClass)) {
-        stateClass = this.databaseById(stateClass);
-      }
-      if (!state) {
-        if (Math.random() > chance) {
-          throw StateLog.addFailed(stateClass);
-        }
-        const instance = new stateClass();
-        this.states().push(instance);
-        this.applyStates(this, instance);
-        return instance;
-      }
-      return null;
-    }
-    /**
-     * Remove a state to the player. Set the chance between 0 and 1 that the state can be removed
-     * ```ts
-     * import Paralyze from 'your-database/states/paralyze'
-     *
-     * try {
-     *      player.removeState(Paralyze)
-     * }
-     * catch (err) {
-     *      console.log(err)
-     * }
-     *  ```
-     *
-     * @title Remove State
-     * @method player.removeState(stateClass,chance=1)
-     * @param {StateClass|string} stateClass class state or state id
-     * @param {number} [chance] 1 by default
-     * @throws {StateLog} removeFailed
-     * If the chance to remove the state has failed (defined with the `chance` param)
-     *  ```
-     * {
-     *      id: REMOVE_STATE_FAILED,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {StateLog} notApplied
-     * If the status does not exist
-     *  ```
-     * {
-     *      id: STATE_NOT_APPLIED,
-     *      msg: '...'
-     * }
-     * ```
-     * @returns {instance of StateClass}
-     * @memberof StateManager
-     */
-    removeState(stateClass, chance = 1) {
-      const index = this.states().findIndex((state) => {
-        if (isString(stateClass)) {
-          return state.id == stateClass;
-        }
-        return isInstanceOf(state, stateClass);
-      });
-      if (index != -1) {
-        if (Math.random() > chance) {
-          throw StateLog.removeFailed(stateClass);
-        }
-        this.states().splice(index, 1);
-      } else {
-        throw StateLog.notApplied(stateClass);
-      }
-    }
-    findStateEfficiency(stateClass) {
-      return this.statesEfficiency().find(
-        (state) => isInstanceOf(state.state, stateClass)
-      );
-    }
-  };
-}
-
-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);
-    }
-    _getItemIndex(itemClass) {
-      return this.items().findIndex((it) => {
-        if (isString(itemClass)) {
-          return it.id() == itemClass;
-        }
-        return isInstanceOf(it, itemClass);
+        return isInstanceOf(it, itemClass);
       });
     }
     /**
@@ -28582,31 +28334,68 @@ var Effect = /* @__PURE__ */ ((Effect2) => {
 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'
      *
-     * const bool = player.hasEffect(Effect.CAN_NOT_SKILL)
+     * // 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);
      * ```
-     *
-     * @title Has Effect
-     * @method player.hasEffect(effect)
-     * @param {string} effect
-     * @returns {boolean}
-     * @memberof EffectManager
-     * */
+     */
     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
-     * console.log(player.effects)
+     * // 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)
+     * );
      * ```
-     * @title Get Effects
-     * @prop {Array<Effect>} player.effects
-     * @memberof EffectManager
-     * */
+     */
     get effects() {
       const getEffects = (prop) => {
         return arrayFlat(this[prop]().map((el) => el.effects || []));
@@ -28620,113 +28409,243 @@ function WithEffectManager(Base) {
     /**
      * 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'
      *
-     * player.effects = [Effect.CAN_NOT_SKILL]
+     * // 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;
      * ```
-     * @title Set Effects
-     * @prop {Array<Effect>} player.effects
-     * @memberof EffectManager
-     * */
+     */
     set effects(val) {
       this._effects.set(val);
     }
   };
 }
 
-function WithBattleManager(Base) {
+function WithElementManager(Base) {
   return class extends Base {
+    constructor() {
+      super(...arguments);
+      this._elementsEfficiency = [];
+    }
     /**
-     * Apply damage. Player will lose HP. the `attackerPlayer` parameter is the other player, the one who attacks.
+     * 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.
      *
-     * 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
+     * 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
-     * player.applyDamage(attackerPlayer) // returns { damage: number }
+     * 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()) {
+        return [
+          ...this._elementsEfficiency,
+          ...this._class()?.elementsEfficiency || []
+        ];
+      }
+      return this._elementsEfficiency;
+    }
+    set elementsEfficiency(val) {
+      this._elementsEfficiency = val;
+    }
+    /**
+     * Retrieves a array of elements assigned to the player and the elements of the weapons / armor equipped
      *
-     * @title Apply Damage
-     * @method player.applyDamage(attackerPlayer,skill)
-     * @param {RpgPlayer} attackerPlayer The attacking player
-     * @param {any} [skill]
-     * @returns {object}
-     * @memberof BattleManager
-     * */
-    applyDamage(attackerPlayer, skill) {
-      const getParam = (player) => {
-        const params = {};
-        this.parameters.forEach((val, key) => {
-          params[key] = player.param[key];
-        });
-        return {
-          [ATK]: player.atk,
-          [PDEF]: player.pdef,
-          [SDEF]: player.sdef,
-          ...params
-        };
-      };
-      let damage = 0, fn;
-      let critical = false;
-      let guard = false;
-      let superGuard = false;
-      let elementVulnerable = false;
-      const paramA = getParam(attackerPlayer);
-      const paramB = getParam(this);
-      console.log(paramA, paramB);
-      if (skill) {
-        fn = this.getFormulas("damageSkill");
-        if (!fn) {
-          throw new Error("Skill Formulas not exists");
-        }
-        damage = fn(paramA, paramB, skill);
-      } else {
-        fn = this.getFormulas("damagePhysic");
-        if (!fn) {
-          throw new Error("Physic Formulas not exists");
-        }
-        damage = fn(paramA, paramB);
-        const coef = this.coefficientElements(attackerPlayer);
-        if (coef >= 2) {
-          elementVulnerable = true;
-        }
-        damage *= coef;
-        fn = this.getFormulas("damageCritical");
-        if (fn) {
-          let newDamage = fn(damage, paramA, paramB);
-          if (damage != newDamage) {
-            critical = true;
-          }
-          damage = newDamage;
+     * 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()) {
+        if (item.elements) {
+          elements = [...elements, ...item.elements];
         }
       }
-      if (this.hasEffect(Effect.GUARD)) {
-        fn = this.getFormulas("damageGuard");
-        if (fn) {
-          let newDamage = fn(damage, paramA, paramB);
-          if (damage != newDamage) {
-            guard = true;
-          }
-          damage = newDamage;
+      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;
+      let coefficient = 1;
+      for (let atkElement of atkPlayerElements) {
+        const elementPlayer = playerElements.find(
+          (el) => el.element == atkElement.element
+        );
+        const elementPlayerDef = this.elementsDefense.find(
+          (el) => el.element == atkElement.element
+        );
+        if (!elementPlayer) continue;
+        const fn = this.getFormulas("coefficientElements");
+        if (!fn) {
+          return coefficient;
         }
+        coefficient += fn(
+          atkElement,
+          elementPlayer,
+          elementPlayerDef || { rate: 0 }
+        );
       }
-      if (this.hasEffect(Effect.SUPER_GUARD)) {
-        damage /= 4;
-        superGuard = true;
-      }
-      this.hp -= damage;
-      return {
-        damage,
-        critical,
-        elementVulnerable,
-        guard,
-        superGuard
-      };
-    }
-    getFormulas(name) {
-      const map = this.getCurrentMap();
-      return map.damageFormulas[name];
+      return coefficient;
     }
   };
 }
@@ -28945,23 +28864,176 @@ 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 getParam = (player) => {
+        const params = {};
+        this.parameters.forEach((val, key) => {
+          params[key] = player.param[key];
+        });
+        return {
+          [ATK]: player.atk,
+          [PDEF]: player.pdef,
+          [SDEF]: player.sdef,
+          ...params
+        };
+      };
+      let damage = 0, fn;
+      let critical = false;
+      let guard = false;
+      let superGuard = false;
+      let elementVulnerable = false;
+      const paramA = getParam(attackerPlayer);
+      const paramB = getParam(this);
+      console.log(paramA, paramB);
+      if (skill) {
+        fn = this.getFormulas("damageSkill");
+        if (!fn) {
+          throw new Error("Skill Formulas not exists");
+        }
+        damage = fn(paramA, paramB, skill);
+      } else {
+        fn = this.getFormulas("damagePhysic");
+        if (!fn) {
+          throw new Error("Physic Formulas not exists");
+        }
+        damage = fn(paramA, paramB);
+        const coef = this.coefficientElements(attackerPlayer);
+        if (coef >= 2) {
+          elementVulnerable = true;
+        }
+        damage *= coef;
+        fn = this.getFormulas("damageCritical");
+        if (fn) {
+          let newDamage = fn(damage, paramA, paramB);
+          if (damage != newDamage) {
+            critical = true;
+          }
+          damage = newDamage;
+        }
+      }
+      if (this.hasEffect(Effect.GUARD)) {
+        fn = this.getFormulas("damageGuard");
+        if (fn) {
+          let newDamage = fn(damage, paramA, paramB);
+          if (damage != newDamage) {
+            guard = true;
+          }
+          damage = newDamage;
+        }
+      }
+      if (this.hasEffect(Effect.SUPER_GUARD)) {
+        damage /= 4;
+        superGuard = true;
+      }
+      this.hp -= damage;
+      return {
+        damage,
+        critical,
+        elementVulnerable,
+        guard,
+        superGuard
+      };
+    }
+    /**
+     * Get damage formulas from the current map
+     * 
+     * Retrieves the damage calculation formulas defined in the current map's configuration.
+     * These formulas are used to calculate different types of damage including physical,
+     * magical, critical hits, and guard effects. The formulas provide flexibility in
+     * customizing the battle system's damage calculations.
+     * 
+     * @param name - The name of the formula to retrieve (e.g., 'damagePhysic', 'damageSkill')
+     * @returns The formula function or undefined if not found
+     * 
+     * @example
+     * ```ts
+     * // Get physical damage formula
+     * const physicFormula = player.getFormulas('damagePhysic');
+     * if (physicFormula) {
+     *   const damage = physicFormula(attackerParams, defenderParams);
+     * }
+     * 
+     * // Get critical damage formula
+     * const criticalFormula = player.getFormulas('damageCritical');
+     * if (criticalFormula) {
+     *   const criticalDamage = criticalFormula(baseDamage, attackerParams, defenderParams);
+     * }
+     * ```
+     */
+    getFormulas(name) {
+      const map = this.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'
      *
-     * player.setClass(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
      * ```
-     *
-     * @title Set Class
-     * @method player.setClass(ClassClass)
-     * @param {ClassClass | string} class class or id
-     * @returns {instance of ClassClass}
-     * @memberof ClassManager
-     * */
+     */
     setClass(_class) {
       if (isString(_class)) _class = this.databaseById(_class);
       const classInstance = new _class();
@@ -28971,18 +29043,39 @@ function WithClassManager(Base) {
     /**
      * 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'
      *
-     * player.setActor(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
      * ```
-     *
-     * @title Set Actor
-     * @method player.setActor(ActorClass)
-     * @param {ActorClass | string} actorClass actor class or id
-     * @returns {instance of ActorClass}
-     * @memberof ClassManager
-     * */
+     */
     setActor(actorClass) {
       if (isString(actorClass)) actorClass = this.databaseById(actorClass);
       const actor = new actorClass();
@@ -29003,32 +29096,41 @@ function WithClassManager(Base) {
   };
 }
 
-function WithElementManager(Base) {
+function WithStateManager(Base) {
   return class extends Base {
     constructor() {
       super(...arguments);
-      this._elementsEfficiency = [];
+      this._statesEfficiency = signal$2([]);
     }
     /**
-     * Recovers the player's elements defense on inventory.  This list is generated from the `elementsDefense` property defined on the weapons or armors equipped.
+     * 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 } from '@rpgjs/server'
+     * import { Armor, State } from '@rpgjs/server'
      *
-     * enum Elements {
-     *   Fire = 'fire'
-     * }
+     * @State({
+     *      name: 'Paralyze'
+     * })
+     * class Paralyze {}
      *
      * @Armor({
      *      name: 'Shield',
-     *      elementsDefense: [{ rate: 1, element: Elements.Fire }]
+     *      statesDefense: [{ rate: 1, state: Paralyze }]
      * })
      * class Shield {}
      *
      * @Armor({
      *      name: 'FireShield',
-     *      elementsDefense: [{ rate: 0.5, element: Elements.Fire }]
+     *      statesDefense: [{ rate: 0.5, state: Paralyze }]
      * })
      * class FireShield {}
      *
@@ -29037,100 +29139,291 @@ function WithElementManager(Base) {
      * player.equip(Shield)
      * player.equip(FireShield)
      *
-     * console.log(player.elementsDefense) // [{ rate: 1, element: 'fire' }]
+     * 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}`);
+     * }
      * ```
-     * @title Get Elements Defense
-     * @prop {Array<{ rate: number, element: Element}>} player.elementsDefense
-     * @readonly
-     * @memberof ElementManager
-     * */
-    get elementsDefense() {
-      return this.getFeature("elementsDefense", "element");
+     */
+    get statesDefense() {
+      return this.getFeature("statesDefense", "state");
     }
     /**
-     * Set or retrieves all the elements where the player is vulnerable or not.
+     * 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 } from '@rpgjs/server'
+     * import { Class, State } from '@rpgjs/server'
+     *
+     * @State({
+     *      name: 'Paralyze'
+     * })
+     * class Paralyze {}
      *
-     * enum Elements {
-     *   Fire = 'fire',
-     *   Ice = 'ice'
-     * }
+     * @State({
+     *      name: 'Sleep'
+     * })
+     * class Sleep {}
      *
      * @Class({
      *      name: 'Fighter',
-     *      elementsEfficiency: [{ rate: 1, element: Elements.Fire }]
+     *      statesEfficiency: [{ rate: 1, state: Paralyze }]
      * })
      * class Hero {}
      *
      * player.setClass(Hero)
      *
-     * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }]
+     * console.log(player.statesEfficiency) // [{ rate: 1, instance of Paralyze }]
      *
-     * player.elementsEfficiency = [{ rate: 2, element: Elements.Ice }]
+     * player.statesEfficiency = [{ rate: 2, state: Sleep }]
      *
-     * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }, { rate: 2, element: 'ice' }]
+     * 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));
      * ```
-     * @title Set/Get Elements Efficiency
-     * @prop {Array<{ rate: number, element: Element}>} player.elementsEfficiency
-     * @memberof ElementManager
-     * */
-    get elementsEfficiency() {
-      if (this._class) {
-        return [
-          ...this._elementsEfficiency,
-          ...this._class()?.elementsEfficiency || []
-        ];
-      }
-      return this._elementsEfficiency;
+     */
+    get statesEfficiency() {
+      return this._statesEfficiency;
     }
-    set elementsEfficiency(val) {
-      this._elementsEfficiency = val;
+    set statesEfficiency(val) {
+      this._statesEfficiency = val;
     }
     /**
-     * Retrieves a array of elements assigned to the player and the elements of the weapons / armor equipped
+     * 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) {
+          player.addState(state, rate);
+        }
+      }
+      if (removeStates) {
+        for (let { state, rate } of removeStates) {
+          player.removeState(state, rate);
+        }
+      }
+    }
+    /**
+     * 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) => {
+        if (isString(stateClass)) {
+          return state.id == stateClass;
+        }
+        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
-     * console.log(player.elements)
+     * 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
+     *   }
+     * });
      * ```
-     * @title Get Elements
-     * @prop {Array<Element>} player.elements
-     * @readonly
-     * @memberof ElementManager
-     * */
-    get elements() {
-      let elements = [];
-      for (let item of this.equipments()) {
-        if (item.elements) {
-          elements = [...elements, ...item.elements];
+     */
+    addState(stateClass, chance = 1) {
+      const state = this.getState(stateClass);
+      if (isString(stateClass)) {
+        stateClass = this.databaseById(stateClass);
+      }
+      if (!state) {
+        if (Math.random() > chance) {
+          throw StateLog.addFailed(stateClass);
         }
+        const instance = new stateClass();
+        this.states().push(instance);
+        this.applyStates(this, instance);
+        return instance;
       }
-      return arrayUniq(elements);
+      return null;
     }
-    coefficientElements(otherPlayer) {
-      const atkPlayerElements = otherPlayer.elements;
-      const playerElements = this.elementsEfficiency;
-      let coefficient = 1;
-      for (let atkElement of atkPlayerElements) {
-        const elementPlayer = playerElements.find(
-          (el) => el.element == atkElement.element
-        );
-        const elementPlayerDef = this.elementsDefense.find(
-          (el) => el.element == atkElement.element
-        );
-        if (!elementPlayer) continue;
-        const fn = this.getFormulas("coefficientElements");
-        if (!fn) {
-          return coefficient;
+    /**
+     * 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)) {
+          return state.id == stateClass;
         }
-        coefficient += fn(
-          atkElement,
-          elementPlayer,
-          elementPlayerDef || { rate: 0 }
-        );
+        return isInstanceOf(state, stateClass);
+      });
+      if (index != -1) {
+        if (Math.random() > chance) {
+          throw StateLog.removeFailed(stateClass);
+        }
+        this.states().splice(index, 1);
+      } else {
+        throw StateLog.notApplied(stateClass);
       }
-      return coefficient;
+    }
+    /**
+     * 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)
+      );
     }
   };
 }
@@ -29147,23 +29440,23 @@ var __decorateClass$2 = (decorators, target, key, kind) => {
 function combinePlayerMixins(mixins) {
   return (Base) => mixins.reduce((ExtendedClass, mixin) => mixin(ExtendedClass), Base);
 }
-const PlayerMixins = combinePlayerMixins([
+const BasicPlayerMixins = combinePlayerMixins([
   WithComponentManager,
   WithEffectManager,
   WithGuiManager,
   WithMoveManager,
   WithGoldManager,
-  WithVariableManager,
   WithParameterManager,
   WithItemFixture,
-  WithStateManager,
   WithItemManager,
-  WithSkillManager,
+  WithElementManager,
+  WithVariableManager,
+  WithStateManager,
   WithClassManager,
-  WithBattleManager,
-  WithElementManager
+  WithSkillManager,
+  WithBattleManager
 ]);
-const _RpgPlayer = class _RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
+const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   constructor() {
     super();
     this.map = null;
@@ -29232,7 +29525,47 @@ const _RpgPlayer = class _RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
       value
     });
   }
-  showAnimation(params) {
+  /**
+   * Set the current animation of the player's sprite
+   * 
+   * This method changes the animation state of the player's current sprite.
+   * It's used to trigger character animations like attack, skill, or custom movements.
+   * When `nbTimes` is set to a finite number, the animation will play that many times
+   * before returning to the previous animation state.
+   * 
+   * @param animationName - The name of the animation to play (e.g., 'attack', 'skill', 'walk')
+   * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)
+   * 
+   * @example
+   * ```ts
+   * // Set continuous walk animation
+   * player.setAnimation('walk');
+   * 
+   * // Play attack animation 3 times then return to previous state
+   * player.setAnimation('attack', 3);
+   * 
+   * // Play skill animation once
+   * player.setAnimation('skill', 1);
+   * 
+   * // Set idle/stand animation
+   * player.setAnimation('stand');
+   * ```
+   */
+  setAnimation(animationName, nbTimes = Infinity) {
+    const map = this.getCurrentMap();
+    if (!map) return;
+    if (nbTimes === Infinity) {
+      this.animationName.set(animationName);
+    } else {
+      map.$broadcast({
+        type: "setAnimation",
+        value: {
+          animationName,
+          nbTimes,
+          object: this.id
+        }
+      });
+    }
   }
   /**
      * Run the change detection cycle. Normally, as soon as a hook is called in a class, the cycle is started. But you can start it manually
@@ -29302,11 +29635,35 @@ const _RpgPlayer = class _RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
       }
     );
   }
-  broadcastEffect(id, params) {
+  /**
+   * Show a temporary component animation on this player
+   * 
+   * This method broadcasts a component animation to all clients, allowing
+   * temporary visual effects like hit indicators, spell effects, or status animations
+   * to be displayed on the player.
+   * 
+   * @param id - The ID of the component animation to display
+   * @param params - Parameters to pass to the component animation
+   * 
+   * @example
+   * ```ts
+   * // Show a hit animation with damage text
+   * player.showComponentAnimation("hit", {
+   *   text: "150",
+   *   color: "red"
+   * });
+   * 
+   * // Show a heal animation
+   * player.showComponentAnimation("heal", {
+   *   amount: 50
+   * });
+   * ```
+   */
+  showComponentAnimation(id, params) {
     const map = this.getCurrentMap();
     if (!map) return;
     map.$broadcast({
-      type: "showEffect",
+      type: "showComponentAnimation",
       value: {
         id,
         params,
@@ -29314,8 +29671,45 @@ const _RpgPlayer = class _RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
       }
     });
   }
+  /**
+   * Display a spritesheet animation on the player
+   * 
+   * This method displays a temporary visual animation using a spritesheet.
+   * The animation can either be displayed as an overlay on the player or replace
+   * the player's current graphic temporarily. This is useful for spell effects,
+   * transformations, or other visual feedback that uses predefined spritesheets.
+   * 
+   * @param graphic - The ID of the spritesheet to use for the animation
+   * @param animationName - The name of the animation within the spritesheet (default: 'default')
+   * @param replaceGraphic - Whether to replace the player's sprite with the animation (default: false)
+   * 
+   * @example
+   * ```ts
+   * // Show explosion animation as overlay on player
+   * player.showAnimation("explosion");
+   * 
+   * // Show specific spell effect animation
+   * player.showAnimation("spell-effects", "fireball");
+   * 
+   * // Transform player graphic temporarily with animation
+   * player.showAnimation("transformation", "werewolf", true);
+   * 
+   * // Show healing effect on player
+   * player.showAnimation("healing-effects", "holy-light");
+   * ```
+   */
+  showAnimation(graphic, animationName = "default", replaceGraphic = false) {
+    if (replaceGraphic) {
+      this.setAnimation(animationName, 1);
+      return;
+    }
+    this.showComponentAnimation("animation", {
+      graphic,
+      animationName
+    });
+  }
   showHit(text) {
-    this.broadcastEffect("hit", {
+    this.showComponentAnimation("hit", {
       text,
       direction: this.direction()
     });
@@ -29343,6 +29737,7 @@ class RpgEvent extends RpgPlayer {
 }
 
 const context$1 = new Context();
+context$1["side"] = "server";
 
 var __defProp$1 = Object.defineProperty;
 var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
@@ -29533,18 +29928,84 @@ let RpgMap = class extends RpgCommonMap {
   removeEvent(eventId) {
     delete this.events()[eventId];
   }
-  showAnimation(animationName, object) {
+  /**
+   * Display a component animation at a specific position on the map
+   * 
+   * This method broadcasts a component animation to all clients connected to the map,
+   * allowing temporary visual effects to be displayed at any location on the map.
+   * Component animations are custom Canvas Engine components that can display
+   * complex effects with custom logic and parameters.
+   * 
+   * @param id - The ID of the component animation to display
+   * @param position - The x, y coordinates where to display the animation
+   * @param params - Parameters to pass to the component animation
+   * 
+   * @example
+   * ```ts
+   * // Show explosion at specific coordinates
+   * map.showComponentAnimation("explosion", { x: 300, y: 400 }, {
+   *   intensity: 2.5,
+   *   duration: 1500
+   * });
+   * 
+   * // Show area damage effect
+   * map.showComponentAnimation("area-damage", { x: player.x, y: player.y }, {
+   *   radius: 100,
+   *   color: "red",
+   *   damage: 50
+   * });
+   * 
+   * // Show treasure spawn effect
+   * map.showComponentAnimation("treasure-spawn", { x: 150, y: 200 }, {
+   *   sparkle: true,
+   *   sound: "treasure-appear"
+   * });
+   * ```
+   */
+  showComponentAnimation(id, position, params) {
     this.$broadcast({
-      type: "showEffect",
+      type: "showComponentAnimation",
       value: {
-        id: "animation",
-        params: {
-          name: animationName
-        },
-        object: object.id
+        id,
+        params,
+        position
       }
     });
   }
+  /**
+   * Display a spritesheet animation at a specific position on the map
+   * 
+   * This method displays a temporary visual animation using a spritesheet at any
+   * location on the map. It's a convenience method that internally uses showComponentAnimation
+   * with the built-in 'animation' component. This is useful for spell effects, environmental
+   * animations, or any visual feedback that uses predefined spritesheets.
+   * 
+   * @param position - The x, y coordinates where to display the animation
+   * @param graphic - The ID of the spritesheet to use for the animation
+   * @param animationName - The name of the animation within the spritesheet (default: 'default')
+   * 
+   * @example
+   * ```ts
+   * // Show explosion at specific coordinates
+   * map.showAnimation({ x: 100, y: 200 }, "explosion");
+   * 
+   * // Show spell effect at player position
+   * const playerPos = { x: player.x, y: player.y };
+   * map.showAnimation(playerPos, "spell-effects", "lightning");
+   * 
+   * // Show environmental effect
+   * map.showAnimation({ x: 300, y: 150 }, "nature-effects", "wind-gust");
+   * 
+   * // Show portal opening animation
+   * map.showAnimation({ x: 500, y: 400 }, "portals", "opening");
+   * ```
+   */
+  showAnimation(position, graphic, animationName = "default") {
+    this.showComponentAnimation("animation", position, {
+      graphic,
+      animationName
+    });
+  }
 };
 __decorateClass$1([
   users$1(RpgPlayer)