murow 0.0.70 → 0.0.71

package/dist/core/driver/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/driver/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/driver/index.js

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

package/dist/core/events/event-system.js

@@ -1,88 +0,0 @@
-/**
- * @description
- * A callback-based event handling system designed to simplify
- * event-driven programming.
- */
-export class EventSystem {
-    constructor({ events }) {
-        this.callbacks = new Map();
-        this.events = events;
-        for (const name of this.events) {
-            this.callbacks.set(name, new Set());
-        }
-    }
-    /**
-     * @description
-     * Registers a callback for an event.
-     *
-     * @param name Event name
-     * @param callback Callback to run when the event is emitted
-     */
-    on(name, callback) {
-        const event = this.callbacks.get(name);
-        if (!event)
-            return console.warn(`Event "${name}" does not exist.`);
-        event.add(callback);
-    }
-    /**
-     * @description
-     * Registers a callback for an event that runs only once.
-     *
-     * @param name Event name
-     * @param callback Callback to run when the event is emitted
-     */
-    once(name, callback) {
-        const wrapper = (props) => {
-            callback(props);
-            this.off(name, wrapper);
-        };
-        this.on(name, wrapper);
-    }
-    /**
-     * @description
-     * Emits an event, running all registered callbacks.
-     *
-     * @param name Event name
-     * @param data Event data
-     */
-    emit(name, data) {
-        const event = this.callbacks.get(name);
-        if (!event)
-            return console.warn(`Event "${name}" does not exist.`);
-        for (const callback of event) {
-            callback(data);
-        }
-    }
-    /**
-     * @description
-     * Removes a callback from an event.
-     *
-     * @param name Event name
-     * @param callback Callback to remove
-     */
-    off(name, callback) {
-        const event = this.callbacks.get(name);
-        if (!event)
-            return console.warn(`Event "${name}" does not exist.`);
-        event.delete(callback);
-    }
-    /**
-     * @description
-     * Removes all callbacks.
-     *
-     * @param name Optional event name
-     */
-    clear(name) {
-        if (!name) {
-            this.callbacks.clear();
-            for (const name of this.events) {
-                this.callbacks.set(name, new Set());
-            }
-            return;
-        }
-        const event = this.callbacks.get(name);
-        if (!event)
-            return console.warn(`Event "${name}" does not exist.`);
-        event.clear();
-    }
-}

package/dist/core/events/index.js

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

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

@@ -1,105 +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 (in milliseconds)
-         */
-        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;
-        // Use a small epsilon relative to interval to handle floating point precision errors
-        // Without this, accumulator might be 0.9999999 when it should be 1.0
-        const epsilon = this.intervalMs * 0.001;
-        while (this.accumulator >= this.intervalMs - epsilon &&
-            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;
-        this.accumulator = 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,10 +0,0 @@
-export * from './binary-codec';
-export * from './events';
-export * from './fixed-ticker';
-export * from './generate-id';
-export * from './lerp';
-export * from './driver';
-export * from './navmesh';
-export * from './pooled-codec';
-export * from './prediction';
-export * from './input';

package/dist/core/input/index.js

@@ -1,2 +0,0 @@
-export * from "./manager";
-export * from "./sources";

package/dist/core/input/manager.js

@@ -1,211 +0,0 @@
-/**
- * Manages keyboard and mouse input.
- *
- * Design goals:
- * - Zero allocations per frame/tick
- * - Render reads live state (peek)
- * - Simulation reads frozen state (snapshot)
-* - Deterministic hit/release semantics
-*/
-export class InputManager {
-    constructor() {
-        this.keys = Object.create(null);
-        this.prevKeys = Object.create(null);
-        this.mouse = {
-            x: 0,
-            y: 0,
-            dx: 0,
-            dy: 0,
-            left: false,
-            right: false,
-            middle: false,
-            scrollX: 0,
-            scrollY: 0,
-        };
-        this.prevMouse = {
-            left: false,
-            right: false,
-            middle: false,
-        };
-        this.snapshotFlip = false;
-        this.handlers = {
-            keydown: (e) => this.onKeyDown(e),
-            keyup: (e) => this.onKeyUp(e),
-            mousemove: (e) => this.onMouseMove(e),
-            mousedown: (e) => this.onMouseDown(e),
-            mouseup: (e) => this.onMouseUp(e),
-            wheel: (e) => this.onMouseWheel(e),
-            swipe: (dir) => this.onSwipe(dir),
-            pinch: (scale) => this.onPinch(scale),
-        };
-        this.snapshotA = createEmptySnapshot();
-        this.snapshotB = createEmptySnapshot();
-    }
-    /**
-     * Returns a live, non-allocating view of the current input state.
-     *
-     * - No hit/release detection
-     * - No resets
-     * - Safe for render passes
-     */
-    peek() {
-        const snap = this.snapshotFlip ? this.snapshotA : this.snapshotB;
-        fillLiveView(snap, this.keys, this.mouse);
-        return snap;
-    }
-    /**
-     * Produces a frozen snapshot of the input state.
-     *
-     * - Computes hit/release
-     * - Resets deltas
-     * - Safe to store for the duration of the tick
-     */
-    snapshot() {
-        const snap = this.snapshotFlip ? this.snapshotA : this.snapshotB;
-        this.snapshotFlip = !this.snapshotFlip;
-        fillSnapshot(snap, this.keys, this.prevKeys, this.mouse, this.prevMouse);
-        this.mouse.dx = 0;
-        this.mouse.dy = 0;
-        this.mouse.scrollX = 0;
-        this.mouse.scrollY = 0;
-        this.prevMouse.left = this.mouse.left;
-        this.prevMouse.right = this.mouse.right;
-        this.prevMouse.middle = this.mouse.middle;
-        return snap;
-    }
-    /**
-     * Starts listening to an input event source
-     */
-    listen(source) {
-        if (this.inputSource)
-            this.inputSource.detach();
-        this.inputSource = source;
-        source.attach(this.handlers);
-    }
-    /**
-     * Stops listening to the current input source.
-     */
-    unlisten() {
-        if (!this.inputSource)
-            return;
-        this.inputSource.detach();
-    }
-    onKeyDown(e) {
-        var _a, _b;
-        const key = ((_a = this.keys)[_b = e.code] ?? (_a[_b] = { down: false, hit: false, released: false }));
-        key.down = true;
-    }
-    onKeyUp(e) {
-        var _a, _b;
-        const key = ((_a = this.keys)[_b = e.code] ?? (_a[_b] = { down: false, hit: false, released: false }));
-        key.down = false;
-    }
-    onMouseMove(e) {
-        const rect = e.target.getBoundingClientRect();
-        const x = e.clientX - rect.left;
-        const y = e.clientY - rect.top;
-        this.mouse.dx += x - this.mouse.x;
-        this.mouse.dy += y - this.mouse.y;
-        this.mouse.x = x;
-        this.mouse.y = y;
-    }
-    onMouseDown(e) {
-        if (e.button === 0)
-            this.mouse.left = true;
-        if (e.button === 1)
-            this.mouse.middle = true;
-        if (e.button === 2)
-            this.mouse.right = true;
-    }
-    onMouseUp(e) {
-        if (e.button === 0)
-            this.mouse.left = false;
-        if (e.button === 1)
-            this.mouse.middle = false;
-        if (e.button === 2)
-            this.mouse.right = false;
-    }
-    onMouseWheel(e) {
-        this.mouse.scrollX += e.deltaX;
-        this.mouse.scrollY += e.deltaY;
-    }
-    onSwipe(_dir) {
-        // Gesture layer lives above core input
-    }
-    onPinch(_scale) {
-        // Gesture layer lives above core input
-    }
-}
-/**
- * Creates a reusable, fully-initialized snapshot object.
- */
-function createEmptySnapshot() {
-    return {
-        mouse: {
-            position: { x: 0, y: 0 },
-            delta: {
-                position: { x: 0, y: 0 },
-                scroll: { x: 0, y: 0 },
-            },
-            left: { down: false, hit: false, released: false },
-            right: { down: false, hit: false, released: false },
-            middle: { down: false, hit: false, released: false },
-        },
-        keys: Object.create(null),
-    };
-}
-/**
- * Fills a snapshot with live input state.
- * No hit/release, no resets.
- */
-function fillLiveView(snap, keys, mouse) {
-    var _a;
-    for (const k in keys) {
-        const dst = ((_a = snap.keys)[k] ?? (_a[k] = { down: false, hit: false, released: false }));
-        dst.down = keys[k].down;
-        dst.hit = false;
-        dst.released = false;
-    }
-    snap.mouse.position.x = mouse.x;
-    snap.mouse.position.y = mouse.y;
-    snap.mouse.delta.position.x = mouse.dx;
-    snap.mouse.delta.position.y = mouse.dy;
-    snap.mouse.delta.scroll.x = mouse.scrollX;
-    snap.mouse.delta.scroll.y = mouse.scrollY;
-    snap.mouse.left.down = mouse.left;
-    snap.mouse.right.down = mouse.right;
-    snap.mouse.middle.down = mouse.middle;
-    snap.mouse.left.hit = snap.mouse.left.released = false;
-    snap.mouse.right.hit = snap.mouse.right.released = false;
-    snap.mouse.middle.hit = snap.mouse.middle.released = false;
-}
-/**
- * Fills a snapshot with frozen input state.
- * Computes hit/release and updates previous state.
- */
-function fillSnapshot(snap, keys, prevKeys, mouse, prevMouse) {
-    var _a;
-    for (const k in keys) {
-        const now = keys[k].down;
-        const prev = prevKeys[k] ?? false;
-        const dst = ((_a = snap.keys)[k] ?? (_a[k] = { down: false, hit: false, released: false }));
-        dst.down = now;
-        dst.hit = now && !prev;
-        dst.released = !now && prev;
-        prevKeys[k] = now;
-    }
-    snap.mouse.position.x = mouse.x;
-    snap.mouse.position.y = mouse.y;
-    snap.mouse.delta.position.x = mouse.dx;
-    snap.mouse.delta.position.y = mouse.dy;
-    snap.mouse.delta.scroll.x = mouse.scrollX;
-    snap.mouse.delta.scroll.y = mouse.scrollY;
-    applyButton(snap.mouse.left, mouse.left, prevMouse.left);
-    applyButton(snap.mouse.right, mouse.right, prevMouse.right);
-    applyButton(snap.mouse.middle, mouse.middle, prevMouse.middle);
-}
-function applyButton(dst, now, prev) {
-    dst.down = now;
-    dst.hit = now && !prev;
-    dst.released = !now && prev;
-}

package/dist/core/input/sources/browser.js

@@ -1,29 +0,0 @@
-export class BrowserInputSource {
-    constructor(keyboardTarget, mouseTarget) {
-        this.keyboardTarget = keyboardTarget;
-        this.mouseTarget = mouseTarget;
-    }
-    attach(h) {
-        if (this.handlers) {
-            this.detach();
-        }
-        this.handlers = h;
-        this.keyboardTarget.addEventListener('keydown', h.keydown);
-        this.keyboardTarget.addEventListener('keyup', h.keyup);
-        this.mouseTarget.addEventListener('mousemove', h.mousemove);
-        this.mouseTarget.addEventListener('mousedown', h.mousedown);
-        this.mouseTarget.addEventListener('mouseup', h.mouseup);
-        this.mouseTarget.addEventListener('wheel', h.wheel);
-    }
-    detach() {
-        const h = this.handlers;
-        if (!h)
-            return;
-        this.keyboardTarget.removeEventListener('keydown', h.keydown);
-        this.keyboardTarget.removeEventListener('keyup', h.keyup);
-        this.mouseTarget.removeEventListener('mousemove', h.mousemove);
-        this.mouseTarget.removeEventListener('mousedown', h.mousedown);
-        this.mouseTarget.removeEventListener('mouseup', h.mouseup);
-        this.mouseTarget.removeEventListener('wheel', h.wheel);
-    }
-}

package/dist/core/input/sources/index.js

@@ -1 +0,0 @@
-export * from "./browser";

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/navmesh/index.js

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