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

package/dist/index.js

@@ -26158,7 +26158,7 @@ function WithMoveManager(Base) {
   return class extends Base {
     constructor() {
       super(...arguments);
-      // Properties for infinite route management
+      // Private properties for infinite route management
       this._infiniteRoutes = null;
       this._finishRoute = null;
       this._isInfiniteRouteActive = false;
@@ -26962,16 +26962,123 @@ class NotificationGui extends Gui {
 }
 
 function WithGuiManager(Base) {
-  class GuiManagerMixin extends Base {
+  return class 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,
@@ -26981,6 +27088,19 @@ 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;
@@ -26990,6 +27110,14 @@ 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;
@@ -27122,12 +27250,23 @@ 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;
@@ -27149,168 +27288,52 @@ 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
-     * // 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());
+     * player.setVariable('OPEN_CHEST', true)
      * ```
-     */
+     * 
+     * @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 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
+     * Get a variable
      * 
-     * @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;
+     * const val = player.getVariable('OPEN_CHEST')
      * ```
-     */
+     * 
+     * @title Get variable
+     * @method player.setVariable(key,val)
+     * @param {string} key
+     * @returns {any} 
+     * @memberof VariableManager
+     * */
     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');
-     * }
+     * player.removeVariable('OPEN_CHEST')
      * ```
-     */
+     * 
+     * @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
+     * */
     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();
-    }
   };
 }
 
@@ -27863,67 +27886,292 @@ class StateLog {
   }
 }
 
-function WithItemManager(Base) {
+function WithStateManager(Base) {
   return class extends Base {
+    constructor() {
+      super(...arguments);
+      this._statesEfficiency = signal$2([]);
+    }
     /**
-     * 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
+     * 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.
      *
      * ```ts
-     * import Potion from 'your-database/potion'
+     * import { Armor, State } from '@rpgjs/server'
      *
-     * 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];
+     * @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 }]
+     * ```
+     * @title Get States Defense
+     * @prop {Array<{ rate: number, state: StateClass}>} player.statesDefense
+     * @readonly
+     * @memberof StateManager
+     * */
+    get statesDefense() {
+      return this.getFeature("statesDefense", "state");
     }
     /**
-     * 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
+     * Set or retrieves all the states where the player is vulnerable or not.
      *
      * ```ts
-     * import Potion from 'your-database/potion'
+     * import { Class, State } from '@rpgjs/server'
      *
-     * player.hasItem(Potion) // false
-     *  ```
-     */
-    hasItem(itemClass) {
-      return !!this.getItem(itemClass);
+     * @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 }]
+     * ```
+     * @title Set/Get States Efficiency
+     * @prop {Array<{ rate: number, state: StateClass}>} player.statesEfficiency
+     * @memberof StateManager
+     * */
+    get statesEfficiency() {
+      return this._statesEfficiency;
     }
-    _getItemIndex(itemClass) {
-      return this.items().findIndex((it) => {
-        if (isString(itemClass)) {
-          return it.id() == itemClass;
+    set statesEfficiency(val) {
+      this._statesEfficiency = val;
+    }
+    applyStates(player, { addStates, removeStates }) {
+      if (addStates) {
+        for (let { state, rate } of addStates) {
+          player.addState(state, rate);
         }
-        return isInstanceOf(it, itemClass);
-      });
+      }
+      if (removeStates) {
+        for (let { state, rate } of removeStates) {
+          player.removeState(state, rate);
+        }
+      }
     }
     /**
-     * Add an item in the player's inventory. You can give more than one by specifying `nb`
+     * 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'
      *
-     * `onAdd()` method is called on the ItemClass
+     * player.getState(Paralyze)
+     *  ```
      *
-     * @title Add Item
-     * @method player.addItem(item,nb=1)
-     * @param {ItemClass} itemClass
-     * @param {number} [nb] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @memberof ItemManager
-     * @example
+     * @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;
+        }
+        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);
+      });
+    }
+    /**
+     * Add an item in the player's inventory. You can give more than one by specifying `nb`
+     *
+     * `onAdd()` method is called on the ItemClass
+     *
+     * @title Add Item
+     * @method player.addItem(item,nb=1)
+     * @param {ItemClass} itemClass
+     * @param {number} [nb] Default 1
+     * @returns {{ nb: number, item: instance of ItemClass }}
+     * @memberof ItemManager
+     * @example
      *
      * ```ts
      * import Potion from 'your-database/potion'
@@ -28334,68 +28582,31 @@ 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'
      *
-     * // Check for skill restriction
-     * const cannotUseSkills = player.hasEffect(Effect.CAN_NOT_SKILL);
-     * if (cannotUseSkills) {
-     *   console.log('Player cannot use skills right now');
-     * }
-     * 
-     * // Check for guard effect
-     * const isGuarding = player.hasEffect(Effect.GUARD);
-     * if (isGuarding) {
-     *   console.log('Player is in guard stance');
-     * }
-     * 
-     * // Check for cost reduction
-     * const halfCost = player.hasEffect(Effect.HALF_SP_COST);
-     * const actualCost = skillCost / (halfCost ? 2 : 1);
+     * const bool = player.hasEffect(Effect.CAN_NOT_SKILL)
      * ```
-     */
+     *
+     * @title Has Effect
+     * @method player.hasEffect(effect)
+     * @param {string} effect
+     * @returns {boolean}
+     * @memberof EffectManager
+     * */
     hasEffect(effect) {
       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)
-     * );
+     * console.log(player.effects)
      * ```
-     */
+     * @title Get Effects
+     * @prop {Array<Effect>} player.effects
+     * @memberof EffectManager
+     * */
     get effects() {
       const getEffects = (prop) => {
         return arrayFlat(this[prop]().map((el) => el.effects || []));
@@ -28409,243 +28620,113 @@ 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'
      *
-     * // Set direct player effects
-     * player.effects = [Effect.CAN_NOT_SKILL];
-     * 
-     * // Add multiple effects
-     * player.effects = [
-     *   Effect.GUARD,
-     *   Effect.HALF_SP_COST,
-     *   Effect.CAN_NOT_ITEM
-     * ];
-     * 
-     * // Clear direct effects (equipment/state effects remain)
-     * player.effects = [];
-     * 
-     * // Temporary effect application
-     * const originalEffects = player.effects;
-     * player.effects = [...originalEffects, Effect.SUPER_GUARD];
-     * // Later restore
-     * player.effects = originalEffects;
+     * player.effects = [Effect.CAN_NOT_SKILL]
      * ```
-     */
+     * @title Set Effects
+     * @prop {Array<Effect>} player.effects
+     * @memberof EffectManager
+     * */
     set effects(val) {
       this._effects.set(val);
     }
   };
 }
 
-function WithElementManager(Base) {
+function WithBattleManager(Base) {
   return class extends Base {
-    constructor() {
-      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)
+     * Apply damage. Player will lose HP. the `attackerPlayer` parameter is the other player, the one who attacks.
      *
-     * 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.
+     * 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
      *
-     * 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));
+     * player.applyDamage(attackerPlayer) // returns { damage: number }
      * ```
-     */
-    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
      *
-     * 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];
+     * @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");
         }
-      }
-      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");
+        damage = fn(paramA, paramB, skill);
+      } else {
+        fn = this.getFormulas("damagePhysic");
         if (!fn) {
-          return coefficient;
+          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;
         }
-        coefficient += fn(
-          atkElement,
-          elementPlayer,
-          elementPlayerDef || { rate: 0 }
-        );
       }
-      return coefficient;
+      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
+      };
+    }
+    getFormulas(name) {
+      const map = this.getCurrentMap();
+      return map.damageFormulas[name];
     }
   };
 }
@@ -28864,176 +28945,23 @@ 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'
      *
-     * // 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
+     * player.setClass(Fighter)
      * ```
-     */
+     *
+     * @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();
@@ -29043,39 +28971,18 @@ 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'
      *
-     * // 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
+     * player.setActor(Hero)
      * ```
-     */
+     *
+     * @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();
@@ -29096,41 +29003,32 @@ function WithClassManager(Base) {
   };
 }
 
-function WithStateManager(Base) {
+function WithElementManager(Base) {
   return class extends Base {
     constructor() {
       super(...arguments);
-      this._statesEfficiency = signal$2([]);
+      this._elementsEfficiency = [];
     }
     /**
-     * Recovers the player's states defense on inventory.  This list is generated from the `statesDefense` property defined on the weapons or armors equipped.
+     * 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 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'
+     * import { Armor } from '@rpgjs/server'
      *
-     * @State({
-     *      name: 'Paralyze'
-     * })
-     * class Paralyze {}
+     * enum Elements {
+     *   Fire = 'fire'
+     * }
      *
      * @Armor({
      *      name: 'Shield',
-     *      statesDefense: [{ rate: 1, state: Paralyze }]
+     *      elementsDefense: [{ rate: 1, element: Elements.Fire }]
      * })
      * class Shield {}
      *
      * @Armor({
      *      name: 'FireShield',
-     *      statesDefense: [{ rate: 0.5, state: Paralyze }]
+     *      elementsDefense: [{ rate: 0.5, element: Elements.Fire }]
      * })
      * class FireShield {}
      *
@@ -29139,291 +29037,100 @@ function WithStateManager(Base) {
      * 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}`);
-     * }
+     * console.log(player.elementsDefense) // [{ rate: 1, element: 'fire' }]
      * ```
-     */
-    get statesDefense() {
-      return this.getFeature("statesDefense", "state");
+     * @title Get Elements Defense
+     * @prop {Array<{ rate: number, element: Element}>} player.elementsDefense
+     * @readonly
+     * @memberof ElementManager
+     * */
+    get elementsDefense() {
+      return this.getFeature("elementsDefense", "element");
     }
     /**
-     * Set or retrieves all the states where the player is vulnerable or not.
+     * Set or retrieves all the elements 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 {}
+     * import { Class } from '@rpgjs/server'
      *
-     * @State({
-     *      name: 'Sleep'
-     * })
-     * class Sleep {}
+     * enum Elements {
+     *   Fire = 'fire',
+     *   Ice = 'ice'
+     * }
      *
      * @Class({
      *      name: 'Fighter',
-     *      statesEfficiency: [{ rate: 1, state: Paralyze }]
+     *      elementsEfficiency: [{ rate: 1, element: Elements.Fire }]
      * })
      * class Hero {}
      *
      * player.setClass(Hero)
      *
-     * console.log(player.statesEfficiency) // [{ rate: 1, instance of Paralyze }]
+     * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }]
      *
-     * player.statesEfficiency = [{ rate: 2, state: Sleep }]
+     * player.elementsEfficiency = [{ rate: 2, element: Elements.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));
-     * ```
-     */
-    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);
+     * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }, { rate: 2, element: 'ice' }]
      * ```
-     */
-    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);
-        }
+     * @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 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);
-      });
+    set elementsEfficiency(val) {
+      this._elementsEfficiency = val;
     }
     /**
-     * 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'
+     * Retrieves a array of elements assigned to the player and the elements of the weapons / armor equipped
      *
-     * 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
-     *   }
-     * });
+     * ```ts
+     * console.log(player.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);
+     * @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];
         }
-        const instance = new stateClass();
-        this.states().push(instance);
-        this.applyStates(this, instance);
-        return instance;
       }
-      return null;
+      return arrayUniq(elements);
     }
-    /**
-     * 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;
-        }
-        return isInstanceOf(state, stateClass);
-      });
-      if (index != -1) {
-        if (Math.random() > chance) {
-          throw StateLog.removeFailed(stateClass);
+    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;
         }
-        this.states().splice(index, 1);
-      } else {
-        throw StateLog.notApplied(stateClass);
+        coefficient += fn(
+          atkElement,
+          elementPlayer,
+          elementPlayerDef || { rate: 0 }
+        );
       }
-    }
-    /**
-     * 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)
-      );
+      return coefficient;
     }
   };
 }
@@ -29440,23 +29147,23 @@ var __decorateClass$2 = (decorators, target, key, kind) => {
 function combinePlayerMixins(mixins) {
   return (Base) => mixins.reduce((ExtendedClass, mixin) => mixin(ExtendedClass), Base);
 }
-const BasicPlayerMixins = combinePlayerMixins([
+const PlayerMixins = combinePlayerMixins([
   WithComponentManager,
   WithEffectManager,
   WithGuiManager,
   WithMoveManager,
   WithGoldManager,
+  WithVariableManager,
   WithParameterManager,
   WithItemFixture,
-  WithItemManager,
-  WithElementManager,
-  WithVariableManager,
   WithStateManager,
-  WithClassManager,
+  WithItemManager,
   WithSkillManager,
-  WithBattleManager
+  WithClassManager,
+  WithBattleManager,
+  WithElementManager
 ]);
-const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
+const _RpgPlayer = class _RpgPlayer extends PlayerMixins(RpgCommonPlayer) {
   constructor() {
     super();
     this.map = null;
@@ -29525,47 +29232,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       value
     });
   }
-  /**
-   * 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
-        }
-      });
-    }
+  showAnimation(params) {
   }
   /**
      * 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
@@ -29635,35 +29302,11 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       }
     );
   }
-  /**
-   * 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) {
+  broadcastEffect(id, params) {
     const map = this.getCurrentMap();
     if (!map) return;
     map.$broadcast({
-      type: "showComponentAnimation",
+      type: "showEffect",
       value: {
         id,
         params,
@@ -29671,45 +29314,8 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(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.showComponentAnimation("hit", {
+    this.broadcastEffect("hit", {
       text,
       direction: this.direction()
     });
@@ -29737,7 +29343,6 @@ class RpgEvent extends RpgPlayer {
 }
 
 const context$1 = new Context();
-context$1["side"] = "server";
 
 var __defProp$1 = Object.defineProperty;
 var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
@@ -29928,84 +29533,18 @@ let RpgMap = class extends RpgCommonMap {
   removeEvent(eventId) {
     delete this.events()[eventId];
   }
-  /**
-   * 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) {
+  showAnimation(animationName, object) {
     this.$broadcast({
-      type: "showComponentAnimation",
+      type: "showEffect",
       value: {
-        id,
-        params,
-        position
+        id: "animation",
+        params: {
+          name: animationName
+        },
+        object: object.id
       }
     });
   }
-  /**
-   * 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)