murow 0.0.70 → 0.0.71

package/src/core/lerp/README.md

@@ -1,79 +0,0 @@
-# lerp
-
-A simple utility function for linear interpolation between two numeric values. Perfect for smooth animations, transitions, and value easing in game development.
-
-## Features
-
-- Clean linear interpolation implementation.
-- Unclamped by design - allows extrapolation when t is outside [0, 1].
-- Zero dependencies.
-- Works in browsers and Node.js.
-- TypeScript support with proper type definitions.
-
-## Usage
-
-```typescript
-import { lerp } from './lerp';
-
-// Basic interpolation
-const value = lerp(0, 100, 0.5); // Returns 50
-
-// Animation example
-const startPos = 0;
-const endPos = 100;
-const progress = 0.75;
-const currentPos = lerp(startPos, endPos, progress); // Returns 75
-
-// Smooth camera movement
-function updateCamera(deltaTime: number) {
-  const t = deltaTime * smoothingFactor;
-  camera.x = lerp(camera.x, target.x, t);
-  camera.y = lerp(camera.y, target.y, t);
-}
-
-// Color transitions
-const r = lerp(startColor.r, endColor.r, progress);
-const g = lerp(startColor.g, endColor.g, progress);
-const b = lerp(startColor.b, endColor.b, progress);
-```
-
-## Parameters
-
-- `start` (number): The starting value (returned when t = 0)
-- `end` (number): The ending value (returned when t = 1)
-- `t` (number): The interpolation factor, typically in range [0, 1]
-
-## Returns
-
-`number` - The interpolated value between start and end.
-
-## Extrapolation
-
-The function does not clamp the `t` parameter, allowing extrapolation:
-
-```typescript
-lerp(0, 100, 1.5);  // Returns 150 (extrapolated beyond end)
-lerp(0, 100, -0.5); // Returns -50 (extrapolated before start)
-```
-
-If you need clamped interpolation, combine with a clamp function:
-
-```typescript
-function clampedLerp(start: number, end: number, t: number): number {
-  const clampedT = Math.max(0, Math.min(1, t));
-  return lerp(start, end, clampedT);
-}
-```
-
-## Common Use Cases
-
-- **Smooth animations**: Interpolate position, rotation, scale over time
-- **Camera movement**: Create smooth camera following behavior
-- **UI transitions**: Fade effects, sliding panels, progress bars
-- **Color blending**: Transition between colors smoothly
-- **Value easing**: Gradually approach target values
-- **Physics simulations**: Interpolate between physics states for rendering
-
----
-
-`lerp` provides a foundational building block for smooth, continuous value transitions in game development and interactive applications.

package/src/core/lerp/index.ts

@@ -1 +0,0 @@
-export * from './lerp';

package/src/core/lerp/lerp.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { lerp } from "./lerp";
-
-describe("lerp", () => {
-  test("should return start value when t is 0", () => {
-    expect(lerp(0, 100, 0)).toBe(0);
-    expect(lerp(50, 200, 0)).toBe(50);
-    expect(lerp(-10, 10, 0)).toBe(-10);
-  });
-
-  test("should return end value when t is 1", () => {
-    expect(lerp(0, 100, 1)).toBe(100);
-    expect(lerp(50, 200, 1)).toBe(200);
-    expect(lerp(-10, 10, 1)).toBe(10);
-  });
-
-  test("should return midpoint when t is 0.5", () => {
-    expect(lerp(0, 100, 0.5)).toBe(50);
-    expect(lerp(50, 150, 0.5)).toBe(100);
-    expect(lerp(-10, 10, 0.5)).toBe(0);
-  });
-
-  test("should interpolate between positive values", () => {
-    expect(lerp(0, 100, 0.25)).toBe(25);
-    expect(lerp(0, 100, 0.75)).toBe(75);
-    expect(lerp(10, 20, 0.3)).toBeCloseTo(13, 5);
-  });
-
-  test("should interpolate between negative values", () => {
-    expect(lerp(-100, -50, 0.5)).toBe(-75);
-    expect(lerp(-10, -5, 0.2)).toBe(-9);
-  });
-
-  test("should interpolate from negative to positive", () => {
-    expect(lerp(-50, 50, 0.5)).toBe(0);
-    expect(lerp(-10, 10, 0.25)).toBe(-5);
-    expect(lerp(-10, 10, 0.75)).toBe(5);
-  });
-
-  test("should handle extrapolation when t > 1", () => {
-    expect(lerp(0, 100, 1.5)).toBe(150);
-    expect(lerp(0, 100, 2)).toBe(200);
-    expect(lerp(10, 20, 1.1)).toBeCloseTo(21, 5);
-  });
-
-  test("should handle extrapolation when t < 0", () => {
-    expect(lerp(0, 100, -0.5)).toBe(-50);
-    expect(lerp(0, 100, -1)).toBe(-100);
-    expect(lerp(10, 20, -0.1)).toBeCloseTo(9, 5);
-  });
-
-  test("should handle same start and end values", () => {
-    expect(lerp(50, 50, 0)).toBe(50);
-    expect(lerp(50, 50, 0.5)).toBe(50);
-    expect(lerp(50, 50, 1)).toBe(50);
-    expect(lerp(50, 50, 2)).toBe(50);
-  });
-
-  test("should handle floating point values", () => {
-    expect(lerp(0.1, 0.9, 0.5)).toBeCloseTo(0.5, 10);
-    expect(lerp(1.5, 2.5, 0.3)).toBeCloseTo(1.8, 10);
-  });
-
-  test("should be commutative with inverted t", () => {
-    const start = 10;
-    const end = 20;
-    expect(lerp(start, end, 0.3)).toBeCloseTo(lerp(end, start, 0.7), 10);
-  });
-
-  test("should handle very small differences", () => {
-    expect(lerp(1.0, 1.0001, 0.5)).toBeCloseTo(1.00005, 10);
-  });
-
-  test("should handle very large values", () => {
-    expect(lerp(1e10, 2e10, 0.5)).toBe(1.5e10);
-  });
-
-  test("should be linear (no easing)", () => {
-    const start = 0;
-    const end = 100;
-    const step = 0.1;
-    const expectedDiff = 10;
-
-    for (let t = 0; t < 1; t += step) {
-      const val1 = lerp(start, end, t);
-      const val2 = lerp(start, end, t + step);
-      expect(val2 - val1).toBeCloseTo(expectedDiff, 5);
-    }
-  });
-});

package/src/core/lerp/lerp.ts

@@ -1,42 +0,0 @@
-/**
- * @description
- * Performs linear interpolation between two values.
- *
- * Linear interpolation (lerp) calculates a value between a start and end point
- * based on a normalized interpolation factor (t). When t = 0, the result equals
- * the start value; when t = 1, the result equals the end value. Values of t
- * between 0 and 1 produce intermediate results.
- *
- * @remarks
- * - This function does not clamp the interpolation factor. Values of t outside
- *   the range [0, 1] will extrapolate beyond the start and end values.
- * - For clamped interpolation, combine with a clamp function on the t parameter.
- * - Commonly used for smooth animations, camera movements, and value transitions.
- *
- * @param start - The starting value (when t = 0)
- * @param end - The ending value (when t = 1)
- * @param t - The interpolation factor, typically in the range [0, 1]
- *
- * @returns {number} The interpolated value between start and end
- *
- * @example
- * ```typescript
- * // Basic interpolation
- * lerp(0, 100, 0.5);   // Returns 50
- * lerp(0, 100, 0);     // Returns 0
- * lerp(0, 100, 1);     // Returns 100
- *
- * // Animation example
- * const startPos = 0;
- * const endPos = 100;
- * const progress = 0.75;
- * const currentPos = lerp(startPos, endPos, progress); // Returns 75
- *
- * // Extrapolation (t outside [0, 1])
- * lerp(0, 100, 1.5);   // Returns 150
- * lerp(0, 100, -0.5);  // Returns -50
- * ```
- */
-export function lerp(start: number, end: number, t: number): number {
-  return start + (end - start) * t;
-}

package/src/core/navmesh/README.md

@@ -1,164 +0,0 @@
-# NavMesh / Pathfinding Utility
-
-A lightweight navigation system for grid-based and hybrid games.
-
-Supports:
-
-* **Grid A*** pathfinding
-* **Line-of-sight graph navigation**
-* **Dynamic obstacles**
-* **Spatial hashing for fast queries**
-* **Circle / Rect / Polygon obstacles**
-* **Zero rebuilds unless data changes**
-
-Designed for **games**, not CAD-grade geometry.
-
----
-
-## Features
-
-* ⚡ **Fast obstacle queries** via spatial hash
-* 🧠 **Smart rebuilds** (version-based, no unnecessary work)
-* 🧩 **Multiple obstacle types**
-* 🧭 **A*** with binary heap
-* 🧱 **Grid or graph navigation**
-* 🔁 Dynamic obstacle add / move / remove
-* 🧪 Deterministic & allocation-safe
-
----
-
-## Usage
-
-### Create navmesh
-
-```ts
-const nav = new NavMesh('grid'); // or 'graph'
-```
-
-### Add obstacles
-
-```ts
-nav.addObstacle({
-  type: 'circle',
-  pos: { x: 5, y: 5 },
-  radius: 2
-});
-```
-
-```ts
-nav.addObstacle({
-  type: 'rect',
-  pos: { x: 2, y: 3 },
-  size: { x: 4, y: 2 },
-});
-```
-
-```ts
-nav.addObstacle({
-  type: 'polygon',
-  pos: { x: 10, y: 5 },
-  points: [
-    { x: 0, y: 0 },
-    { x: 2, y: 0 },
-    { x: 1, y: 2 },
-  ],
-});
-```
-
-### Move / remove
-
-```ts
-nav.moveObstacle(id, { x: 8, y: 4 });
-nav.removeObstacle(id);
-```
-
-### Find path
-
-```ts
-const path = nav.findPath({
-  from: { x: 1, y: 1 },
-  to: { x: 10, y: 8 }
-});
-```
-
----
-
-## Web Workers (Optional)
-
-For games with many concurrent pathfinding requests (20+ units), enable workers for parallel processing:
-
-### Modes
-
-```ts
-// Default: synchronous (workers: false)
-const nav = new NavMesh('grid'); // Returns Vec2[]
-const path = nav.findPath({ from, to });
-
-// Always use workers (workers: true)
-const nav = new NavMesh('grid', { workers: true }); // Returns Promise<Vec2[]>
-const path = await nav.findPath({ from, to });
-
-// Auto mode (workers: 'auto')
-const nav = new NavMesh('grid', { workers: 'auto' }); // Returns Vec2[] | Promise<Vec2[]>
-const result = nav.findPath({ from, to });
-const path = result instanceof Promise ? await result : result;
-```
-
-### Performance
-
-- **Single path**: Sync mode faster (no worker overhead)
-- **20+ parallel paths**: Workers ~3x faster
-- **30+ unit RTS**: Workers ~4.5x faster (35 FPS → 162 FPS)
-
-Use workers for RTS/strategy games with many simultaneous pathfinding requests.
-
-```ts
-// Custom pool size (default: 4)
-const nav = new NavMesh('grid', {
-  workers: true,
-  workerPoolSize: 8,
-  workerPath: './custom-worker.js'
-});
-```
-
----
-
-## Navigation Modes
-
-### `grid`
-
-* A* over grid cells
-* Accurate
-* Best for RTS / tactics / tile games
-
-### `graph`
-
-* Line-of-sight check
-* Falls back to grid if blocked
-* Faster for open maps
-
----
-
-## Performance
-
-| Feature        | Cost                              |
-| -------------- | --------------------------------- |
-| Obstacle query | **O(1)** avg                      |
-| Grid rebuild   | O(n × area)                       |
-| Pathfinding    | O(bᵈ log n)                       |
-| Memory         | Minimal, no allocations per frame |
-
-Handles:
-
-* 1k+ obstacles
-* 10k+ A* nodes
-* Real-time updates
-
----
-
-## Notes
-
-* Polygon points **must be local (0,0-based)**
-* Rotation is supported for rects & polygons
-* All math is deterministic
-* No dependencies

package/src/core/navmesh/index.ts

@@ -1 +0,0 @@
-export * from './navmesh';

package/src/core/navmesh/navmesh-worker-pool.ts

@@ -1,236 +0,0 @@
-/**
- * NavMesh Worker Pool - Manages multiple workers for parallel pathfinding
- */
-
-import { ObstacleInput } from './navmesh';
-
-interface Vec2 {
-  x: number;
-  y: number;
-}
-
-interface PathRequest {
-  id: number;
-  from: Vec2;
-  to: Vec2;
-  resolve: (path: Vec2[]) => void;
-  reject: (error: Error) => void;
-}
-
-interface PathResultMessage {
-  type: 'PATH_RESULT';
-  id: number;
-  path: Vec2[];
-  duration: number;
-}
-
-interface ErrorMessage {
-  type: 'ERROR';
-  error: string;
-}
-
-type WorkerResponse = PathResultMessage | ErrorMessage;
-
-export class NavMeshWorkerPool {
-  private workers: Worker[] = [];
-  private nextWorkerIndex = 0;
-  private requestId = 0;
-  private pendingRequests = new Map<number, PathRequest>();
-  private initialized = false;
-
-  constructor(
-    private poolSize: number,
-    private workerPath: string,
-    private navType: 'grid' | 'graph' = 'grid',
-    private obstacles: ObstacleInput[] = []
-  ) {}
-
-  /**
-   * Initialize all workers in the pool
-   */
-  async init(): Promise<void> {
-    if (this.initialized) return;
-
-    const initPromises: Promise<void>[] = [];
-
-    for (let i = 0; i < this.poolSize; i++) {
-      const worker = new Worker(this.workerPath, { type: 'module' });
-
-      // Set up message handler
-      worker.onmessage = (e: MessageEvent<WorkerResponse>) => {
-        const msg = e.data;
-
-        if (msg.type === 'PATH_RESULT') {
-          const request = this.pendingRequests.get(msg.id);
-          if (request) {
-            request.resolve(msg.path);
-            this.pendingRequests.delete(msg.id);
-          }
-        } else if (msg.type === 'ERROR') {
-          // Reject all pending requests for this worker
-          for (const [id, request] of this.pendingRequests.entries()) {
-            request.reject(new Error(msg.error));
-            this.pendingRequests.delete(id);
-          }
-        }
-      };
-
-      worker.onerror = (error) => {
-        console.error('Worker error:', error);
-        // Reject all pending requests for this worker
-        for (const [id, request] of this.pendingRequests.entries()) {
-          request.reject(new Error('Worker error'));
-          this.pendingRequests.delete(id);
-        }
-      };
-
-      this.workers.push(worker);
-
-      // Initialize worker
-      const readyPromise = new Promise<void>((resolve) => {
-        const onReady = (e: MessageEvent) => {
-          if (e.data.type === 'READY') {
-            worker.removeEventListener('message', onReady);
-            resolve();
-          }
-        };
-        worker.addEventListener('message', onReady);
-      });
-
-      worker.postMessage({
-        type: 'INIT',
-        navType: this.navType,
-        obstacles: this.obstacles,
-      });
-
-      initPromises.push(readyPromise);
-    }
-
-    await Promise.all(initPromises);
-    this.initialized = true;
-  }
-
-  /**
-   * Find a path using the next available worker (round-robin)
-   */
-  async findPath(from: Vec2, to: Vec2): Promise<Vec2[]> {
-    if (!this.initialized) {
-      throw new Error('Worker pool not initialized. Call init() first.');
-    }
-
-    const id = this.requestId++;
-    const worker = this.workers[this.nextWorkerIndex];
-    this.nextWorkerIndex = (this.nextWorkerIndex + 1) % this.workers.length;
-
-    return new Promise<Vec2[]>((resolve, reject) => {
-      this.pendingRequests.set(id, { id, from, to, resolve, reject });
-
-      worker.postMessage({
-        type: 'FIND_PATH',
-        id,
-        from,
-        to,
-      });
-    });
-  }
-
-  /**
-   * Add an obstacle to all workers
-   */
-  async addObstacle(obstacle: ObstacleInput): Promise<number> {
-    if (!this.initialized) {
-      throw new Error('Worker pool not initialized. Call init() first.');
-    }
-
-    // Add to all workers
-    const promises = this.workers.map((worker) => {
-      return new Promise<number>((resolve) => {
-        const onAdded = (e: MessageEvent) => {
-          if (e.data.type === 'OBSTACLE_ADDED') {
-            worker.removeEventListener('message', onAdded);
-            resolve(e.data.obstacleId);
-          }
-        };
-        worker.addEventListener('message', onAdded);
-        worker.postMessage({ type: 'ADD_OBSTACLE', obstacle });
-      });
-    });
-
-    const ids = await Promise.all(promises);
-    return ids[0]; // All workers should return the same ID
-  }
-
-  /**
-   * Remove an obstacle from all workers
-   */
-  async removeObstacle(obstacleId: number): Promise<void> {
-    if (!this.initialized) {
-      throw new Error('Worker pool not initialized. Call init() first.');
-    }
-
-    const promises = this.workers.map((worker) => {
-      return new Promise<void>((resolve) => {
-        const onRemoved = (e: MessageEvent) => {
-          if (e.data.type === 'OBSTACLE_REMOVED') {
-            worker.removeEventListener('message', onRemoved);
-            resolve();
-          }
-        };
-        worker.addEventListener('message', onRemoved);
-        worker.postMessage({ type: 'REMOVE_OBSTACLE', obstacleId });
-      });
-    });
-
-    await Promise.all(promises);
-  }
-
-  /**
-   * Move an obstacle in all workers
-   */
-  async moveObstacle(obstacleId: number, pos: Vec2): Promise<void> {
-    if (!this.initialized) {
-      throw new Error('Worker pool not initialized. Call init() first.');
-    }
-
-    const promises = this.workers.map((worker) => {
-      return new Promise<void>((resolve) => {
-        const onMoved = (e: MessageEvent) => {
-          if (e.data.type === 'OBSTACLE_MOVED') {
-            worker.removeEventListener('message', onMoved);
-            resolve();
-          }
-        };
-        worker.addEventListener('message', onMoved);
-        worker.postMessage({ type: 'MOVE_OBSTACLE', obstacleId, pos });
-      });
-    });
-
-    await Promise.all(promises);
-  }
-
-  /**
-   * Terminate all workers
-   */
-  terminate() {
-    for (const worker of this.workers) {
-      worker.terminate();
-    }
-    this.workers = [];
-    this.pendingRequests.clear();
-    this.initialized = false;
-  }
-
-  /**
-   * Get the number of pending requests
-   */
-  get pendingCount(): number {
-    return this.pendingRequests.size;
-  }
-
-  /**
-   * Get the pool size
-   */
-  get size(): number {
-    return this.workers.length;
-  }
-}