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

package/dist/index.js

@@ -6095,6 +6095,19 @@ function computed$2(computeFunction, disposableFn) {
   return fn;
 }
 __name$5(computed$2, "computed");
+function untracked(fn) {
+  const prevDepTracker = reactiveStore$2.currentDependencyTracker;
+  const prevSubTracker = reactiveStore$2.currentSubscriptionsTracker;
+  reactiveStore$2.currentDependencyTracker = null;
+  reactiveStore$2.currentSubscriptionsTracker = null;
+  try {
+    return fn();
+  } finally {
+    reactiveStore$2.currentDependencyTracker = prevDepTracker;
+    reactiveStore$2.currentSubscriptionsTracker = prevSubTracker;
+  }
+}
+__name$5(untracked, "untracked");
 
 // src/effect.ts
 function effect$2(fn) {
@@ -6443,6 +6456,8 @@ function loadValue$1(rootInstance, parts, value) {
         Reflect.deleteProperty(current, part);
       } else if (current[part]?._subject) {
         current[part].set(value);
+      } else if (isSignal$2(current) && Array.isArray(current()) && !isNaN(Number(part))) {
+        current()[Number(part)] = value;
       } else {
         current[part] = value;
       }
@@ -7404,6 +7419,101 @@ var Server = class {
     instance.$broadcast = (obj) => {
       return this.broadcast(obj, instance);
     };
+    instance.$sessionTransfer = async (userOrPublicId, targetRoomId) => {
+      let user;
+      let publicId = null;
+      const signal2 = this.getUsersProperty(instance);
+      if (!signal2) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      if (typeof userOrPublicId === "string") {
+        publicId = userOrPublicId;
+        user = signal2()[publicId];
+        if (!user) {
+          console.error(`[sessionTransfer] User with publicId ${publicId} not found.`);
+          return null;
+        }
+      } else {
+        user = userOrPublicId;
+        const users = signal2();
+        for (const [id2, u] of Object.entries(users)) {
+          if (u === user) {
+            publicId = id2;
+            break;
+          }
+        }
+        if (!publicId && user && typeof user === "object") {
+          for (const [id2, u] of Object.entries(users)) {
+            if (u && typeof u === "object") {
+              if (u.constructor === user.constructor) {
+                publicId = id2;
+                break;
+              }
+            }
+          }
+        }
+        if (!publicId) {
+          console.error("[sessionTransfer] User not found in users collection.", {
+            userType: user?.constructor?.name,
+            userKeys: user ? Object.keys(user) : "null",
+            usersCount: Object.keys(users).length,
+            userIds: Object.keys(users)
+          });
+          return null;
+        }
+      }
+      const sessions = await this.room.storage.list();
+      let userSession = null;
+      let privateId = null;
+      for (const [key, session] of sessions) {
+        if (key.startsWith("session:") && session.publicId === publicId) {
+          userSession = session;
+          privateId = key.replace("session:", "");
+          break;
+        }
+      }
+      if (!userSession || !privateId) {
+        console.error(`[sessionTransfer] Session for publicId ${publicId} not found.`);
+        return null;
+      }
+      const usersPropName = this.getUsersPropName(instance);
+      if (!usersPropName) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      const userSnapshot = createStatesSnapshot$1(user);
+      const transferData = {
+        privateId,
+        userSnapshot,
+        sessionState: userSession.state,
+        publicId
+      };
+      try {
+        const targetRoomParty = this.room.context.parties.main.get(targetRoomId);
+        const response2 = await targetRoomParty.fetch("/session-transfer", {
+          method: "POST",
+          body: JSON.stringify(transferData),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response2.ok) {
+          throw new Error(`Transfer request failed: ${await response2.text()}`);
+        }
+        const { transferToken } = await response2.json();
+        await this.deleteSession(privateId);
+        await this.room.storage.delete(`${usersPropName}.${publicId}`);
+        const currentUsers = signal2();
+        if (currentUsers[publicId]) {
+          delete currentUsers[publicId];
+        }
+        return transferToken;
+      } catch (error) {
+        console.error(`[sessionTransfer] Failed to transfer session to room ${targetRoomId}:`, error);
+        return null;
+      }
+    };
     const syncCb = /* @__PURE__ */ __name$3((values) => {
       if (options.getMemoryAll) {
         buildObject(values, instance.$memoryAll);
@@ -7594,29 +7704,46 @@ var Server = class {
     });
     const roomGuards = subRoom.constructor["_roomGuards"] || [];
     for (const guard of roomGuards) {
-      const isAuthorized = await guard(conn, ctx);
+      const isAuthorized = await guard(conn, ctx, this.room);
       if (!isAuthorized) {
         conn.close();
         return;
       }
     }
+    let transferToken = null;
+    if (ctx.request?.url) {
+      const url = new URL(ctx.request.url);
+      transferToken = url.searchParams.get("transferToken");
+    }
+    let transferData = null;
+    if (transferToken) {
+      transferData = await this.room.storage.get(`transfer:${transferToken}`);
+      if (transferData) {
+        await this.room.storage.delete(`transfer:${transferToken}`);
+      }
+    }
     const existingSession = await this.getSession(conn.id);
-    const publicId = existingSession?.publicId || generateShortUUID$2();
+    const publicId = existingSession?.publicId || transferData?.publicId || generateShortUUID$2();
     let user = null;
     const signal2 = this.getUsersProperty(subRoom);
     const usersPropName = this.getUsersPropName(subRoom);
     if (signal2) {
       const { classType } = signal2.options;
       if (!existingSession?.publicId) {
-        user = isClass(classType) ? new classType() : classType(conn, ctx);
-        signal2()[publicId] = user;
-        const snapshot = createStatesSnapshot$1(user);
-        this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        if (transferData?.restored && signal2()[publicId]) {
+          user = signal2()[publicId];
+        } else {
+          user = isClass(classType) ? new classType() : classType(conn, ctx);
+          signal2()[publicId] = user;
+          const snapshot = createStatesSnapshot$1(user);
+          this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        }
       } else {
         user = signal2()[existingSession.publicId];
       }
       if (!existingSession) {
-        await this.saveSession(conn.id, {
+        const sessionPrivateId = transferData?.privateId || conn.id;
+        await this.saveSession(sessionPrivateId, {
           publicId
         });
       } else {
@@ -7904,7 +8031,7 @@ var Server = class {
   * @method onClose
   * @async
   * @param {Party.Connection} conn - The connection object of the disconnecting user.
-  * @description Handles user disconnection, removing them from the room and triggering the onLeave event.
+  * @description Handles user disconnection, removing them from the room and triggering the onLeave event..
   * @returns {Promise<void>}
   * 
   * @example
@@ -7970,6 +8097,58 @@ var Server = class {
     return this.handleDirectRequest(req, res);
   }
   /**
+  * @method handleSessionRestore
+  * @private
+  * @async
+  * @param {Party.Request} req - The HTTP request for session restore
+  * @param {ServerResponse} res - The response object
+  * @description Handles session restoration from transfer data, creates session from privateId
+  * @returns {Promise<Response>} The response to return to the client
+  */
+  async handleSessionRestore(req, res) {
+    try {
+      const transferData = await req.json();
+      const { privateId, userSnapshot, sessionState, publicId } = transferData;
+      if (!privateId || !publicId) {
+        return res.badRequest("Missing privateId or publicId in transfer data");
+      }
+      const subRoom = await this.getSubRoom();
+      if (!subRoom) {
+        return res.serverError("Room not available");
+      }
+      await this.saveSession(privateId, {
+        publicId,
+        state: sessionState,
+        created: Date.now(),
+        connected: false
+        // Will be set to true when user connects
+      });
+      if (userSnapshot) {
+        const signal2 = this.getUsersProperty(subRoom);
+        const usersPropName = this.getUsersPropName(subRoom);
+        if (signal2 && usersPropName) {
+          const { classType } = signal2.options;
+          const user = isClass(classType) ? new classType() : classType();
+          load$1(user, userSnapshot, true);
+          signal2()[publicId] = user;
+          await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
+        }
+      }
+      const transferToken = generateShortUUID$2();
+      await this.room.storage.put(`transfer:${transferToken}`, {
+        privateId,
+        publicId,
+        restored: true
+      });
+      return res.success({
+        transferToken
+      });
+    } catch (error) {
+      console.error("Error restoring session:", error);
+      return res.serverError("Failed to restore session");
+    }
+  }
+  /**
   * @method handleDirectRequest
   * @private
   * @async
@@ -7982,6 +8161,10 @@ var Server = class {
     if (!subRoom) {
       return res.notFound();
     }
+    const url = new URL(req.url);
+    if (url.pathname.endsWith("/session-transfer") && req.method === "POST") {
+      return this.handleSessionRestore(req, res);
+    }
     const response2 = await this.tryMatchRequestHandler(req, res, subRoom);
     if (response2) {
       return response2;
@@ -8080,7 +8263,7 @@ var Server = class {
   */
   pathMatches(requestPath, handlerPath) {
     const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     return pathRegex.test(requestPath);
   }
   /**
@@ -8100,7 +8283,7 @@ var Server = class {
       }
     });
     const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     const matches = requestPath.match(pathRegex);
     if (matches && matches.length > 1) {
       for (let i = 0; i < paramNames.length; i++) {
@@ -9208,6 +9391,30 @@ WorldRoom = _ts_decorate([
   ])
 ], WorldRoom);
 
+// src/session.guard.ts
+function createRequireSessionGuard(storage) {
+  return async (sender, value) => {
+    if (!sender || !sender.id) {
+      return false;
+    }
+    try {
+      const session = await storage.get(`session:${sender.id}`);
+      if (!session) {
+        return false;
+      }
+      const typedSession = session;
+      if (!typedSession.publicId) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("Error checking session in requireSession guard:", error);
+      return false;
+    }
+  };
+}
+__name$3(createRequireSessionGuard, "createRequireSessionGuard");
+
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {
     const e = m[i];
@@ -11477,6 +11684,8 @@ var Direction = /* @__PURE__ */ ((Direction2) => {
 })(Direction || {});
 class RpgCommonPlayer {
   constructor() {
+    this.name = signal("");
+    this.type = signal("");
     this.x = signal(0);
     this.y = signal(0);
     this.z = signal(0);
@@ -11491,8 +11700,8 @@ class RpgCommonPlayer {
     });
     this._gold = signal(0);
     this.animationName = signal("stand");
-    this._hp = signal(0);
-    this._sp = signal(0);
+    this.hpSignal = signal(0);
+    this.spSignal = signal(0);
     this._exp = signal(0);
     this._level = signal(0);
     this._class = signal({});
@@ -11510,14 +11719,14 @@ class RpgCommonPlayer {
   }
   /**
    * Change the player's facing direction
-   * 
+   *
    * Updates the direction the player is facing, which affects animations
    * and directional abilities. This should be called when the player
    * intends to move in a specific direction, not when they are pushed
    * by physics or sliding.
-   * 
+   *
    * @param direction - The new direction to face
-   * 
+   *
    * @example
    * ```ts
    * // Player presses right arrow key
@@ -11529,9 +11738,9 @@ class RpgCommonPlayer {
   }
   /**
    * Get the current facing direction
-   * 
+   *
    * @returns Current direction the player is facing
-   * 
+   *
    * @example
    * ```ts
    * const currentDirection = player.getDirection();
@@ -11545,18 +11754,18 @@ class RpgCommonPlayer {
   }
   /**
    * Set the intended movement direction
-   * 
+   *
    * This should be called when the player intends to move in a direction,
    * typically from input handling. This direction will be used to update
    * the player's facing direction regardless of physics interactions.
-   * 
+   *
    * @param direction - The intended movement direction, or null if not moving
-   * 
+   *
    * @example
    * ```ts
    * // Player presses down arrow key
    * player.setIntendedDirection(Direction.Down);
-   * 
+   *
    * // Player releases all movement keys
    * player.setIntendedDirection(null);
    * ```
@@ -11569,9 +11778,9 @@ class RpgCommonPlayer {
   }
   /**
    * Get the intended movement direction
-   * 
+   *
    * @returns The direction the player intends to move, or null if not moving
-   * 
+   *
    * @example
    * ```ts
    * const intended = player.getIntendedDirection();
@@ -11585,14 +11794,14 @@ class RpgCommonPlayer {
   }
   /**
    * Apply physics body position to player coordinates
-   * 
+   *
    * Synchronizes the player's position with their physics body after
    * physics calculations. This method no longer automatically changes
    * the player's direction based on position changes, as direction
    * should be controlled by intended movement instead.
-   * 
+   *
    * @param body - The Matter.js physics body
-   * 
+   *
    * @example
    * ```ts
    * // Called automatically by physics system
@@ -11610,6 +11819,43 @@ class RpgCommonPlayer {
       this.y.set(topLeftY);
     }
   }
+  /**
+   * 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
+    });
+  }
   _showAnimation(params) {
     const { graphic, animationName, loop } = params;
     if (graphic) {
@@ -11622,20 +11868,20 @@ class RpgCommonPlayer {
   }
   /**
    * Create a temporary and moving hitbox relative to the player's position
-   * 
+   *
    * Creates a temporary hitbox that moves through multiple positions sequentially,
    * with all coordinates being relative to the player's current position.
    * For example, you can use it for player attacks, spells, or area effects
    * that should follow the player's position.
-   * 
+   *
    * The method creates a zone sensor that moves through the specified hitbox positions
    * at the given speed, detecting collisions with other players and events at each step.
-   * 
+   *
    * @param hitboxes - Array of hitbox positions relative to player position
    * @param options - Configuration options for the movement
    * @param map - Reference to the map instance for physics access
    * @returns Observable that emits arrays of hit entities and completes when movement is finished
-   * 
+   *
    * @example
    * ```ts
    * // Create a forward attack relative to player position
@@ -11665,10 +11911,22 @@ class RpgCommonPlayer {
   getCurrentMap() {
     return this["map"];
   }
+  get hp() {
+    return this.hpSignal();
+  }
+  get sp() {
+    return this.spSignal();
+  }
 }
 __decorateClass$3([
   id()
 ], RpgCommonPlayer.prototype, "id");
+__decorateClass$3([
+  sync()
+], RpgCommonPlayer.prototype, "name");
+__decorateClass$3([
+  sync()
+], RpgCommonPlayer.prototype, "type");
 __decorateClass$3([
   sync()
 ], RpgCommonPlayer.prototype, "x");
@@ -11704,10 +11962,10 @@ __decorateClass$3([
 ], RpgCommonPlayer.prototype, "animationName");
 __decorateClass$3([
   sync()
-], RpgCommonPlayer.prototype, "_hp");
+], RpgCommonPlayer.prototype, "hpSignal");
 __decorateClass$3([
   sync()
-], RpgCommonPlayer.prototype, "_sp");
+], RpgCommonPlayer.prototype, "spSignal");
 __decorateClass$3([
   sync()
 ], RpgCommonPlayer.prototype, "_exp");
@@ -23281,32 +23539,61 @@ class RpgCommonPhysic {
       return dy > 0 ? Direction.Down : Direction.Up;
     }
   }
-  /**
-   * Add a static hitbox (immovable objects like walls, obstacles)
-   * 
-   * @param id - Unique identifier for the hitbox
-   * @param x - X position
-   * @param y - Y position
-   * @param width - Width of hitbox
-   * @param height - Height of hitbox
-   * @returns The id of the created hitbox
-   * 
-   * @example
-   * ```ts
-   * // Add a wall
-   * physic.addStaticHitbox('wall1', 100, 50, 32, 128);
-   * ```
-   */
-  addStaticHitbox(id, x, y, width, height) {
+  addStaticHitbox(id, xOrPoints, y, width, height) {
     if (this.hitboxes.has(id)) {
       throw new Error(`Hitbox with id ${id} already exists`);
     }
-    const centerX = x + width / 2;
-    const centerY = y + height / 2;
-    const body = matterExports.Bodies.rectangle(centerX, centerY, width, height, {
-      isStatic: true,
-      label: id
-    });
+    let body;
+    if (Array.isArray(xOrPoints)) {
+      const points = xOrPoints;
+      if (points.length < 3) {
+        throw new Error(`Polygon must have at least 3 points, got ${points.length}`);
+      }
+      for (let i = 0; i < points.length; i++) {
+        const point = points[i];
+        if (!Array.isArray(point) || point.length !== 2 || typeof point[0] !== "number" || typeof point[1] !== "number") {
+          throw new Error(`Invalid point at index ${i}: ${JSON.stringify(point)}. Expected [x, y] with numbers.`);
+        }
+      }
+      let centerX = 0, centerY = 0;
+      for (const point of points) {
+        centerX += point[0];
+        centerY += point[1];
+      }
+      centerX /= points.length;
+      centerY /= points.length;
+      const vertices = points.map((point) => ({
+        x: point[0] - centerX,
+        y: point[1] - centerY
+      }));
+      try {
+        body = matterExports.Bodies.fromVertices(0, 0, [vertices], {
+          isStatic: true,
+          label: id
+        });
+        if (!body) {
+          throw new Error(`Matter.Bodies.fromVertices returned null/undefined`);
+        }
+        if (!body.vertices || body.vertices.length === 0) {
+          throw new Error(`Created body has no vertices`);
+        }
+        matterExports.Body.setPosition(body, { x: centerX, y: centerY });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to create polygon body from points ${JSON.stringify(points)}: ${errorMessage}`);
+      }
+    } else {
+      const x = xOrPoints;
+      if (y === void 0 || width === void 0 || height === void 0) {
+        throw new Error("Rectangle hitbox requires x, y, width, and height parameters");
+      }
+      const centerX = x + width / 2;
+      const centerY = y + height / 2;
+      body = matterExports.Bodies.rectangle(centerX, centerY, width, height, {
+        isStatic: true,
+        label: id
+      });
+    }
     matterExports.Composite.add(this.world, body);
     this.hitboxes.set(id, {
       id,
@@ -23890,6 +24177,39 @@ class RpgCommonPhysic {
   getWorld() {
     return this.world;
   }
+  /**
+   * Get debug information about all hitboxes
+   * 
+   * Useful for debugging collision issues
+   * 
+   * @returns Array of hitbox debug information
+   * 
+   * @example
+   * ```ts
+   * // Debug all hitboxes
+   * const info = physic.getDebugInfo();
+   * console.log('All hitboxes:', info);
+   * ```
+   */
+  getDebugInfo() {
+    const info = [];
+    for (const [id, hitboxData] of this.hitboxes.entries()) {
+      const body = hitboxData.body;
+      info.push({
+        id,
+        type: hitboxData.type,
+        position: { x: body.position.x, y: body.position.y },
+        bounds: {
+          min: { x: body.bounds.min.x, y: body.bounds.min.y },
+          max: { x: body.bounds.max.x, y: body.bounds.max.y }
+        },
+        verticesCount: body.vertices.length,
+        isPolygon: body.vertices.length > 4
+        // Rectangles have 4 vertices
+      });
+    }
+    return info;
+  }
   /* ----------------------------------------------------------------------- */
   /*                               ZONES                                    */
   /* ----------------------------------------------------------------------- */
@@ -25321,7 +25641,11 @@ class RpgCommonMap {
     this.physic.addStaticHitbox("map-height-top", 0, -100, this.data().width, gap);
     this.physic.addStaticHitbox("map-height-bottom", 0, this.data().height, this.data().width, gap);
     for (let staticHitbox of hitboxes) {
-      this.physic.addStaticHitbox(staticHitbox.id ?? generateShortUUID(), staticHitbox.x, staticHitbox.y, staticHitbox.width, staticHitbox.height);
+      if ("x" in staticHitbox) {
+        this.physic.addStaticHitbox(staticHitbox.id ?? generateShortUUID(), staticHitbox.x, staticHitbox.y, staticHitbox.width, staticHitbox.height);
+      } else if ("points" in staticHitbox) {
+        this.physic.addStaticHitbox(staticHitbox.id ?? generateShortUUID(), staticHitbox.points);
+      }
     }
     this.events.observable.subscribe(({ value: event, type }) => {
       if (type == "add") {
@@ -25794,8 +26118,50 @@ function mergeConfig(baseConfig, config) {
 __name(mergeConfig, "mergeConfig");
 
 // src/provider.ts
+function getDeps(provider) {
+  if (typeof provider === "function") {
+    return provider.deps ?? [];
+  }
+  return provider.deps ?? [];
+}
+__name(getDeps, "getDeps");
+function sortProviders(providers) {
+  const tokenName = /* @__PURE__ */ __name((t) => typeof t === "function" ? t.name : t, "tokenName");
+  const map = /* @__PURE__ */ new Map();
+  for (const p of providers) {
+    const token = tokenName(typeof p === "function" ? p : p.provide);
+    map.set(token, p);
+  }
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((token) => {
+    const name = tokenName(token);
+    if (visited.has(name)) return;
+    if (stack.has(name)) {
+      throw new Error(`Circular dependency detected for provider ${name}`);
+    }
+    stack.add(name);
+    const provider = map.get(name);
+    if (provider) {
+      for (const dep of getDeps(provider)) {
+        visit(dep);
+      }
+      visited.add(name);
+      result.push(provider);
+    }
+    stack.delete(name);
+  }, "visit");
+  for (const p of providers) {
+    const token = typeof p === "function" ? p : p.provide;
+    visit(token);
+  }
+  return result;
+}
+__name(sortProviders, "sortProviders");
 async function injector(context, providers) {
   providers = providers.flat();
+  providers = sortProviders(providers);
   for (const provider of providers) {
     let token;
     let instance;
@@ -26856,6 +27222,12 @@ function WithMoveManager(Base) {
   };
 }
 
+var DialogPosition = /* @__PURE__ */ ((DialogPosition2) => {
+  DialogPosition2["Top"] = "top";
+  DialogPosition2["Bottom"] = "bottom";
+  DialogPosition2["Middle"] = "middle";
+  return DialogPosition2;
+})(DialogPosition || {});
 class DialogGui extends Gui {
   constructor(player) {
     super(PrebuiltGui.Dialog, player);
@@ -26881,7 +27253,8 @@ class DialogGui extends Gui {
       // remove value property. It is not useful to know this on the client side.
       choices: options.choices.map((choice) => ({
         text: choice.text
-      }))
+      })),
+      face: options.face
     };
     return super.open({
       message,
@@ -27380,8 +27753,63 @@ function WithParameterManager(Base) {
   return class extends Base {
     constructor() {
       super(...arguments);
-      this._paramsModifier = {};
-      this._parameters = /* @__PURE__ */ new Map();
+      /**
+       * Signal for parameter modifiers - allows reactive updates when modifiers change
+       * 
+       * This signal tracks temporary parameter modifications from equipment, states, etc.
+       * When updated, it automatically triggers recalculation of all computed parameters.
+       * 
+       * @example
+       * ```ts
+       * // Set modifier that adds 100 to MaxHP
+       * player.paramsModifier = {
+       *   [MAXHP]: { value: 100 }
+       * };
+       * 
+       * // Parameters automatically recalculate
+       * console.log(player.param[MAXHP]); // Updated value
+       * ```
+       */
+      this._paramsModifierSignal = signal$2({});
+      /**
+       * Signal for base parameters configuration
+       * 
+       * Stores the start and end values for each parameter's level curve.
+       * Changes to this signal trigger recalculation of all parameter values.
+       */
+      this._parametersSignal = signal$2({});
+      /**
+       * Computed signal for all parameter values
+       * 
+       * Automatically recalculates all parameter values when level or modifiers change.
+       * This provides reactive parameter updates throughout the system.
+       * 
+       * @example
+       * ```ts
+       * // Access reactive parameters
+       * const maxHp = player.param[MAXHP]; // Always current value
+       * 
+       * // Parameters update automatically when level changes
+       * player.level = 10;
+       * console.log(player.param[MAXHP]); // New calculated value
+       * ```
+       */
+      this._param = type$1(computed$2(() => {
+        const obj = {};
+        const parameters = this._parametersSignal();
+        const level = this._level();
+        for (const [name, paramConfig] of Object.entries(parameters)) {
+          let curveVal = Math.floor((paramConfig.end - paramConfig.start) * ((level - 1) / (this.finalLevel - this.initialLevel))) + paramConfig.start;
+          const allModifiers = this._getAggregatedModifiers();
+          const modifier = allModifiers[name];
+          if (modifier) {
+            if (modifier.rate) curveVal *= modifier.rate;
+            if (modifier.value) curveVal += modifier.value;
+          }
+          obj[name] = curveVal;
+        }
+        return obj;
+      }), "_param", {}, this);
       /** 
       * ```ts
       * player.initialLevel = 5
@@ -27405,6 +27833,52 @@ function WithParameterManager(Base) {
        * */
       this.finalLevel = 99;
     }
+    /**
+     * Aggregates parameter modifiers from all sources (direct modifiers, states, equipment)
+     * 
+     * This method combines modifiers from multiple sources and calculates the final
+     * modifier values for each parameter. It handles both value and rate modifiers.
+     * 
+     * @returns Aggregated parameter modifiers
+     * 
+     * @example
+     * ```ts
+     * // Internal usage - gets modifiers from all sources
+     * const modifiers = this._getAggregatedModifiers();
+     * console.log(modifiers[MAXHP]); // { value: 100, rate: 1.2 }
+     * ```
+     */
+    _getAggregatedModifiers() {
+      const params = {};
+      const paramsAvg = {};
+      const changeParam = (paramsModifier) => {
+        for (let key in paramsModifier) {
+          const { rate, value } = paramsModifier[key];
+          if (!params[key]) params[key] = { rate: 0, value: 0 };
+          if (!paramsAvg[key]) paramsAvg[key] = 0;
+          if (value) params[key].value += value;
+          if (rate !== void 0) params[key].rate += rate;
+          paramsAvg[key]++;
+        }
+      };
+      const getModifier = (prop) => {
+        if (!isString(prop)) {
+          changeParam(prop);
+          return;
+        }
+        for (let el of this[prop]()) {
+          if (!el.paramsModifier) continue;
+          changeParam(el.paramsModifier);
+        }
+      };
+      getModifier(this._paramsModifierSignal());
+      getModifier("states");
+      getModifier("equipments");
+      for (let key in params) {
+        params[key].rate /= paramsAvg[key];
+      }
+      return params;
+    }
     /** 
      * Changes the health points
      * - Cannot exceed the MaxHP parameter
@@ -27426,10 +27900,7 @@ function WithParameterManager(Base) {
         this["execMethod"]("onDead");
         val = 0;
       }
-      this._hp.set(val);
-    }
-    get hp() {
-      return this._hp();
+      this.hpSignal.set(val);
     }
     /** 
      * Changes the skill points
@@ -27448,10 +27919,7 @@ function WithParameterManager(Base) {
       if (val > this.param[MAXSP]) {
         val = this.param[MAXSP];
       }
-      this._sp.set(val);
-    }
-    get sp() {
-      return this._sp();
+      this.spSignal.set(val);
     }
     /** 
      * Changing the player's experience. 
@@ -27557,42 +28025,10 @@ function WithParameterManager(Base) {
      * @memberof ParameterManager
      * */
     get param() {
-      const obj = {};
-      this._parameters.forEach((val, name) => {
-        obj[name] = this.getParamValue(name);
-      });
-      return obj;
+      return this._param();
     }
     get paramsModifier() {
-      const params = {};
-      const paramsAvg = {};
-      const changeParam = (paramsModifier) => {
-        for (let key in paramsModifier) {
-          const { rate, value } = paramsModifier[key];
-          if (!params[key]) params[key] = { rate: 0, value: 0 };
-          if (!paramsAvg[key]) paramsAvg[key] = 0;
-          if (value) params[key].value += value;
-          if (rate !== void 0) params[key].rate += rate;
-          paramsAvg[key]++;
-        }
-      };
-      const getModifier = (prop) => {
-        if (!isString(prop)) {
-          changeParam(prop);
-          return;
-        }
-        for (let el of this[prop]()) {
-          if (!el.paramsModifier) continue;
-          changeParam(el.paramsModifier);
-        }
-      };
-      getModifier(this._paramsModifier);
-      getModifier("states");
-      getModifier("equipments");
-      for (let key in params) {
-        params[key].rate /= paramsAvg[key];
-      }
-      return params;
+      return this._paramsModifierSignal();
     }
     /** 
      * Changes the values of some parameters
@@ -27652,13 +28088,13 @@ function WithParameterManager(Base) {
      * @memberof ParameterManager
      * */
     set paramsModifier(val) {
-      this._paramsModifier = val;
+      this._paramsModifierSignal.set(val);
     }
     get parameters() {
-      return this._parameters;
+      return this._parametersSignal();
     }
     set parameters(val) {
-      this._parameters = val;
+      this._parametersSignal.set(val);
     }
     _expForLevel(level) {
       const {
@@ -27669,22 +28105,8 @@ function WithParameterManager(Base) {
       } = this.expCurve;
       return Math.round(basis * Math.pow(level - 1, 0.9 + accelerationA / 250) * level * (level + 1) / (6 + Math.pow(level, 2) / 50 / accelerationB) + (level - 1) * extra);
     }
-    getParam(name) {
-      const features = this._parameters.get(name);
-      if (!features) {
-        throw `Parameter ${name} not exists. Please use addParameter() before`;
-      }
-      return features;
-    }
     getParamValue(name) {
-      const features = this.getParam(name);
-      let curveVal = Math.floor((features.end - features.start) * ((this.level - 1) / (this.finalLevel - this.initialLevel))) + features.start;
-      const modifier = this.paramsModifier[name];
-      if (modifier) {
-        if (modifier.rate) curveVal *= modifier.rate;
-        if (modifier.value) curveVal += modifier.value;
-      }
-      return curveVal;
+      return this.param[name];
     }
     /** 
      * Give a new parameter. Give a start value and an end value. 
@@ -27705,15 +28127,17 @@ function WithParameterManager(Base) {
      * 
      * @title Add custom parameters
      * @method player.addParameter(name,curve)
-     * @param {name} name 
-     * @param {object} curve Scheme of the object: { start: number, end: number }
+     * @param {string} name - The name of the parameter
+     * @param {object} curve - Scheme of the object: { start: number, end: number }
      * @returns {void}
      * @memberof ParameterManager
      * */
     addParameter(name, { start, end }) {
-      this._parameters.set(name, {
-        start,
-        end
+      this._parametersSignal.mutate((parameters) => {
+        parameters[name] = {
+          start,
+          end
+        };
       });
       const maxHp = this.param[MAXHP];
       const maxSp = this.param[MAXSP];
@@ -27739,7 +28163,7 @@ function WithParameterManager(Base) {
      * 
      * @title Recovery HP and/or SP
      * @method player.recovery(params)
-     * @param {object} params Scheme of the object: { hp: number, sp: number }. The values of the numbers must be in 0 and 1
+     * @param {object} params - Scheme of the object: { hp: number, sp: number }. The values of the numbers must be in 0 and 1
      * @returns {void}
      * @memberof ParameterManager
      * */
@@ -29476,13 +29900,18 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     this.addParameter(AGI, AGI_CURVE);
     this.allRecovery();
   }
+  _onInit() {
+    this.hooks.callHooks("server-playerProps-load", this).subscribe();
+  }
+  get hooks() {
+    return inject$1(this.context, ModulesToken);
+  }
   async execMethod(method, methodData = [], target) {
     let ret;
     if (target) {
       ret = await target[method](...methodData);
     } else {
-      const hooks = inject$1(this.context, ModulesToken);
-      ret = await lastValueFrom(hooks.callHooks(`server-player-${method}`, target ?? this, ...methodData));
+      ret = await lastValueFrom(this.hooks.callHooks(`server-player-${method}`, target ?? this, ...methodData));
     }
     this.syncChanges();
     return ret;
@@ -29504,6 +29933,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
    * ```
    */
   async changeMap(mapId, positions) {
+    this.getCurrentMap();
     this.emit("changeMap", {
       mapId: "map-" + mapId,
       positions
@@ -29517,14 +29947,25 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   getCurrentMap() {
     return this.map;
   }
-  emit(type, value) {
+  emit(type2, value) {
     const map = this.getCurrentMap();
     if (!map || !this.conn) return;
     map.$send(this.conn, {
-      type,
+      type: type2,
       value
     });
   }
+  async save() {
+    const snapshot = createStatesSnapshot$1(this);
+    await lastValueFrom(this.hooks.callHooks("server-player-onSave", this, snapshot));
+    return JSON.stringify(snapshot);
+  }
+  async load(snapshot) {
+    const data = JSON.parse(snapshot);
+    const dataLoaded = load$1(this, data);
+    await lastValueFrom(this.hooks.callHooks("server-player-onLoad", this, dataLoaded));
+    return dataLoaded;
+  }
   /**
    * Set the current animation of the player's sprite
    * 
@@ -29659,7 +30100,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
    * });
    * ```
    */
-  showComponentAnimation(id, params) {
+  showComponentAnimation(id, params = {}) {
     const map = this.getCurrentMap();
     if (!map) return;
     map.$broadcast({
@@ -29671,49 +30112,24 @@ 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", {
       text,
       direction: this.direction()
     });
   }
+  /**
+   * Set the sync schema for the map
+   * @param schema - The schema to set
+   */
+  setSync(schema) {
+    for (let key in schema) {
+      this[key] = type$1(signal$2(null), key, {
+        syncWithClient: schema[key]?.$syncWithClient,
+        persist: schema[key]?.$permanent
+      }, this);
+    }
+  }
 };
 __decorateClass$2([
   sync$1(_RpgPlayer)
@@ -29721,8 +30137,7 @@ __decorateClass$2([
 let RpgPlayer = _RpgPlayer;
 class RpgEvent extends RpgPlayer {
   async execMethod(methodName, methodData = [], instance = this) {
-    const hooks = inject$1(this.context, ModulesToken);
-    await lastValueFrom(hooks.callHooks(`server-event-${methodName}`, instance, ...methodData));
+    await lastValueFrom(this.hooks.callHooks(`server-event-${methodName}`, instance, ...methodData));
     if (!instance[methodName]) {
       return;
     }
@@ -29774,6 +30189,7 @@ let RpgMap = class extends RpgCommonMap {
     }, () => {
       player.animationName.set("stand");
     });
+    player._onInit();
     this.dataIsReady$.pipe(
       finalize$1(() => {
         this.hooks.callHooks("server-player-onJoinMap", player, this).subscribe();
@@ -29913,6 +30329,7 @@ let RpgMap = class extends RpgCommonMap {
     eventInstance.context = context$1;
     eventInstance.x.set(x);
     eventInstance.y.set(y);
+    if (event.name) eventInstance.name.set(event.name);
     this.events()[id] = eventInstance;
     await eventInstance.execMethod("onInit");
   }
@@ -29925,6 +30342,12 @@ let RpgMap = class extends RpgCommonMap {
   getEvents() {
     return Object.values(this.events());
   }
+  getEventBy(cb) {
+    return this.getEventsBy(cb)[0];
+  }
+  getEventsBy(cb) {
+    return this.getEvents().filter(cb);
+  }
   removeEvent(eventId) {
     delete this.events()[eventId];
   }
@@ -30006,6 +30429,18 @@ let RpgMap = class extends RpgCommonMap {
       animationName
     });
   }
+  /**
+   * Set the sync schema for the map
+   * @param schema - The schema to set
+   */
+  setSync(schema) {
+    for (let key in schema) {
+      this[key] = type$1(signal$2(null), key, {
+        syncWithClient: schema[key]?.$syncWithClient,
+        persist: schema[key]?.$permanent
+      }, this);
+    }
+  }
 };
 __decorateClass$1([
   users$1(RpgPlayer)
@@ -30111,6 +30546,16 @@ function provideServerModules(modules) {
       if ("server" in module) {
         module = module.server;
       }
+      if (module.player?.props) {
+        module = {
+          ...module,
+          playerProps: {
+            load: (player) => {
+              player.setSync(module.player.props);
+            }
+          }
+        };
+      }
       if (module.maps && Array.isArray(module.maps)) {
         const maps = [...module.maps];
         module = {
@@ -30130,5 +30575,5 @@ function provideServerModules(modules) {
   });
 }
 
-export { AGI, AGI_CURVE, ATK, COEFFICIENT_ELEMENTS, DAMAGE_CRITICAL, DAMAGE_GUARD, DAMAGE_PHYSIC, DAMAGE_SKILL, DEX, DEX_CURVE, Frequency, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, Move, PDEF, RpgEvent, RpgMap, RpgPlayer, RpgServerEngine, SDEF, STR, STR_CURVE, Speed, WithMoveManager, clearInject, context, createServer, inject, provideServerModules, setInject };
+export { AGI, AGI_CURVE, ATK, ArraySubject$2 as ArraySubject, COEFFICIENT_ELEMENTS, DAMAGE_CRITICAL, DAMAGE_GUARD, DAMAGE_PHYSIC, DAMAGE_SKILL, DEX, DEX_CURVE, DialogGui, DialogPosition, Frequency, Gui, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, MenuGui, Move, NotificationGui, ObjectSubject$2 as ObjectSubject, PDEF, RpgEvent, RpgMap, RpgPlayer, RpgServerEngine, SDEF, STR, STR_CURVE, ShopGui, Speed, WithMoveManager, clearInject, computed$2 as computed, context, createServer, effect$2 as effect, inject, isArraySubject$1 as isArraySubject, isComputed$2 as isComputed, isObjectSubject$1 as isObjectSubject, isSignal$2 as isSignal, provideServerModules, setInject, signal$2 as signal, untracked };
 //# sourceMappingURL=index.js.map