@rpgjs/common 5.0.0-alpha.4 → 5.0.0-alpha.40

package/dist/rooms/WorldMaps.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Interface for world map information
+ */
+export interface WorldMapInfo {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    worldX: number;
+    worldY: number;
+    widthPx: number;
+    heightPx: number;
+    tileWidth: number;
+    tileHeight: number;
+}
+/**
+ * Configuration for a world map
+ */
+export interface WorldMapConfig {
+    id: string;
+    worldX: number;
+    worldY: number;
+    width: number;
+    height: number;
+    tileWidth?: number;
+    tileHeight?: number;
+}
+/**
+ * World Maps Manager
+ *
+ * Manages a collection of interconnected maps and their spatial relationships
+ */
+export declare class WorldMapsManager {
+    private maps;
+    private spatialIndex;
+    /**
+     * Configure the world maps
+     *
+     * @param configs - Array of map configurations
+     *
+     * @example
+     * ```ts
+     * const worldMaps = new WorldMapsManager();
+     * worldMaps.configure([
+     *   { id: "town", worldX: 0, worldY: 0, width: 1024, height: 768 },
+     *   { id: "forest", worldX: 1024, worldY: 0, width: 1024, height: 768 }
+     * ]);
+     * ```
+     */
+    configure(configs: WorldMapConfig[]): void;
+    /**
+     * Remove a map from the world by its id
+     *
+     * Deletes the map from the internal registry and spatial index.
+     *
+     * @param mapId - Map identifier
+     * @returns True if a map was removed, false otherwise
+     *
+     * @example
+     * ```ts
+     * const removed = world.removeMap("forest");
+     * ```
+     */
+    removeMap(mapId: string): boolean;
+    /**
+     * Find adjacent maps based on various search strategies
+     *
+     * Supports three search modes:
+     * - PositionBox: collect maps intersecting the given box
+     * - Direction: collect maps adjacent in the given direction
+     * - Point: collect the map containing the given world point
+     *
+     * The given `map` can be any object exposing `worldX`, `worldY`, `width`, `height` properties
+     * (e.g. your `RpgMap` instance or a `WorldMapInfo`).
+     *
+     * @param map - The source map
+     * @param search - Search strategy (box, direction or point)
+     * @returns Array of matching adjacent map infos
+     *
+     * @example
+     * ```ts
+     * // Point
+     * world.getAdjacentMaps(currentMap, { x: 1024, y: 0 });
+     *
+     * // Direction
+     * world.getAdjacentMaps(currentMap, Direction.Up);
+     *
+     * // Box
+     * world.getAdjacentMaps(currentMap, { minX: 0, minY: 0, maxX: 2048, maxY: 1024 });
+     * ```
+     */
+    getAdjacentMaps(map: {
+        worldX: number;
+        worldY: number;
+        widthPx: number;
+        heightPx: number;
+    }, search: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    } | {
+        x: number;
+        y: number;
+    } | number): WorldMapInfo[];
+    /**
+     * Get map information by ID
+     *
+     * @param mapId - Map ID
+     * @returns Map information or null if not found
+     *
+     * @example
+     * ```ts
+     * const mapInfo = worldMaps.getMapInfo("forest");
+     * ```
+     */
+    getMapInfo(mapId: string): WorldMapInfo | null;
+    /**
+     * Get all configured maps
+     *
+     * @returns Array of all world maps
+     */
+    getAllMaps(): WorldMapInfo[];
+    /**
+     * Find map by world coordinates
+     *
+     * @param worldX - World X coordinate
+     * @param worldY - World Y coordinate
+     * @returns Map found or null
+     */
+    getMapByWorldCoordinates(worldX: number, worldY: number): WorldMapInfo | null;
+    /**
+     * Calculate absolute world position of a player
+     *
+     * @param map - Current map
+     * @param localX - Local X position in the map
+     * @param localY - Local Y position in the map
+     * @returns Absolute coordinates in the world
+     */
+    getWorldPosition(map: WorldMapInfo, localX: number, localY: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Calculate local position from world position
+     *
+     * @param worldX - World X position
+     * @param worldY - World Y position
+     * @param targetMap - Target map
+     * @returns Local position in the target map
+     */
+    getLocalPosition(worldX: number, worldY: number, targetMap: WorldMapInfo): {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Public alias for the world maps manager
+ *
+ * This alias is provided for API readability in map methods.
+ */
+export type RpgWorldMaps = WorldMapsManager;

package/dist/services/save.d.ts

@@ -0,0 +1,12 @@
+export interface SaveSlotMeta {
+    level?: number;
+    exp?: number;
+    map?: string;
+    date?: string;
+    [key: string]: any;
+}
+export interface SaveSlot extends SaveSlotMeta {
+    snapshot?: string;
+}
+export type SaveSlotList = Array<SaveSlotMeta | null>;
+export type SaveSlotEntries = Array<SaveSlot | null>;

package/dist/weather.d.ts

@@ -0,0 +1,27 @@
+export type WeatherEffect = "rain" | "snow" | "fog" | "cloud";
+export interface WeatherParams {
+    speed?: number;
+    windDirection?: number;
+    windStrength?: number;
+    density?: number;
+    maxDrops?: number;
+    height?: number;
+    scale?: number;
+    sunIntensity?: number;
+    sunAngle?: number;
+    raySpread?: number;
+    rayTwinkle?: number;
+    rayTwinkleSpeed?: number;
+    zIndex?: number;
+    alpha?: number;
+    blendMode?: string;
+}
+export interface WeatherState {
+    effect: WeatherEffect;
+    preset?: string;
+    params?: WeatherParams;
+    transitionMs?: number;
+    durationMs?: number;
+    startedAt?: number;
+    seed?: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/common",
-  "version": "5.0.0-alpha.4",
+  "version": "5.0.0-alpha.40",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,17 +11,16 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@dimforge/rapier2d": "^0.17.3",
-    "@signe/di": "^2.3.1",
-    "@signe/reactive": "^2.3.1",
-    "@signe/sync": "^2.3.1",
-    "matter-js": "^0.20.0",
+    "@rpgjs/physic": "5.0.0-alpha.40",
+    "@signe/di": "^2.8.3",
+    "@signe/reactive": "^2.8.3",
+    "@signe/sync": "^2.8.3",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "vite": "^6.2.5",
-    "vite-plugin-dts": "^4.5.3",
-    "vitest": "^3.1.1"
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18"
   },
   "type": "module",
   "scripts": {

package/src/PerlinNoise.ts

@@ -0,0 +1,294 @@
+/**
+ * Perlin Noise 2D Generator
+ * 
+ * A simple, efficient, and performant implementation of 2D Perlin noise.
+ * Perlin noise generates smooth, natural-looking random values that are coherent
+ * across space, making it ideal for procedural generation and smooth random movements.
+ * 
+ * ## Features
+ * - **Deterministic**: Same seed and coordinates always produce the same value
+ * - **Smooth**: Values change gradually, creating natural-looking patterns
+ * - **Performant**: Optimized for real-time use in movement systems
+ * - **Seeded**: Optional seed for reproducible results
+ * 
+ * ## Usage
+ * ```ts
+ * const noise = new PerlinNoise2D();
+ * const value = noise.get(x, y); // Returns value between -1 and 1
+ * 
+ * // With seed for deterministic results
+ * const seededNoise = new PerlinNoise2D(12345);
+ * ```
+ * 
+ * @example
+ * ```ts
+ * // Use in movement system for smooth random directions
+ * const noise = new PerlinNoise2D();
+ * const time = Date.now() * 0.001;
+ * const direction = Math.floor(noise.get(player.x(), player.y(), time) * 4) % 4;
+ * ```
+ */
+export class PerlinNoise2D {
+  private readonly permutation: number[];
+  private readonly p: number[];
+
+  /**
+   * Creates a new Perlin noise generator
+   * 
+   * @param seed - Optional seed for deterministic noise generation. If not provided, uses a default seed.
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D(12345);
+   * const value = noise.get(10, 20);
+   * ```
+   */
+  constructor(seed: number = 0) {
+    // Create permutation table (256 values)
+    this.permutation = this.generatePermutation(seed);
+    
+    // Double the permutation array for easier wrapping
+    this.p = [...this.permutation, ...this.permutation];
+  }
+
+  /**
+   * Generates a permutation table based on seed
+   * 
+   * @param seed - Seed value for permutation generation
+   * @returns Array of 256 shuffled values
+   */
+  private generatePermutation(seed: number): number[] {
+    const p: number[] = [];
+    
+    // Initialize with sequential values
+    for (let i = 0; i < 256; i++) {
+      p[i] = i;
+    }
+    
+    // Simple seeded shuffle using linear congruential generator
+    let state = seed;
+    const lcg = () => {
+      state = (state * 1103515245 + 12345) & 0x7fffffff;
+      return state;
+    };
+    
+    // Fisher-Yates shuffle with seeded random
+    for (let i = 255; i > 0; i--) {
+      const j = lcg() % (i + 1);
+      [p[i], p[j]] = [p[j], p[i]];
+    }
+    
+    return p;
+  }
+
+  /**
+   * Fade function for smooth interpolation (ease curve)
+   * 
+   * @param t - Value between 0 and 1
+   * @returns Smoothed value between 0 and 1
+   */
+  private fade(t: number): number {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+
+  /**
+   * Linear interpolation
+   * 
+   * @param a - Start value
+   * @param b - End value
+   * @param t - Interpolation factor (0 to 1)
+   * @returns Interpolated value
+   */
+  private lerp(a: number, b: number, t: number): number {
+    return a + t * (b - a);
+  }
+
+  /**
+   * Gradient function - generates a pseudo-random gradient vector
+   * 
+   * @param hash - Hash value from permutation table
+   * @param x - X component
+   * @param y - Y component
+   * @returns Dot product of gradient and position
+   */
+  private grad(hash: number, x: number, y: number): number {
+    // Convert hash to one of 4 gradient directions
+    const h = hash & 3;
+    
+    // Return dot product with gradient vector
+    switch (h) {
+      case 0: return x + y;      // (1, 1)
+      case 1: return -x + y;     // (-1, 1)
+      case 2: return x - y;      // (1, -1)
+      case 3: return -x - y;     // (-1, -1)
+      default: return 0;
+    }
+  }
+
+  /**
+   * Gets the noise value at the specified 2D coordinates
+   * 
+   * Returns a value between approximately -1 and 1, though values near the edges
+   * are less common. For practical use, you may want to clamp or normalize the result.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param scale - Optional scale factor (default: 0.1). Lower values create smoother, larger patterns.
+   * @returns Noise value between approximately -1 and 1
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const value = noise.get(10, 20); // Basic usage
+   * const scaled = noise.get(10, 20, 0.05); // Smoother pattern
+   * ```
+   */
+  get(x: number, y: number, scale: number = 0.1): number {
+    // Apply scale
+    x *= scale;
+    y *= scale;
+
+    // Find unit grid cell containing point
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+
+    // Get relative x,y coordinates within that cell
+    x -= Math.floor(x);
+    y -= Math.floor(y);
+
+    // Compute fade curves for x and y
+    const u = this.fade(x);
+    const v = this.fade(y);
+
+    // Hash coordinates of the 4 square corners
+    const A = this.p[X] + Y;
+    const AA = this.p[A];
+    const AB = this.p[A + 1];
+    const B = this.p[X + 1] + Y;
+    const BA = this.p[B];
+    const BB = this.p[B + 1];
+
+    // And add blended results from 4 corners of the square
+    return this.lerp(
+      this.lerp(
+        this.grad(this.p[AA], x, y),
+        this.grad(this.p[BA], x - 1, y),
+        u
+      ),
+      this.lerp(
+        this.grad(this.p[AB], x, y - 1),
+        this.grad(this.p[BB], x - 1, y - 1),
+        u
+      ),
+      v
+    );
+  }
+
+  /**
+   * Gets a normalized noise value between 0 and 1
+   * 
+   * Convenience method that normalizes the noise output to a 0-1 range.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param scale - Optional scale factor (default: 0.1)
+   * @returns Noise value between 0 and 1
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const normalized = noise.getNormalized(10, 20);
+   * // Returns value between 0 and 1
+   * ```
+   */
+  getNormalized(x: number, y: number, scale: number = 0.1): number {
+    return (this.get(x, y, scale) + 1) * 0.5;
+  }
+
+  /**
+   * Gets a noise value mapped to a specific range
+   * 
+   * Maps the noise output to a custom min-max range.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param min - Minimum output value
+   * @param max - Maximum output value
+   * @param scale - Optional scale factor (default: 0.1)
+   * @returns Noise value between min and max
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const direction = noise.getRange(10, 20, 0, 3); // Returns 0, 1, 2, or 3
+   * ```
+   */
+  getRange(x: number, y: number, min: number, max: number, scale: number = 0.1): number {
+    const normalized = this.getNormalized(x, y, scale);
+    return min + normalized * (max - min);
+  }
+
+  /**
+   * Gets an integer noise value in a specific range (inclusive)
+   * 
+   * Useful for selecting discrete values like array indices or enum values.
+   * 
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param min - Minimum integer value (inclusive)
+   * @param max - Maximum integer value (inclusive)
+   * @param scale - Optional scale factor (default: 0.1)
+   * @returns Integer noise value between min and max (inclusive)
+   * 
+   * @example
+   * ```ts
+   * const noise = new PerlinNoise2D();
+   * const directionIndex = noise.getInt(10, 20, 0, 3); // Returns 0, 1, 2, or 3
+   * ```
+   */
+  getInt(x: number, y: number, min: number, max: number, scale: number = 0.1): number {
+    const value = this.getRange(x, y, min, max + 1, scale);
+    return Math.floor(value);
+  }
+}
+
+/**
+ * Creates a shared Perlin noise instance for global use
+ * 
+ * Useful when you want consistent noise across different parts of your application
+ * without passing the instance around.
+ * 
+ * @param seed - Optional seed for the shared instance
+ * @returns Shared PerlinNoise2D instance
+ * 
+ * @example
+ * ```ts
+ * const noise = getSharedPerlinNoise(12345);
+ * const value = noise.get(10, 20);
+ * ```
+ */
+let sharedInstance: PerlinNoise2D | null = null;
+
+export function getSharedPerlinNoise(seed?: number): PerlinNoise2D {
+  if (!sharedInstance) {
+    sharedInstance = new PerlinNoise2D(seed);
+  }
+  return sharedInstance;
+}
+
+/**
+ * Resets the shared Perlin noise instance
+ * 
+ * Useful for testing or when you need to change the seed.
+ * 
+ * @param seed - Optional new seed for the instance
+ * 
+ * @example
+ * ```ts
+ * resetSharedPerlinNoise(12345);
+ * ```
+ */
+export function resetSharedPerlinNoise(seed?: number): void {
+  sharedInstance = new PerlinNoise2D(seed);
+}
+