@rpgjs/server 5.0.0-alpha.36 → 5.0.0-alpha.39

package/dist/index.js

@@ -16895,7 +16895,30 @@ class RpgCommonMap {
       const eventsMap = this.events();
       const isSelfPlayer = !!playersMap[self.uuid];
       const isOtherPlayer = !!playersMap[other.uuid];
+      const isSelfEvent = !!eventsMap[self.uuid];
       const isOtherEvent = !!eventsMap[other.uuid];
+      const readScenarioOwnerId = (owner2) => {
+        const scenarioOwnerId = owner2?._scenarioOwnerId ?? owner2?.scenarioOwnerId;
+        return typeof scenarioOwnerId === "string" && scenarioOwnerId.length > 0 ? scenarioOwnerId : void 0;
+      };
+      const selfScenarioOwnerId = readScenarioOwnerId(selfOwner);
+      const otherScenarioOwnerId = readScenarioOwnerId(otherOwner);
+      if (selfScenarioOwnerId) {
+        if (isOtherPlayer && other.uuid !== selfScenarioOwnerId) {
+          return false;
+        }
+        if (isOtherEvent && otherScenarioOwnerId !== selfScenarioOwnerId) {
+          return false;
+        }
+      }
+      if (otherScenarioOwnerId) {
+        if (isSelfPlayer && self.uuid !== otherScenarioOwnerId) {
+          return false;
+        }
+        if (isSelfEvent && selfScenarioOwnerId !== otherScenarioOwnerId) {
+          return false;
+        }
+      }
       if (isSelfPlayer && isOtherPlayer) {
         if (typeof selfOwner._throughOtherPlayer === "function") {
           try {
@@ -19012,8 +19035,16 @@ function WithMoveManager(Base) {
     stopMoveTo() {
       const map = this.getCurrentMap();
       if (!map) return;
-      this.id;
-      const strategies = this.getActiveMovements();
+      let strategies = [];
+      try {
+        strategies = this.getActiveMovements();
+      } catch (error) {
+        const message = error?.message ?? "";
+        if (message.includes("unable to resolve entity")) {
+          return;
+        }
+        throw error;
+      }
       const toRemove = strategies.filter((s) => s instanceof SeekAvoid || s instanceof LinearRepulsion);
       if (toRemove.length > 0) {
         toRemove.forEach((strategy) => {
@@ -22652,9 +22683,12 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     const map2 = this.getCurrentMap();
     if (!map2) return;
     const { events } = map2;
+    const visibleMapEvents = Object.values(events?.() ?? {}).filter(
+      (event) => map2.isEventVisibleForPlayer?.(event, this) ?? true
+    );
     const arrayEvents = [
       ...Object.values(this.events()),
-      ...Object.values(events?.() ?? {})
+      ...visibleMapEvents
     ];
     for (let event of arrayEvents) {
       if (event.onChanges) event.onChanges(this);
@@ -22781,7 +22815,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
           entities.forEach((entity) => {
             const event = map2.getEvent(entity.uuid);
             const player = map2.getPlayer(entity.uuid);
-            if (event) {
+            if (event && (!map2.isEventVisibleForPlayer || map2.isEventVisibleForPlayer(event, this))) {
               event.execMethod("onInShape", [shape, this]);
               if (event._inShapes) {
                 event._inShapes.add(shape);
@@ -22799,7 +22833,7 @@ const _RpgPlayer = class _RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
           entities.forEach((entity) => {
             const event = map2.getEvent(entity.uuid);
             const player = map2.getPlayer(entity.uuid);
-            if (event) {
+            if (event && (!map2.isEventVisibleForPlayer || map2.isEventVisibleForPlayer(event, this))) {
               event.execMethod("onOutShape", [shape, this]);
               if (event._inShapes) {
                 event._inShapes.delete(shape);
@@ -27614,6 +27648,23 @@ function superRefine(fn) {
     return _superRefine(fn);
 }
 
+var EventMode = /* @__PURE__ */ ((EventMode2) => {
+  EventMode2["Shared"] = "shared";
+  EventMode2["Scenario"] = "scenario";
+  return EventMode2;
+})(EventMode || {});
+function EventData(options) {
+  return (target) => {
+    target.mode = options.mode || "shared" /* Shared */;
+    target.width = options.width;
+    target.height = options.height;
+    target.hitbox = options.hitbox;
+    target._name = options.name;
+    target.prototype._name = options.name;
+    target.prototype.mode = target.mode;
+  };
+}
+
 var __defProp$2 = Object.defineProperty;
 var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
 var __decorateClass$2 = (decorators, target, key, kind) => {
@@ -27920,6 +27971,14 @@ let RpgMap = class extends RpgCommonMap {
     this._shapeEntities = /* @__PURE__ */ new Map();
     /** Enable/disable automatic tick processing (useful for unit tests) */
     this._autoTickEnabled = true;
+    /** Runtime templates for scenario events to instantiate per player */
+    this._scenarioEventTemplates = [];
+    /** Runtime registry of event mode by id */
+    this._eventModeById = /* @__PURE__ */ new Map();
+    /** Runtime registry of scenario owner by event id */
+    this._eventOwnerById = /* @__PURE__ */ new Map();
+    /** Runtime registry of spawned scenario event ids by player id */
+    this._scenarioEventIdsByPlayer = /* @__PURE__ */ new Map();
     this.autoSync = true;
     this.hooks.callHooks("server-map-onStart", this).subscribe();
     const isTest = room.env.TEST === "true" ? true : false;
@@ -27955,6 +28014,147 @@ let RpgMap = class extends RpgCommonMap {
       map.height = this.isPositiveNumber(worldMapInfo?.height) ? worldMapInfo.height : SAFE_MAP_HEIGHT;
     }
   }
+  normalizeEventMode(mode) {
+    return mode === EventMode.Scenario || mode === "scenario" ? EventMode.Scenario : EventMode.Shared;
+  }
+  resolveEventMode(eventObj) {
+    if (!eventObj) return EventMode.Shared;
+    if (eventObj.mode !== void 0) {
+      return this.normalizeEventMode(eventObj.mode);
+    }
+    const eventDef = eventObj.event ?? eventObj;
+    if (eventDef?.mode !== void 0) {
+      return this.normalizeEventMode(eventDef.mode);
+    }
+    if (typeof eventDef === "function") {
+      const staticMode = eventDef.mode;
+      const prototypeMode = eventDef.prototype?.mode;
+      if (staticMode !== void 0) {
+        return this.normalizeEventMode(staticMode);
+      }
+      if (prototypeMode !== void 0) {
+        return this.normalizeEventMode(prototypeMode);
+      }
+    }
+    return EventMode.Shared;
+  }
+  resolveScenarioOwnerId(eventObj) {
+    if (!eventObj) return void 0;
+    const ownerId = eventObj.scenarioOwnerId ?? eventObj._scenarioOwnerId ?? eventObj.event?.scenarioOwnerId ?? eventObj.event?._scenarioOwnerId;
+    return typeof ownerId === "string" && ownerId.length > 0 ? ownerId : void 0;
+  }
+  normalizeEventObject(eventObj) {
+    if (eventObj && typeof eventObj === "object" && "event" in eventObj) {
+      return eventObj;
+    }
+    return {
+      event: eventObj
+    };
+  }
+  cloneEventTemplate(eventObj) {
+    const clone = { ...eventObj };
+    if (clone.event && typeof clone.event === "object") {
+      clone.event = { ...clone.event };
+    }
+    return clone;
+  }
+  buildRuntimeEventId(baseId, mode, scenarioOwnerId) {
+    const fallbackId = baseId || generateShortUUID$1();
+    if (mode !== EventMode.Scenario || !scenarioOwnerId) {
+      return fallbackId;
+    }
+    const scopedId = `${fallbackId}::${scenarioOwnerId}`;
+    if (!this.events()[scopedId]) {
+      return scopedId;
+    }
+    return `${scopedId}::${generateShortUUID$1()}`;
+  }
+  setEventRuntimeMetadata(eventId, mode, scenarioOwnerId) {
+    this._eventModeById.set(eventId, mode);
+    if (mode === EventMode.Scenario && scenarioOwnerId) {
+      this._eventOwnerById.set(eventId, scenarioOwnerId);
+      const ids = this._scenarioEventIdsByPlayer.get(scenarioOwnerId) ?? /* @__PURE__ */ new Set();
+      ids.add(eventId);
+      this._scenarioEventIdsByPlayer.set(scenarioOwnerId, ids);
+      return;
+    }
+    this._eventOwnerById.delete(eventId);
+  }
+  clearEventRuntimeMetadata(eventId) {
+    this._eventModeById.delete(eventId);
+    const ownerId = this._eventOwnerById.get(eventId);
+    if (ownerId) {
+      const ids = this._scenarioEventIdsByPlayer.get(ownerId);
+      if (ids) {
+        ids.delete(eventId);
+        if (ids.size === 0) {
+          this._scenarioEventIdsByPlayer.delete(ownerId);
+        }
+      }
+    }
+    this._eventOwnerById.delete(eventId);
+  }
+  getEventModeById(eventId) {
+    const runtimeMode = this._eventModeById.get(eventId);
+    if (runtimeMode) {
+      return runtimeMode;
+    }
+    const event = this.getEvent(eventId);
+    return this.normalizeEventMode(event?.mode);
+  }
+  getScenarioOwnerIdByEventId(eventId) {
+    const runtimeOwnerId = this._eventOwnerById.get(eventId);
+    if (runtimeOwnerId) {
+      return runtimeOwnerId;
+    }
+    const event = this.getEvent(eventId);
+    const ownerId = event?._scenarioOwnerId ?? event?.scenarioOwnerId;
+    return typeof ownerId === "string" && ownerId.length > 0 ? ownerId : void 0;
+  }
+  isEventVisibleForPlayer(eventOrId, playerOrId) {
+    const playerId = typeof playerOrId === "string" ? playerOrId : playerOrId?.id;
+    if (!playerId) {
+      return false;
+    }
+    const eventId = typeof eventOrId === "string" ? eventOrId : eventOrId?.id;
+    if (!eventId) {
+      return false;
+    }
+    const mode = this.getEventModeById(eventId);
+    if (mode === EventMode.Shared) {
+      return true;
+    }
+    const ownerId = this.getScenarioOwnerIdByEventId(eventId);
+    return ownerId === playerId;
+  }
+  async spawnScenarioEventsForPlayer(player) {
+    if (!player?.id || this._scenarioEventTemplates.length === 0) {
+      return;
+    }
+    this.removeScenarioEventsForPlayer(player.id);
+    for (const template of this._scenarioEventTemplates) {
+      const clone = this.cloneEventTemplate(template);
+      await this.createDynamicEvent(clone, { mode: EventMode.Scenario, scenarioOwnerId: player.id });
+    }
+  }
+  removeScenarioEventsForPlayer(playerId) {
+    const ids = this._scenarioEventIdsByPlayer.get(playerId);
+    if (!ids || ids.size === 0) {
+      return;
+    }
+    for (const eventId of [...ids]) {
+      const event = this.getEvent(eventId);
+      if (event && typeof event.remove === "function") {
+        try {
+          event.remove();
+          continue;
+        } catch {
+        }
+      }
+      this.removeEvent(eventId);
+    }
+    this._scenarioEventIdsByPlayer.delete(playerId);
+  }
   /**
    * Setup collision detection between players, events, and shapes
    * 
@@ -28039,7 +28239,7 @@ let RpgMap = class extends RpgCommonMap {
       }
       const eventId = player.id === entityA.uuid ? entityB.uuid : entityA.uuid;
       const event = this.getEvent(eventId);
-      if (event) {
+      if (event && this.isEventVisibleForPlayer(eventId, player)) {
         activeCollisions.add(collisionKey);
         event.execMethod("onPlayerTouch", [player]);
       }
@@ -28102,6 +28302,7 @@ let RpgMap = class extends RpgCommonMap {
    */
   interceptorPacket(player, packet, conn) {
     let obj = {};
+    let packetValue = packet?.value;
     if (!player) {
       return null;
     }
@@ -28124,13 +28325,25 @@ let RpgMap = class extends RpgCommonMap {
         };
       }
     }
+    if (packetValue && typeof packetValue === "object" && packetValue.events && typeof packetValue.events === "object") {
+      const eventEntries = Object.entries(packetValue.events);
+      const filteredEntries = eventEntries.filter(([eventId]) => this.isEventVisibleForPlayer(eventId, player));
+      if (filteredEntries.length !== eventEntries.length) {
+        packetValue = { ...packetValue };
+        if (filteredEntries.length === 0) {
+          delete packetValue.events;
+        } else {
+          packetValue.events = Object.fromEntries(filteredEntries);
+        }
+      }
+    }
     if (typeof packet.value == "string") {
       return packet;
     }
     return {
       ...packet,
       value: {
-        ...packet.value,
+        ...packetValue,
         ...obj
       }
     };
@@ -28186,6 +28399,7 @@ let RpgMap = class extends RpgCommonMap {
               body.owner = player;
             }
             this.updateHitbox(player.id, player.x(), player.y(), width, height);
+            await this.spawnScenarioEventsForPlayer(player);
             if (this.stopAllSoundsBeforeJoin) {
               player.stopAllSounds();
             }
@@ -28236,6 +28450,7 @@ let RpgMap = class extends RpgCommonMap {
       await this._onLeave(player);
     }
     await lastValueFrom(this.hooks.callHooks("server-player-onLeaveMap", player, this));
+    this.removeScenarioEventsForPlayer(player.id);
     player.pendingInputs = [];
     player.lastProcessedInputTs = 0;
     player._lastFramePositions = null;
@@ -28272,10 +28487,10 @@ let RpgMap = class extends RpgCommonMap {
   }
   onAction(player, action) {
     const collisions = this.getCollisions(player.id);
-    const events = collisions.map((id) => this.getEvent(id));
+    const events = collisions.map((id) => this.getEvent(id)).filter((event) => !!event && this.isEventVisibleForPlayer(event, player));
     if (events.length > 0) {
       events.forEach((event) => {
-        event?.execMethod("onAction", [player, action]);
+        event.execMethod("onAction", [player, action]);
       });
     }
     player.execMethod("onInput", [action]);
@@ -28401,9 +28616,22 @@ let RpgMap = class extends RpgCommonMap {
       this.clearWeather();
     }
     await lastValueFrom(this.hooks.callHooks("server-map-onBeforeUpdate", map, this));
+    this._scenarioEventTemplates = [];
+    this._eventModeById.clear();
+    this._eventOwnerById.clear();
+    this._scenarioEventIdsByPlayer.clear();
     this.loadPhysic();
     for (let event of map.events ?? []) {
-      await this.createDynamicEvent(event);
+      const normalizedEvent = this.normalizeEventObject(event);
+      const mode = this.resolveEventMode(normalizedEvent);
+      if (mode === EventMode.Scenario) {
+        this._scenarioEventTemplates.push(this.cloneEventTemplate(normalizedEvent));
+        continue;
+      }
+      await this.createDynamicEvent(normalizedEvent, { mode: EventMode.Shared });
+    }
+    for (const player of this.getPlayers()) {
+      await this.spawnScenarioEventsForPlayer(player);
     }
     this.dataIsReady$.complete();
     await lastValueFrom(this.hooks.callHooks("server-map-onLoad", this));
@@ -28817,22 +29045,28 @@ let RpgMap = class extends RpgCommonMap {
    *   }
    * });
    */
-  async createDynamicEvent(eventObj) {
-    if (!eventObj.event) {
-      eventObj = {
-        event: eventObj
-      };
-    }
+  async createDynamicEvent(eventObj, options = {}) {
+    eventObj = this.normalizeEventObject(eventObj);
     const value = await lastValueFrom(this.hooks.callHooks("server-event-onBeforeCreated", eventObj, this));
     value.filter((v) => v).forEach((v) => {
       eventObj = v;
     });
-    const { x, y, event } = eventObj;
-    let id = eventObj.id || generateShortUUID$1();
+    const event = eventObj.event;
+    const x = typeof eventObj.x === "number" ? eventObj.x : 0;
+    const y = typeof eventObj.y === "number" ? eventObj.y : 0;
+    const requestedMode = options.mode ?? this.resolveEventMode(eventObj);
+    const mode = this.normalizeEventMode(requestedMode);
+    const ownerFromData = options.scenarioOwnerId ?? this.resolveScenarioOwnerId(eventObj);
+    const scenarioOwnerId = mode === EventMode.Scenario ? ownerFromData : void 0;
+    const effectiveMode = mode === EventMode.Scenario && scenarioOwnerId ? EventMode.Scenario : EventMode.Shared;
+    if (mode === EventMode.Scenario && !scenarioOwnerId) {
+      console.warn("Scenario event created without owner id. Falling back to shared mode.");
+    }
+    const id = this.buildRuntimeEventId(eventObj.id, effectiveMode, scenarioOwnerId);
     let eventInstance;
     if (this.events()[id]) {
       console.warn(`Event ${id} already exists on map`);
-      return;
+      return void 0;
     }
     if (typeof event === "function") {
       eventInstance = new event();
@@ -28855,11 +29089,21 @@ let RpgMap = class extends RpgCommonMap {
       eventInstance = new DynamicEvent();
       if (event.name) eventInstance.name.set(event.name);
     }
+    eventInstance.mode = effectiveMode;
+    if (effectiveMode === EventMode.Scenario && scenarioOwnerId) {
+      eventInstance._scenarioOwnerId = scenarioOwnerId;
+      eventInstance.scenarioOwnerId = scenarioOwnerId;
+    } else {
+      delete eventInstance._scenarioOwnerId;
+      delete eventInstance.scenarioOwnerId;
+    }
     eventInstance.map = this;
     eventInstance.context = context;
     await eventInstance.teleport({ x, y });
     this.events()[id] = eventInstance;
+    this.setEventRuntimeMetadata(id, effectiveMode, scenarioOwnerId);
     await eventInstance.execMethod("onInit");
+    return id;
   }
   /**
    * Get an event by its ID
@@ -28945,6 +29189,9 @@ let RpgMap = class extends RpgCommonMap {
   getEvents() {
     return Object.values(this.events());
   }
+  getEventsForPlayer(playerOrId) {
+    return this.getEvents().filter((event) => this.isEventVisibleForPlayer(event, playerOrId));
+  }
   /**
    * Get the first event that matches a condition
    * 
@@ -29015,6 +29262,18 @@ let RpgMap = class extends RpgCommonMap {
    * ```
    */
   removeEvent(eventId) {
+    const event = this.getEvent(eventId);
+    if (event) {
+      try {
+        event.stopMoveTo?.();
+      } catch {
+      }
+      try {
+        event.breakRoutes?.(true);
+      } catch {
+      }
+    }
+    this.clearEventRuntimeMetadata(eventId);
     delete this.events()[eventId];
   }
   /**
@@ -30070,23 +30329,6 @@ class LocalStorageSaveStorageStrategy {
   }
 }
 
-var EventMode = /* @__PURE__ */ ((EventMode2) => {
-  EventMode2["Shared"] = "shared";
-  EventMode2["Scenario"] = "scenario";
-  return EventMode2;
-})(EventMode || {});
-function EventData(options) {
-  return (target) => {
-    target.mode = options.mode || "shared" /* Shared */;
-    target.width = options.width;
-    target.height = options.height;
-    target.hitbox = options.hitbox;
-    target._name = options.name;
-    target.prototype._name = options.name;
-    target.prototype.mode = target.mode;
-  };
-}
-
 function MapData(options) {
   return (target) => {
     target.file = options.file;