@rpgjs/common 5.0.0-alpha.26 → 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/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';

package/dist/index.js

@@ -2619,6 +2619,9 @@ __decorateClass([
 __decorateClass([
   sync()
 ], RpgCommonPlayer.prototype, "_gold");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "animationName");
 __decorateClass([
   sync()
 ], RpgCommonPlayer.prototype, "hpSignal");
@@ -9488,6 +9491,11 @@ class RpgCommonMap {
     this.tileHeight = 32;
     this.physicsAccumulatorMs = 0;
     this.physicsSyncDepth = 0;
+    /**
+     * Whether to automatically subscribe to tick$ for physics updates
+     * Set to false in test environments for manual control with nextTick()
+     */
+    this.autoTickEnabled = true;
     /**
      * Observable representing the game loop tick
      * 
@@ -9721,9 +9729,11 @@ class RpgCommonMap {
         this.updateCharacterHitbox(event);
       }
     });
-    this.tickSubscription = this.tick$.subscribe(({ delta }) => {
-      this.runFixedTicks(delta);
-    });
+    if (this.autoTickEnabled) {
+      this.tickSubscription = this.tick$.subscribe(({ delta }) => {
+        this.runFixedTicks(delta);
+      });
+    }
   }
   async movePlayer(player, direction) {
     const currentX = player.x();
@@ -9745,12 +9755,8 @@ class RpgCommonMap {
         nextY = currentY + speed;
         break;
     }
-    if (typeof player.setIntendedDirection === "function") {
-      player.setIntendedDirection(direction);
-    } else if (typeof player.changeDirection === "function") {
-      player.changeDirection(direction);
-    }
-    if (typeof player.autoChangeMap === "function") {
+    player.changeDirection(direction);
+    if (typeof player.autoChangeMap === "function" && !player.isEvent()) {
       const mapChanged = await player.autoChangeMap({ x: nextX, y: nextY }, direction);
       if (mapChanged) {
         this.stopMovement(player);
@@ -9834,6 +9840,46 @@ class RpgCommonMap {
     }
     return executed;
   }
+  /**
+   * Manually trigger a single game tick
+   * 
+   * This method allows you to manually advance the game by one tick (16ms at 60fps).
+   * It's primarily useful for testing where you need precise control over when
+   * physics updates occur, rather than relying on the automatic tick$ subscription.
+   * 
+   * ## Use Cases
+   * 
+   * - **Testing**: Control exactly when physics steps occur in unit tests
+   * - **Manual control**: Step through game state manually for debugging
+   * - **Deterministic testing**: Ensure consistent timing in test scenarios
+   * 
+   * ## Important
+   * 
+   * This method should NOT be used in production code alongside the automatic `tick$`
+   * subscription, as it will cause double-stepping. Use either:
+   * - Automatic ticks (via `loadPhysic()` which subscribes to `tick$`)
+   * - Manual ticks (via `nextTick()` without `loadPhysic()` subscription)
+   * 
+   * @param deltaMs - Optional delta time in milliseconds (default: 16ms for 60fps)
+   * @returns Number of physics ticks executed
+   * 
+   * @example
+   * ```ts
+   * // In tests: manually advance game by one tick
+   * map.nextTick(); // Advances by 16ms (one frame at 60fps)
+   * 
+   * // With custom delta
+   * map.nextTick(32); // Advances by 32ms (two frames at 60fps)
+   * 
+   * // In a test loop
+   * for (let i = 0; i < 60; i++) {
+   *   map.nextTick(); // Simulate 1 second of game time
+   * }
+   * ```
+   */
+  nextTick(deltaMs = 16) {
+    return this.runFixedTicks(deltaMs);
+  }
   /**
    * Force a single physics tick outside of the normal game loop
    * 
@@ -9883,19 +9929,12 @@ class RpgCommonMap {
     const hitbox = typeof owner.hitbox === "function" ? owner.hitbox() : owner.hitbox;
     const width = hitbox?.w ?? 32;
     const height = hitbox?.h ?? 32;
-    const topLeftX = this.resolveNumeric(owner.x);
-    const topLeftY = this.resolveNumeric(owner.y);
-    const centerX = topLeftX + width / 2;
-    const centerY = topLeftY + height / 2;
     const radius = Math.max(width, height) / 2;
-    const speedValue = typeof owner.speed === "function" ? owner.speed() : typeof owner.speed === "number" ? owner.speed : void 0;
     this.addCharacter({
       owner,
-      x: centerX,
-      y: centerY,
       radius,
       kind,
-      maxSpeed: speedValue,
+      maxSpeed: owner.speed(),
       collidesWithCharacters: !this.shouldDisableCharacterCollisions(owner),
       isStatic: options?.isStatic,
       mass: options?.mass
@@ -10267,11 +10306,24 @@ class RpgCommonMap {
       owner2.changeDirection(cardinalDirection);
     });
     entity.onMovementChange(({ isMoving, intensity }) => {
+      const owner2 = entity.owner;
+      if (!owner2) return;
       const LOW_INTENSITY_THRESHOLD = 10;
+      const hasSetAnimation = typeof owner2.setAnimation === "function";
+      const animationNameSignal = owner2.animationName;
+      const ownerHasAnimationName = animationNameSignal && typeof animationNameSignal === "object" && typeof animationNameSignal.set === "function";
       if (isMoving && intensity > LOW_INTENSITY_THRESHOLD) {
-        owner.animationName.set("walk");
+        if (hasSetAnimation) {
+          owner2.setAnimation("walk");
+        } else if (ownerHasAnimationName) {
+          animationNameSignal.set("walk");
+        }
       } else if (!isMoving) {
-        owner.animationName.set("stand");
+        if (hasSetAnimation) {
+          owner2.setAnimation("stand");
+        } else if (ownerHasAnimationName) {
+          animationNameSignal.set("stand");
+        }
       }
     });
     const entityWidth = width;
@@ -10346,10 +10398,7 @@ class RpgCommonMap {
   moveBody(player, direction) {
     const entity = this.physic.getEntityByUUID(player.id);
     if (!entity) return false;
-    const speedValue = typeof player.speed === "function" ? Number(player.speed()) : 0;
-    if (typeof player.setIntendedDirection === "function") {
-      player.setIntendedDirection(direction);
-    }
+    const speedValue = player.speed();
     let vx = 0, vy = 0;
     switch (direction) {
       case Direction.Left:
@@ -10401,9 +10450,6 @@ class RpgCommonMap {
     const entity = this.physic.getEntityByUUID(player.id);
     if (!entity) return false;
     this.moveManager.stopMovement(player.id);
-    if (typeof player.setIntendedDirection === "function") {
-      player.setIntendedDirection(null);
-    }
     player.pendingInputs = [];
     return true;
   }
@@ -11173,5 +11219,213 @@ var PrebuiltGui = /* @__PURE__ */ ((PrebuiltGui2) => {
   return PrebuiltGui2;
 })(PrebuiltGui || {});
 
-export { AABB, AABBCollider, AnchorConstraint, Animation, BVH, CapsuleCollider, CircleCollider, CollisionResolver, CompositeMovement, Control, Dash, DeterministicInputBuffer, Direction, DistanceConstraint, EPSILON$1 as EPSILON, Entity, EntityMovementBody, EntityState, EventSystem, Hooks, IceMovement, IntegrationMethod, Integrator, Item, Knockback, LinearMove, LinearRepulsion, Matrix2, ModulesToken, MovementManager$1 as MovementManager, ObjectPool, Oscillate, PathFollow, PhysicsEngine, PolygonCollider, PrebuiltGui, PredictionController, ProjectileMovement, ProjectileType, Quadtree, Ray, Region, RegionManager, RpgCommonMap, RpgCommonPlayer, RpgModule, RpgShape, SeekAvoid, Side, SpatialHash, SpringConstraint, UpdateMapService, UpdateMapToken, Vector2, World, WorldMapsManager, ZoneManager, angleBetween, angularDistance, applyAttraction, applyConstantForce, applyDirectionalForce, applyExplosion, applyMixins, applyRepulsion, applySpring, approximatelyEqual, arrayEquals, arrayFlat, arrayUniq, assignPolygonCollider, basename, camelToKebab, capitalize, clamp, closestPointOnAABB, combineMixins, createCollider, createConstructor, createModule, defineModule, degToRad, distance, distanceSquared, elementToPositionAbsolute, extractId, findCollisions, findModules, fps2ms, generateDeterministicUUID, generateUID, generateUUID, hexaToNumber, intersection, isArray, isBrowser, isClass, isFunction, isInstanceOf, isObject, isPromise, isString, lerp, mergeObjectWithMethods, migrateEntities, migrateEntity, normalizeAngle, pointInCircle, preciseNow, projectPointOnLineSegment, provideModules, radToDeg, random, raycast, round, set, sharedArrayBuffer, sweepEntities, testCollision, toRadians };
+class PerlinNoise2D {
+  /**
+   * 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 = 0) {
+    this.permutation = this.generatePermutation(seed);
+    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
+   */
+  generatePermutation(seed) {
+    const p = [];
+    for (let i = 0; i < 256; i++) {
+      p[i] = i;
+    }
+    let state = seed;
+    const lcg = () => {
+      state = state * 1103515245 + 12345 & 2147483647;
+      return state;
+    };
+    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
+   */
+  fade(t) {
+    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
+   */
+  lerp(a, b, t) {
+    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
+   */
+  grad(hash, x, y) {
+    const h = hash & 3;
+    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, y, scale = 0.1) {
+    x *= scale;
+    y *= scale;
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    x -= Math.floor(x);
+    y -= Math.floor(y);
+    const u = this.fade(x);
+    const v = this.fade(y);
+    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];
+    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, y, scale = 0.1) {
+    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, y, min, max, scale = 0.1) {
+    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, y, min, max, scale = 0.1) {
+    const value = this.getRange(x, y, min, max + 1, scale);
+    return Math.floor(value);
+  }
+}
+let sharedInstance = null;
+function getSharedPerlinNoise(seed) {
+  if (!sharedInstance) {
+    sharedInstance = new PerlinNoise2D(seed);
+  }
+  return sharedInstance;
+}
+function resetSharedPerlinNoise(seed) {
+  sharedInstance = new PerlinNoise2D(seed);
+}
+
+export { AABB, AABBCollider, AnchorConstraint, Animation, BVH, CapsuleCollider, CircleCollider, CollisionResolver, CompositeMovement, Control, Dash, DeterministicInputBuffer, Direction, DistanceConstraint, EPSILON$1 as EPSILON, Entity, EntityMovementBody, EntityState, EventSystem, Hooks, IceMovement, IntegrationMethod, Integrator, Item, Knockback, LinearMove, LinearRepulsion, Matrix2, ModulesToken, MovementManager$1 as MovementManager, ObjectPool, Oscillate, PathFollow, PerlinNoise2D, PhysicsEngine, PolygonCollider, PrebuiltGui, PredictionController, ProjectileMovement, ProjectileType, Quadtree, Ray, Region, RegionManager, RpgCommonMap, RpgCommonPlayer, RpgModule, RpgShape, SeekAvoid, Side, SpatialHash, SpringConstraint, UpdateMapService, UpdateMapToken, Vector2, World, WorldMapsManager, ZoneManager, angleBetween, angularDistance, applyAttraction, applyConstantForce, applyDirectionalForce, applyExplosion, applyMixins, applyRepulsion, applySpring, approximatelyEqual, arrayEquals, arrayFlat, arrayUniq, assignPolygonCollider, basename, camelToKebab, capitalize, clamp, closestPointOnAABB, combineMixins, createCollider, createConstructor, createModule, defineModule, degToRad, distance, distanceSquared, elementToPositionAbsolute, extractId, findCollisions, findModules, fps2ms, generateDeterministicUUID, generateUID, generateUUID, getSharedPerlinNoise, hexaToNumber, intersection, isArray, isBrowser, isClass, isFunction, isInstanceOf, isObject, isPromise, isString, lerp, mergeObjectWithMethods, migrateEntities, migrateEntity, normalizeAngle, pointInCircle, preciseNow, projectPointOnLineSegment, provideModules, radToDeg, random, raycast, resetSharedPerlinNoise, round, set, sharedArrayBuffer, sweepEntities, testCollision, toRadians };
 //# sourceMappingURL=index.js.map