@rpgjs/common 5.0.0-alpha.25 → 5.0.0-alpha.27

package/dist/PerlinNoise.d.ts

@@ -0,0 +1,167 @@
+/**
+ * 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 declare class PerlinNoise2D {
+    private readonly permutation;
+    private readonly p;
+    /**
+     * 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);
+    /**
+     * Generates a permutation table based on seed
+     *
+     * @param seed - Seed value for permutation generation
+     * @returns Array of 256 shuffled values
+     */
+    private generatePermutation;
+    /**
+     * Fade function for smooth interpolation (ease curve)
+     *
+     * @param t - Value between 0 and 1
+     * @returns Smoothed value between 0 and 1
+     */
+    private fade;
+    /**
+     * Linear interpolation
+     *
+     * @param a - Start value
+     * @param b - End value
+     * @param t - Interpolation factor (0 to 1)
+     * @returns Interpolated value
+     */
+    private lerp;
+    /**
+     * 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;
+    /**
+     * 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): number;
+    /**
+     * 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): number;
+    /**
+     * 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): number;
+    /**
+     * 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): number;
+}
+export declare function getSharedPerlinNoise(seed?: number): PerlinNoise2D;
+/**
+ * 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 declare function resetSharedPerlinNoise(seed?: number): void;

package/dist/Player.d.ts

@@ -126,5 +126,6 @@ export declare abstract class RpgCommonPlayer {
      * ```
      */
     getDirection(): Direction;
+    abstract isEvent(): boolean;
 }
 export type PlayerCtor<T extends RpgCommonPlayer = RpgCommonPlayer> = Constructor<T>;

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.d.ts

@@ -7,4 +7,5 @@ export * from './services/updateMap';
 export * from './Utils';
 export * from './PrebuiltGui';
 export * from './database';
+export * from './PerlinNoise';
 export * from '@rpgjs/physic';