@rpgjs/common 5.0.0-alpha.24 → 5.0.0-alpha.26

package/dist/database/Item.d.ts

@@ -1,4 +1,11 @@
 import { RpgCommonPlayer } from '../Player';
+interface ItemData {
+    name: string;
+    description: string;
+    price: number;
+    quantity: number;
+    onAdd: (player: RpgCommonPlayer) => void;
+}
 export declare class Item {
     id: import('@signe/reactive').WritableSignal<string>;
     name: import('@signe/reactive').WritableSignal<string>;
@@ -6,5 +13,6 @@ export declare class Item {
     price: import('@signe/reactive').WritableSignal<number>;
     quantity: import('@signe/reactive').WritableSignal<number>;
     onAdd: (player: RpgCommonPlayer) => void;
-    constructor(data: any);
+    constructor(data?: ItemData);
 }
+export {};

package/dist/index.js

@@ -1721,7 +1721,7 @@ var trackDependency = /* @__PURE__ */ __name$1((signal2) => {
     reactiveStore.currentDependencyTracker(signal2);
   }
 }, "trackDependency");
-function signal(defaultValue) {
+function signal(defaultValue, options) {
   let subject;
   if (Array.isArray(defaultValue)) {
     subject = new ArraySubject(defaultValue);
@@ -1743,12 +1743,21 @@ function signal(defaultValue) {
     return getValue();
   }, "fn");
   fn.set = (value) => {
-    if (subject instanceof ArraySubject) {
-      subject.items = value;
-    } else if (subject instanceof ObjectSubject) {
-      subject.obj = value;
+    const currentValue = getValue();
+    let shouldEmit = true;
+    if (options?.equal) {
+      shouldEmit = !options.equal(currentValue, value);
     } else {
-      subject.next(value);
+      shouldEmit = currentValue !== value;
+    }
+    if (shouldEmit) {
+      if (subject instanceof ArraySubject) {
+        subject.items = value;
+      } else if (subject instanceof ObjectSubject) {
+        subject.obj = value;
+      } else {
+        subject.next(value);
+      }
     }
   };
   fn._isFrozen = false;
@@ -1805,9 +1814,18 @@ function computed(computeFunction, disposableFn) {
     disposableFn = lastComputedValue;
   }
   reactiveStore.currentDependencyTracker = previousTracker;
-  const computedObservable = combineLatest([
+  const observables = [
     ...dependencies
-  ].map((signal2) => signal2.observable)).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
+  ].map((dep) => {
+    if (isComputed(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  const computedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
   const fn = /* @__PURE__ */ __name$1(function() {
     trackDependency(fn);
     return lastComputedValue;
@@ -1822,6 +1840,193 @@ function computed(computeFunction, disposableFn) {
   return fn;
 }
 __name$1(computed, "computed");
+function linkedSignal(computationOrOptions, simpleOptions) {
+  const dependencies = /* @__PURE__ */ new Set();
+  let init = true;
+  let lastComputedValue;
+  let computeFunction;
+  let sourceSignal;
+  let computationFn;
+  let equalFn;
+  let previousValue;
+  let isOverridden = false;
+  let overriddenValue;
+  let depVersion = 0;
+  let overrideDepVersion = null;
+  if (typeof computationOrOptions === "function") {
+    computeFunction = computationOrOptions;
+    equalFn = simpleOptions?.equal;
+  } else {
+    const options = computationOrOptions;
+    sourceSignal = options.source;
+    computationFn = options.computation;
+    equalFn = options.equal;
+    if (typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+      const sourceFn = sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$1(() => {
+        const sourceValue = sourceFn();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    } else {
+      const source = typeof sourceSignal === "function" ? sourceSignal : sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$1(() => {
+        const sourceValue = source();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    }
+  }
+  const previousTracker = reactiveStore.currentDependencyTracker;
+  reactiveStore.currentDependencyTracker = (signal2) => {
+    dependencies.add(signal2);
+  };
+  if (sourceSignal && typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+    lastComputedValue = computeFunction();
+  } else if (sourceSignal && isSignal(sourceSignal)) {
+    dependencies.add(sourceSignal);
+    lastComputedValue = computeFunction();
+  } else {
+    lastComputedValue = computeFunction();
+  }
+  reactiveStore.currentDependencyTracker = previousTracker;
+  const subject = new BehaviorSubject(lastComputedValue);
+  const observables = [
+    ...dependencies
+  ].map((dep) => {
+    if (isComputed(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  let linkedObservable;
+  if (observables.length > 0) {
+    linkedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => {
+      const computed2 = computeFunction();
+      if (equalFn) {
+        if (!equalFn(lastComputedValue, computed2)) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      } else {
+        if (lastComputedValue !== computed2) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      }
+      return lastComputedValue;
+    }));
+  } else {
+    linkedObservable = subject.asObservable().pipe(filter(() => !init));
+  }
+  const fn = /* @__PURE__ */ __name$1(function() {
+    trackDependency(fn);
+    if (isOverridden && dependencies.size > 0) {
+      if (overrideDepVersion !== depVersion) {
+        const computed2 = computeFunction();
+        isOverridden = false;
+        overriddenValue = void 0;
+        lastComputedValue = computed2;
+        overrideDepVersion = null;
+        return computed2;
+      }
+      return overriddenValue;
+    }
+    if (isOverridden) {
+      return overriddenValue;
+    }
+    if (dependencies.size === 0) {
+      const computed2 = computeFunction();
+      lastComputedValue = computed2;
+    }
+    return lastComputedValue;
+  }, "fn");
+  fn.observable = new Observable((observer) => {
+    const depSubscription = linkedObservable.subscribe((value) => {
+      if (dependencies.size > 0) {
+        depVersion++;
+        isOverridden = false;
+        overrideDepVersion = null;
+        lastComputedValue = value;
+      } else {
+        lastComputedValue = value;
+      }
+      observer.next(value);
+    });
+    let subjectSubscription;
+    if (dependencies.size === 0) {
+      subjectSubscription = subject.pipe(filter(() => !init)).subscribe((value) => {
+        observer.next(value);
+      });
+    }
+    observer.next(lastComputedValue);
+    return () => {
+      depSubscription.unsubscribe();
+      if (subjectSubscription) {
+        subjectSubscription.unsubscribe();
+      }
+    };
+  });
+  fn.subscription = fn.observable.subscribe(() => {
+  });
+  fn.dependencies = dependencies;
+  fn._subject = subject;
+  fn.set = (value) => {
+    if (!isOverridden) {
+      overrideDepVersion = depVersion;
+      if (computationFn && sourceSignal) {
+        const sourceValue = untracked(() => {
+          if (typeof sourceSignal === "function") {
+            const source = sourceSignal;
+            return isSignal(source) ? source() : sourceSignal();
+          }
+          return sourceSignal();
+        });
+        previousValue = {
+          source: sourceValue,
+          value
+        };
+      }
+    }
+    isOverridden = true;
+    overriddenValue = value;
+    lastComputedValue = value;
+    subject.next(value);
+  };
+  reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+  init = false;
+  return fn;
+}
+__name$1(linkedSignal, "linkedSignal");
 function untracked(fn) {
   const prevDepTracker = reactiveStore.currentDependencyTracker;
   const prevSubTracker = reactiveStore.currentSubscriptionsTracker;
@@ -2237,10 +2442,10 @@ class Item {
     this.quantity = signal(1);
     this.onAdd = () => {
     };
-    this.description.set(data.description);
-    this.price.set(data.price);
-    this.name.set(data.name);
-    this.onAdd = data.onAdd?.bind(this) ?? (() => {
+    this.description.set(data?.description ?? "");
+    this.price.set(data?.price ?? 0);
+    this.name.set(data?.name ?? "");
+    this.onAdd = data?.onAdd?.bind(this) ?? (() => {
     });
   }
 }
@@ -2317,7 +2522,7 @@ class RpgCommonPlayer {
     this.hpSignal = signal(0);
     this.spSignal = signal(0);
     this._exp = signal(0);
-    this._level = signal(0);
+    this._level = signal(1);
     this._class = signal({});
     this.items = signal([]);
     this.equipments = signal([]);
@@ -9277,6 +9482,10 @@ class RpgCommonMap {
     });
     this.moveManager = new MovementManager(() => this.physic);
     this.speedScalar = 50;
+    // Default speed scalar for movement
+    // World Maps properties
+    this.tileWidth = 32;
+    this.tileHeight = 32;
     this.physicsAccumulatorMs = 0;
     this.physicsSyncDepth = 0;
     /**
@@ -9331,6 +9540,88 @@ class RpgCommonMap {
   get isStandalone() {
     return typeof window !== "undefined";
   }
+  /**
+   * Get the width of the map in pixels
+   * 
+   * @returns The width of the map in pixels, or 0 if not loaded
+   * 
+   * @example
+   * ```ts
+   * const width = map.widthPx;
+   * console.log(`Map width: ${width}px`);
+   * ```
+   */
+  get widthPx() {
+    return this.data()?.width ?? 0;
+  }
+  /**
+   * Get the height of the map in pixels
+   * 
+   * @returns The height of the map in pixels, or 0 if not loaded
+   * 
+   * @example
+   * ```ts
+   * const height = map.heightPx;
+   * console.log(`Map height: ${height}px`);
+   * ```
+   */
+  get heightPx() {
+    return this.data()?.height ?? 0;
+  }
+  /**
+   * Get the unique identifier of the map
+   * 
+   * @returns The map ID, or empty string if not loaded
+   * 
+   * @example
+   * ```ts
+   * const mapId = map.id;
+   * console.log(`Current map: ${mapId}`);
+   * ```
+   */
+  get id() {
+    return this.data()?.id ?? "";
+  }
+  /**
+  * Get the X position of this map in the world coordinate system
+  * 
+  * This is used when maps are part of a larger world map. The world position
+  * indicates where this map is located relative to other maps.
+  * 
+  * @returns The X position in world coordinates, or 0 if not in a world
+  * 
+  * @example
+  * ```ts
+  * const worldX = map.worldX;
+  * console.log(`Map is at world position (${worldX}, ${map.worldY})`);
+  * ```
+  */
+  get worldX() {
+    const worldMaps = this.getWorldMapsManager?.();
+    if (!worldMaps) return 0;
+    const mapId = this.id.startsWith("map-") ? this.id.slice(4) : this.id;
+    return worldMaps.getMapInfo(mapId)?.worldX ?? 0;
+  }
+  /**
+   * Get the Y position of this map in the world coordinate system
+   * 
+   * This is used when maps are part of a larger world map. The world position
+   * indicates where this map is located relative to other maps.
+   * 
+   * @returns The Y position in world coordinates, or 0 if not in a world
+   * 
+   * @example
+   * ```ts
+   * const worldY = map.worldY;
+   * console.log(`Map is at world position (${map.worldX}, ${worldY})`);
+   * ```
+   */
+  get worldY() {
+    const worldMaps = this.getWorldMapsManager?.();
+    if (!worldMaps) return 0;
+    const mapId = this.id.startsWith("map-") ? this.id.slice(4) : this.id;
+    return worldMaps.getMapInfo(mapId)?.worldY ?? 0;
+  }
   /**
    * Clear all physics content and reset to initial state
    * 
@@ -10422,17 +10713,19 @@ class WorldMapsManager {
     if (typeof search === "number") {
       const src = map;
       return maps.filter((m) => {
-        const horizontallyOverlaps = Math.max(src.worldX, m.worldX) < Math.min(src.worldX + src.width, m.worldX + m.width);
-        const verticallyOverlaps = Math.max(src.worldY, m.worldY) < Math.min(src.worldY + src.height, m.worldY + m.height);
+        const horizontallyOverlapsOrTouches = Math.max(src.worldX, m.worldX) <= Math.min(src.worldX + src.widthPx, m.worldX + m.widthPx);
+        const verticallyOverlapsOrTouches = Math.max(src.worldY, m.worldY) <= Math.min(src.worldY + src.heightPx, m.worldY + m.heightPx);
+        const marginLeftRight = src.tileWidth / 2;
+        const marginTopDown = src.tileHeight / 2;
         switch (search) {
           case 0:
-            return verticallyOverlaps && m.worldY + m.height === src.worldY;
+            return verticallyOverlapsOrTouches && m.worldY + m.heightPx - marginTopDown === src.worldY;
           case 1:
-            return verticallyOverlaps && m.worldY === src.worldY + src.height;
+            return verticallyOverlapsOrTouches && m.worldY + marginTopDown === src.worldY + src.heightPx;
           case 2:
-            return horizontallyOverlaps && m.worldX + m.width === src.worldX;
+            return horizontallyOverlapsOrTouches && m.worldX + m.widthPx - marginLeftRight === src.worldX;
           case 3:
-            return horizontallyOverlaps && m.worldX === src.worldX + src.width;
+            return horizontallyOverlapsOrTouches && m.worldX + marginLeftRight === src.worldX + src.widthPx;
           default:
             return false;
         }
@@ -10440,7 +10733,7 @@ class WorldMapsManager {
     }
     if ("x" in search && "y" in search) {
       const found = maps.find(
-        (m) => search.x >= m.worldX && search.x < m.worldX + m.width && search.y >= m.worldY && search.y < m.worldY + m.height
+        (m) => search.x >= m.worldX && search.x < m.worldX + m.widthPx && search.y >= m.worldY && search.y < m.worldY + m.heightPx
       );
       return found ? [found] : [];
     }
@@ -10448,9 +10741,9 @@ class WorldMapsManager {
       const { minX, minY, maxX, maxY } = search;
       return maps.filter((m) => {
         const aLeft = m.worldX;
-        const aRight = m.worldX + m.width;
+        const aRight = m.worldX + m.widthPx;
         const aTop = m.worldY;
-        const aBottom = m.worldY + m.height;
+        const aBottom = m.worldY + m.heightPx;
         const bLeft = minX;
         const bRight = maxX;
         const bTop = minY;