murow 0.0.70 → 0.0.71

package/src/core/fixed-ticker/fixed-ticker.ts

@@ -1,174 +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 {
-  /**
-   * @description Accumulator for the time passed since the last tick (in milliseconds)
-   */
-  private accumulator = 0;
-
-  /**
-   * @description Rate of ticks per second
-   */
-  rate: number;
-
-  /**
-   * @description
-   * Interval in milliseconds per tick
-   */
-  intervalMs: number;
-
-  /**
-   * @description
-   * Maximum amount of ticks to run per frame, to avoid
-   * running too many ticks in a single frame.
-   */
-  private maxTicksPerFrame: number;
-
-  /**
-   * @description
-   * Callback to execute on each tick
-   */
-  private onTick: (deltaTime: number, tick?: number) => void;
-
-  /**
-   * @description
-   * Optional callback to execute when ticks are skipped due to high delta time.
-   * This can be useful for debugging or logging purposes.
-   */
-  private onTickSkipped?: (skippedTicks: number) => void;
-
-  /**
-   * @description
-   * Internal counter for the number of ticks processed.
-   */
-  private _tickCount = 0;
-
-  constructor({ rate, onTick }: FixedTickerProps) {
-    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
-   */
-  private getTicks(deltaTime: number): number {
-    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: number): void {
-    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(): number {
-    return this._tickCount;
-  }
-
-  /**
-   * @description
-   * Resets the tick count to zero.
-   */
-  resetTickCount(): void {
-    this._tickCount = 0;
-    this.accumulator = 0;
-  }
-
-  /**
-   * @description
-   * Returns the accumulated time in seconds, useful for interpolation.
-   *
-   * @returns {number} Accumulated time in seconds
-   */
-  get accumulatedTime(): number {
-    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(): number {
-    return Math.min(this.accumulatedTime / (1 / this.rate), 1.0);
-  }
-}
-
-interface FixedTickerProps {
-  /**
-   * @description
-   * Rate of ticks per second
-   */
-  rate: number;
-
-  /**
-   * @description
-   * Callback to execute on each tick
-   */
-  onTick: (deltaTime: number, tick?: number) => void;
-
-  /**
-   * @description
-   * Optional callback to execute when ticks are skipped due to high delta time.
-   * This can be useful for debugging or logging purposes.
-   */
-  onTickSkipped?: (skippedTicks: number) => void
-}

package/src/core/fixed-ticker/index.ts

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

package/src/core/generate-id/README.md

@@ -1,18 +0,0 @@
-# generateId
-
-A simple utility function to generate unique 64-bit identifiers using the Web Crypto API.
-The IDs are returned as hexadecimal strings and work in both modern browsers and Node.js (v15+).
-
-## Features
-
-- Generates cryptographically strong 64-bit IDs.
-- Returns hexadecimal strings (always padded to 16 characters).
-- Works in browsers and Node ≥15 without any imports.
-- Fast and clean using BigInt arithmetic.
-
-## Usage
-
-```typescript
-import { generateId } from './generate-id';
-const id = generateId(); // akwats 16-character hex string
-```

package/src/core/generate-id/generate-id.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { generateId } from "./generate-id";
-
-describe("generateId", () => {
-  test("should generate an ID with default length of 16", () => {
-    const id = generateId();
-    expect(id.length).toBe(16);
-  });
-
-  test("should generate a hexadecimal string", () => {
-    const id = generateId();
-    expect(id).toMatch(/^[0-9a-f]+$/);
-  });
-
-  test("should generate unique IDs", () => {
-    const ids = new Set();
-    for (let i = 0; i < 1000; i++) {
-      ids.add(generateId());
-    }
-    expect(ids.size).toBe(1000);
-  });
-
-  test("should include prefix when provided", () => {
-    const prefix = "user_";
-    const id = generateId({ prefix });
-    expect(id.startsWith(prefix)).toBe(true);
-  });
-
-  test("should maintain total size including prefix", () => {
-    const prefix = "user_";
-    const size = 20;
-    const id = generateId({ prefix, size });
-    expect(id.length).toBe(size);
-    expect(id.startsWith(prefix)).toBe(true);
-  });
-
-  test("should generate custom size without prefix", () => {
-    const size = 32;
-    const id = generateId({ size });
-    expect(id.length).toBe(size);
-  });
-
-  test("should enforce minimum of 8 hex characters", () => {
-    const prefix = "verylongprefix_";
-    const size = 10; // shorter than prefix + 8
-    const id = generateId({ prefix, size });
-    // Should be prefix + at least 8 hex chars
-    expect(id.length).toBeGreaterThanOrEqual(prefix.length + 8);
-  });
-
-  test("should pad ID to desired length", () => {
-    const size = 24;
-    const id = generateId({ size });
-    expect(id.length).toBe(size);
-  });
-
-  test("should generate different IDs on consecutive calls", () => {
-    const id1 = generateId();
-    const id2 = generateId();
-    expect(id1).not.toBe(id2);
-  });
-
-  test("should work with various prefix lengths", () => {
-    const prefixes = ["a", "ab", "abc", "player_", "super_long_prefix_"];
-    prefixes.forEach((prefix) => {
-      const id = generateId({ prefix });
-      expect(id.startsWith(prefix)).toBe(true);
-    });
-  });
-
-  test("should generate valid hex with leading zeros preserved", () => {
-    // Generate many IDs to ensure padding works correctly
-    for (let i = 0; i < 100; i++) {
-      const id = generateId({ size: 16 });
-      expect(id.length).toBe(16);
-      expect(id).toMatch(/^[0-9a-f]{16}$/);
-    }
-  });
-});

package/src/core/generate-id/generate-id.ts

@@ -1,37 +0,0 @@
-interface GenerateIdOptions {
-  /** Optional prefix to prepend to the ID */
-  prefix?: string;
-  /** Total length of the returned ID including prefix (default 16) */
-  size?: number;
-}
-
-/**
- * @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: GenerateIdOptions = {}): string {
-  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/src/core/generate-id/index.ts

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

package/src/core/index.ts

@@ -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/src/core/input/README.md

@@ -1,24 +0,0 @@
-# Input
-
-The input system is responsible for managing user input from various sources, such as keyboard and mouse events. It provides a unified interface for querying the current state of input devices and handling input events.
-
-## Key Components
-
-- **InputManager**: The main class for managing input state and events. It tracks the state of keyboard and mouse inputs and provides methods for querying this state.
-- **InputSnapshot**: A snapshot of the current input state, including the state of all keys and mouse buttons.
-- **InputEventSource**: An interface for different input event sources (e.g., browser events, gamepad events) to provide input data to the InputManager.
-
-## Usage
-
-To use the input system, create an instance of the InputManager and listen for input events from the desired input source. You can then query the current input state using the `snapshot()` and `peek()` methods.
-
-```typescript
-const inputManager = new InputManager();
-const inputSource = new BrowserInputSource(document, document.body);
-inputManager.listen(inputSource);
-
-// In your game loop
-const inputSnapshot = inputManager.snapshot();
-if (inputSnapshot.keys['Space'].hit) {
-    // Handle space key hit
-}

package/src/core/input/index.ts

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

package/src/core/input/manager.ts

@@ -1,259 +0,0 @@
-import type {
-    ButtonState,
-    InputEventSource,
-    InputHandlers,
-        InputSnapshot,
-    } from "./types";
-
-    /**
-     * 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 {
-    private keys: Record<string, ButtonState> = Object.create(null);
-    private prevKeys: Record<string, boolean> = Object.create(null);
-
-    private mouse = {
-        x: 0,
-        y: 0,
-        dx: 0,
-        dy: 0,
-        left: false,
-        right: false,
-        middle: false,
-        scrollX: 0,
-        scrollY: 0,
-    };
-
-    private prevMouse = {
-        left: false,
-        right: false,
-        middle: false,
-    };
-
-    private snapshotA: InputSnapshot;
-    private snapshotB: InputSnapshot;
-    private snapshotFlip = false;
-    private inputSource!: InputEventSource;
-
-    private handlers: InputHandlers = {
-        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),
-    };
-
-    constructor() {
-        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(): Readonly<InputSnapshot> {
-        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(): InputSnapshot {
-        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: InputEventSource) {
-        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();
-    }
-
-    private onKeyDown(e: KeyboardEvent) {
-        const key = (this.keys[e.code] ??= { down: false, hit: false, released: false });
-        key.down = true;
-    }
-
-    private onKeyUp(e: KeyboardEvent) {
-        const key = (this.keys[e.code] ??= { down: false, hit: false, released: false });
-        key.down = false;
-    }
-
-    private onMouseMove(e: MouseEvent) {
-        const rect = (e.target as HTMLElement).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;
-    }
-
-    private onMouseDown(e: MouseEvent) {
-        if (e.button === 0) this.mouse.left = true;
-        if (e.button === 1) this.mouse.middle = true;
-        if (e.button === 2) this.mouse.right = true;
-    }
-
-    private onMouseUp(e: MouseEvent) {
-        if (e.button === 0) this.mouse.left = false;
-        if (e.button === 1) this.mouse.middle = false;
-        if (e.button === 2) this.mouse.right = false;
-    }
-
-    private onMouseWheel(e: WheelEvent) {
-        this.mouse.scrollX += e.deltaX;
-        this.mouse.scrollY += e.deltaY;
-    }
-
-    private onSwipe(_dir: "up" | "down" | "left" | "right") {
-        // Gesture layer lives above core input
-    }
-
-    private onPinch(_scale: number) {
-        // Gesture layer lives above core input
-    }
-}
-
-/**
- * Creates a reusable, fully-initialized snapshot object.
- */
-function createEmptySnapshot(): InputSnapshot {
-    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: InputSnapshot,
-    keys: Record<string, ButtonState>,
-    mouse: InputManager["mouse"]
-) {
-    for (const k in keys) {
-        const dst = (snap.keys[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: InputSnapshot,
-    keys: Record<string, ButtonState>,
-    prevKeys: Record<string, boolean>,
-    mouse: InputManager["mouse"],
-    prevMouse: InputManager["prevMouse"]
-) {
-    for (const k in keys) {
-        const now = keys[k].down;
-        const prev = prevKeys[k] ?? false;
-
-        const dst = (snap.keys[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: ButtonState, now: boolean, prev: boolean) {
-    dst.down = now;
-    dst.hit = now && !prev;
-    dst.released = !now && prev;
-}

package/src/core/input/sources/browser.ts

@@ -1,39 +0,0 @@
-import { InputHandlers, InputEventSource } from "../types";
-
-export class BrowserInputSource implements InputEventSource {
-    private handlers!: InputHandlers;
-
-    constructor(
-        private keyboardTarget: Document | Window,
-        private mouseTarget: HTMLElement
-    ) { }
-
-    attach(h: InputHandlers) {
-        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/src/core/input/sources/index.ts

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

package/src/core/input/types.ts

@@ -1,40 +0,0 @@
-export type InputHandlers = {
-    keydown: (e: KeyboardEvent) => void;
-    keyup: (e: KeyboardEvent) => void;
-
-    mousemove: (e: MouseEvent) => void;
-    mousedown: (e: MouseEvent) => void;
-    mouseup: (e: MouseEvent) => void;
-
-    wheel: (e: WheelEvent) => void;
-
-    swipe: (direction: 'up' | 'down' | 'left' | 'right') => void;
-    pinch: (scale: number) => void;
-};
-
-export interface InputEventSource {
-    attach(handlers: InputHandlers): void;
-    detach(): void;
-}
-
-export type ButtonState = {
-    down: boolean;
-    hit: boolean;
-    released: boolean;
-};
-
-export type Vector2 = {
-    x: number;
-    y: number;
-};
-
-export type InputSnapshot = {
-    keys: Record<string, ButtonState>;
-    mouse: {
-        position: Vector2;
-        delta: { position: Vector2, scroll: Vector2 };
-        left: ButtonState;
-        middle: ButtonState;
-        right: ButtonState;
-    };
-};