murow 0.0.60 → 0.0.71

package/dist/core/fixed-ticker/fixed-ticker.js

@@ -1,101 +0,0 @@
-/**
- * @description
- * A utility class for managing fixed-rate update ticks, useful for deterministic behaviour
- * in both client and server.
- *
- * The `FixedTicker` accumulates elapsed time and determines how many fixed-interval "ticks"
- * should be processed based on a specified tick rate. It also limits the maximum number of
- * ticks per frame to prevent runaway update loops when frame times are long.
- *
- *
- * @remarks
- * - The `tick` method should be called once per frame, passing the elapsed time in seconds.
- * - The class ensures that no more than a safe number of ticks are processed per frame.
- */
-export class FixedTicker {
-    constructor({ rate, onTick }) {
-        /**
-         * @description Accumulator for the time passed since the last tick
-         */
-        this.accumulator = 0;
-        /**
-         * @description
-         * Internal counter for the number of ticks processed.
-         */
-        this._tickCount = 0;
-        this.rate = rate;
-        this.intervalMs = 1000 / this.rate;
-        this.onTick = onTick;
-        // Allow up to rate/2 ticks per frame, but at least 1.
-        // Prevents runaway loops if delta is too large.
-        this.maxTicksPerFrame = Math.max(1, Math.floor(rate / 2));
-    }
-    /**
-     * @description
-     * Returns how many ticks to run.
-     *
-     * @param deltaTime Delta time in seconds
-     * @returns {number} Amount of ticks to run
-     */
-    getTicks(deltaTime) {
-        this.accumulator += deltaTime * 1000;
-        let ticks = 0;
-        while (this.accumulator >= this.intervalMs &&
-            ticks < this.maxTicksPerFrame) {
-            this.accumulator -= this.intervalMs;
-            ticks++;
-        }
-        const skippedTicks = Math.floor(this.accumulator / this.intervalMs);
-        if (skippedTicks > 0 && this.onTickSkipped) {
-            this.onTickSkipped(skippedTicks);
-        }
-        return ticks;
-    }
-    /**
-     * @description
-     * Processes the ticks based on the elapsed time.
-     *
-     * @param deltaTime Delta time in seconds
-     */
-    tick(deltaTime) {
-        const ticks = this.getTicks(deltaTime);
-        for (let i = 0; i < ticks; i++) {
-            this.onTick(1 / this.rate, this._tickCount++);
-        }
-    }
-    /**
-     * @description
-     * Returns the number of ticks processed since the last reset.
-     *
-     * @returns {number} Number of ticks processed
-     */
-    get tickCount() {
-        return this._tickCount;
-    }
-    /**
-     * @description
-     * Resets the tick count to zero.
-     */
-    resetTickCount() {
-        this._tickCount = 0;
-    }
-    /**
-     * @description
-     * Returns the accumulated time in seconds, useful for interpolation.
-     *
-     * @returns {number} Accumulated time in seconds
-     */
-    get accumulatedTime() {
-        return this.accumulator / 1000; // Convert to seconds
-    }
-    /**
-     * @description
-     * Returns the interpolation factor between 0 and 1 for smooth rendering between ticks.
-     * Clamped to prevent extrapolation when ticks are skipped.
-     *
-     * @returns {number} Alpha value between 0 and 1
-     */
-    get alpha() {
-        return Math.min(this.accumulatedTime / (1 / this.rate), 1.0);
-    }
-}

package/dist/core/fixed-ticker/index.js

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

package/dist/core/generate-id/generate-id.js

@@ -1,25 +0,0 @@
-/**
- * @description
- * Generates a unique identifier as a hexadecimal string.
- * Can include a prefix and a custom total length.
- *
- * @param options Optional configuration: prefix and total size
- * @returns A unique identifier string
- *
- * @example
- * generateId(); // "f3a2b1c4d5e67890"
- * generateId({ prefix: 'user_' }); // "user_f3a2b1c4d5e67890"
- * generateId({ prefix: 'user_', size: 24 }); // "user_00f3a2b1c4d5e67890"
- */
-export function generateId(options = {}) {
-    const { prefix = "", size = 16 } = options;
-    // compute number of hex characters to generate (subtract prefix length)
-    const hexLength = Math.max(size - prefix.length, 8); // min 8 hex chars
-    // number of 32-bit integers needed to cover the hexLength
-    const numInts = Math.ceil(hexLength / 8);
-    const arr = crypto.getRandomValues(new Uint32Array(numInts));
-    let id = arr.reduce((acc, val) => acc + val.toString(16).padStart(8, "0"), "");
-    // truncate/pad to desired length
-    id = id.slice(0, hexLength).padStart(hexLength, "0");
-    return `${prefix}${id}`;
-}

package/dist/core/generate-id/index.js

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

package/dist/core/index.js

@@ -1,9 +0,0 @@
-export * from './binary-codec';
-export * from './events';
-export * from './fixed-ticker';
-export * from './generate-id';
-export * from './lerp';
-export * from './loop';
-export * from './navmesh';
-export * from './pooled-codec';
-export * from './prediction';

package/dist/core/lerp/index.js

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

package/dist/core/lerp/lerp.js

@@ -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, end, t) {
-    return start + (end - start) * t;
-}

package/dist/core/loop/drivers/immediate.js

@@ -1,61 +0,0 @@
-/**
- * Server-side game loop driver using setImmediate.
- *
- * This driver runs the game loop as fast as possible without blocking the event loop,
- * making it suitable for Node.js server environments where high tick rates are desired.
- *
- * Delta time is automatically calculated between iterations and passed to the update callback in seconds.
- *
- * **Note:** This driver requires Node.js as it uses `setImmediate` which is not available in browsers.
- *
- * @example
- * ```typescript
- * const driver = new ImmediateDriver((dt) => {
- *   world.tick(dt);
- *   broadcastState();
- * });
- * driver.start();
- * ```
- */
-export class ImmediateDriver {
-    /**
-     * @param update - Callback invoked each tick with delta time in seconds
-     */
-    constructor(update) {
-        this.update = update;
-        this.last = performance.now();
-        this.running = false;
-        /**
-         * Internal loop method that calculates delta time and schedules the next iteration.
-         *
-         * Delta time is provided in seconds.
-         */
-        this.loop = () => {
-            if (!this.running)
-                return;
-            const now = performance.now();
-            const dt = (now - this.last) / 1000;
-            this.last = now;
-            this.update(dt);
-            setImmediate(this.loop);
-        };
-    }
-    /**
-     * Starts the game loop using setImmediate.
-     *
-     * Resets timing to prevent large initial delta.
-     */
-    start() {
-        this.running = true;
-        this.last = performance.now();
-        this.loop();
-    }
-    /**
-     * Stops the game loop.
-     *
-     * Note: Does not cancel already queued setImmediate callbacks.
-     */
-    stop() {
-        this.running = false;
-    }
-}

package/dist/core/loop/drivers/index.js

@@ -1,3 +0,0 @@
-export * from "./immediate";
-export * from "./raf";
-export * from "./timeout";

package/dist/core/loop/drivers/raf.js

@@ -1,62 +0,0 @@
-/**
- * Client-side game loop driver using requestAnimationFrame.
- *
- * This driver synchronizes updates with the browser's display refresh rate (typically 60 FPS),
- * providing smooth rendering and automatic throttling when the tab is not visible.
- *
- * Delta time is automatically calculated between frames and passed to the update callback in seconds.
- *
- * @example
- * ```typescript
- * const driver = new RafDriver((dt) => {
- *   player.update(dt);
- *   renderer.render();
- * });
- * driver.start();
- * ```
- */
-export class RafDriver {
-    /**
-     * @param update - Callback invoked each frame with delta time in seconds
-     */
-    constructor(update) {
-        this.update = update;
-        this.last = performance.now();
-        this.running = false;
-        this.rafId = null;
-        /**
-         * Internal loop method that calculates delta time and schedules the next frame.
-         *
-         * Delta time is provided in seconds.
-         */
-        this.loop = () => {
-            if (!this.running)
-                return;
-            const now = performance.now();
-            const dt = (now - this.last) / 1000;
-            this.last = now;
-            this.update(dt);
-            requestAnimationFrame(this.loop);
-        };
-    }
-    /**
-     * Starts the game loop using requestAnimationFrame.
-     *
-     * Resets timing to prevent large initial delta.
-     */
-    start() {
-        this.running = true;
-        this.last = performance.now();
-        this.rafId = requestAnimationFrame(this.loop);
-    }
-    /**
-     * Stops the game loop and cancels any pending animation frame.
-     */
-    stop() {
-        this.running = false;
-        if (this.rafId !== null) {
-            cancelAnimationFrame(this.rafId);
-            this.rafId = null;
-        }
-    }
-}

package/dist/core/loop/drivers/timeout.js

@@ -1,71 +0,0 @@
-/**
- * Minimal delay for setTimeout-based loop scheduling.
- * Using 1ms allows the event loop to process I/O while still maintaining high tick rates.
- */
-const TIMEOUT_DELAY = 1;
-/**
- * Server-side game loop driver using setTimeout.
- *
- * This driver provides a more controlled alternative to setImmediate, running the game loop
- * with a minimal delay (1ms) between iterations. This ensures the event loop can process
- * I/O operations while maintaining high tick rates.
- *
- * Unlike setImmediate which runs as fast as possible, setTimeout provides better I/O responsiveness
- * by yielding to the event loop between ticks with a minimal delay.
- *
- * Delta time is automatically calculated between iterations and passed to the update callback in seconds.
- *
- * **Note:** This driver is designed for Node.js/Bun server environments. For maximum performance
- * without I/O concerns, use ImmediateDriver instead.
- *
- * @example
- * ```typescript
- * const driver = new TimeoutDriver((dt) => {
- *   world.tick(dt);
- *   broadcastState();
- * });
- * driver.start();
- * ```
- */
-export class TimeoutDriver {
-    /**
-     * @param update - Callback invoked each tick with delta time in seconds
-     */
-    constructor(update) {
-        this.update = update;
-        this.last = performance.now();
-        this.running = false;
-        /**
-         * Internal loop method that calculates delta time and schedules the next iteration.
-         *
-         * Delta time is provided in seconds. Uses 1ms delay to allow I/O processing.
-         */
-        this.loop = () => {
-            if (!this.running)
-                return;
-            const now = performance.now();
-            const dt = (now - this.last) / 1000;
-            this.last = now;
-            this.update(dt);
-            setTimeout(this.loop, TIMEOUT_DELAY);
-        };
-    }
-    /**
-     * Starts the game loop using setTimeout with minimal delay.
-     *
-     * Resets timing to prevent large initial delta.
-     */
-    start() {
-        this.running = true;
-        this.last = performance.now();
-        this.loop();
-    }
-    /**
-     * Stops the game loop.
-     *
-     * Note: Does not cancel already queued setTimeout callbacks.
-     */
-    stop() {
-        this.running = false;
-    }
-}

package/dist/core/loop/index.js

@@ -1,2 +0,0 @@
-export * from './loop';
-export * from './drivers';

package/dist/core/loop/loop.js

@@ -1,47 +0,0 @@
-import { ImmediateDriver, RafDriver, TimeoutDriver } from "./drivers";
-// Re-export driver classes for testing and direct usage
-export { ImmediateDriver, RafDriver, TimeoutDriver };
-/**
- * Factory function to create a loop driver for the specified environment.
- *
- * @param type - The environment type
- *   - `'client'`: Browser RAF driver (60 FPS, syncs with display)
- *   - `'server'`: Node.js setImmediate driver (maximum performance)
- *   - `'server-timeout'`: Node.js setTimeout driver (balanced with I/O)
- * @param update - Callback function invoked each frame with delta time in seconds
- * @returns A configured LoopDriver instance ready to start
- *
- * @example
- * ```typescript
- * // Client
- * const clientDriver = createDriver('client', (dt) => {
- *   game.update(dt);
- *   renderer.render();
- * });
- * clientDriver.start();
- *
- * // Server (maximum performance)
- * const serverDriver = createDriver('server', (dt) => {
- *   simulation.tick(dt);
- * });
- * serverDriver.start();
- *
- * // Server (balanced with I/O)
- * const balancedDriver = createDriver('server-timeout', (dt) => {
- *   simulation.tick(dt);
- *   handleNetworkIO();
- * });
- * balancedDriver.start();
- * ```
- */
-export function createDriver(type, update) {
-    if (type === 'server-immediate') {
-        return new ImmediateDriver(update);
-    }
-    else if (type === 'server-timeout') {
-        return new TimeoutDriver(update);
-    }
-    else {
-        return new RafDriver(update);
-    }
-}

package/dist/core/navmesh/index.js

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

package/dist/core/navmesh/navmesh-worker-pool.js

@@ -1,180 +0,0 @@
-/**
- * NavMesh Worker Pool - Manages multiple workers for parallel pathfinding
- */
-export class NavMeshWorkerPool {
-    constructor(poolSize, workerPath, navType = 'grid', obstacles = []) {
-        this.poolSize = poolSize;
-        this.workerPath = workerPath;
-        this.navType = navType;
-        this.obstacles = obstacles;
-        this.workers = [];
-        this.nextWorkerIndex = 0;
-        this.requestId = 0;
-        this.pendingRequests = new Map();
-        this.initialized = false;
-    }
-    /**
-     * Initialize all workers in the pool
-     */
-    async init() {
-        if (this.initialized)
-            return;
-        const initPromises = [];
-        for (let i = 0; i < this.poolSize; i++) {
-            const worker = new Worker(this.workerPath, { type: 'module' });
-            // Set up message handler
-            worker.onmessage = (e) => {
-                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((resolve) => {
-                const onReady = (e) => {
-                    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, to) {
-        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((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) {
-        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((resolve) => {
-                const onAdded = (e) => {
-                    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) {
-        if (!this.initialized) {
-            throw new Error('Worker pool not initialized. Call init() first.');
-        }
-        const promises = this.workers.map((worker) => {
-            return new Promise((resolve) => {
-                const onRemoved = (e) => {
-                    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, pos) {
-        if (!this.initialized) {
-            throw new Error('Worker pool not initialized. Call init() first.');
-        }
-        const promises = this.workers.map((worker) => {
-            return new Promise((resolve) => {
-                const onMoved = (e) => {
-                    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() {
-        return this.pendingRequests.size;
-    }
-    /**
-     * Get the pool size
-     */
-    get size() {
-        return this.workers.length;
-    }
-}