@netforge/engine 0.0.0-stage → 0.1.0

package/dist/runtime/feel/trauma.d.ts

@@ -0,0 +1,48 @@
+export interface TraumaOptions {
+    /** Trauma lost per second (1 = a full hit fades in one second). Default 1.4. */
+    readonly decay?: number;
+    /** shake = trauma ^ exponent. 2 or 3 reads best. Default 2. */
+    readonly exponent?: number;
+    /** Offset at full shake, in world units (m). Default 0.6. */
+    readonly maxOffset?: number;
+    /** Roll at full shake, radians. Default 0.04. */
+    readonly maxRoll?: number;
+    /** Noise frequency, Hz. Default 16. */
+    readonly frequency?: number;
+    /** Noise seed (same seed, same shake). Default 1. */
+    readonly seed?: number;
+}
+/**
+ * Trauma screen shake: hits add trauma 0..1, it decays linearly, and the
+ * shake is trauma squared, so small hits barely move the camera and big
+ * ones kick hard. Offsets come from smooth seeded noise, so the shake is
+ * fluid rather than jittery and never uses Math.random.
+ */
+export declare class Trauma {
+    /** Current trauma 0..1. */
+    value: number;
+    /** This frame's offsets (m) and roll (rad); zero when calm. */
+    x: number;
+    y: number;
+    roll: number;
+    /** Trauma adds so far (playtest counters). */
+    adds: number;
+    private time;
+    private hold;
+    private readonly o;
+    constructor(opts?: TraumaOptions);
+    get options(): Readonly<Required<TraumaOptions>>;
+    /** Add trauma (the total is clamped to 0..1). */
+    add(amount: number): void;
+    /** Same as `add`: lets a bare Trauma stand in for a CameraRig as a TraumaTarget. */
+    addTrauma(amount: number): void;
+    /** Keep the current trauma from decaying for `seconds` (the classic shake(amplitude, seconds) maps here). */
+    sustain(seconds: number): void;
+    /** The shake factor, trauma ^ exponent. */
+    get shake(): number;
+    update(dt: number): void;
+    /** Back to calm. */
+    reset(): void;
+    /** Trauma that gives a shake of about `amplitude` world units. */
+    traumaFor(amplitude: number): number;
+}

package/dist/runtime/feel/trauma.js

@@ -0,0 +1,76 @@
+import { valueNoise1 } from "./noise.js";
+/**
+ * Trauma screen shake: hits add trauma 0..1, it decays linearly, and the
+ * shake is trauma squared, so small hits barely move the camera and big
+ * ones kick hard. Offsets come from smooth seeded noise, so the shake is
+ * fluid rather than jittery and never uses Math.random.
+ */
+export class Trauma {
+    /** Current trauma 0..1. */
+    value = 0;
+    /** This frame's offsets (m) and roll (rad); zero when calm. */
+    x = 0;
+    y = 0;
+    roll = 0;
+    /** Trauma adds so far (playtest counters). */
+    adds = 0;
+    time = 0;
+    hold = 0;
+    o;
+    constructor(opts = {}) {
+        this.o = { decay: 1.4, exponent: 2, maxOffset: 0.6, maxRoll: 0.04, frequency: 16, seed: 1, ...opts };
+    }
+    get options() {
+        return this.o;
+    }
+    /** Add trauma (the total is clamped to 0..1). */
+    add(amount) {
+        if (!(amount > 0))
+            return;
+        this.adds++;
+        this.value = Math.min(1, this.value + amount);
+    }
+    /** Same as `add`: lets a bare Trauma stand in for a CameraRig as a TraumaTarget. */
+    addTrauma(amount) {
+        this.add(amount);
+    }
+    /** Keep the current trauma from decaying for `seconds` (the classic shake(amplitude, seconds) maps here). */
+    sustain(seconds) {
+        this.hold = Math.max(this.hold, seconds);
+    }
+    /** The shake factor, trauma ^ exponent. */
+    get shake() {
+        return Math.pow(this.value, this.o.exponent);
+    }
+    update(dt) {
+        if (dt > 0) {
+            this.time += dt;
+            if (this.hold > 0)
+                this.hold = Math.max(0, this.hold - dt);
+            else
+                this.value = Math.max(0, this.value - this.o.decay * dt);
+        }
+        const s = this.shake;
+        if (s === 0) {
+            this.x = this.y = this.roll = 0;
+            return;
+        }
+        const t = this.time * this.o.frequency;
+        const seed = this.o.seed;
+        this.x = this.o.maxOffset * s * valueNoise1(t, seed);
+        this.y = this.o.maxOffset * s * valueNoise1(t, seed + 101);
+        this.roll = this.o.maxRoll * s * valueNoise1(t, seed + 202);
+    }
+    /** Back to calm. */
+    reset() {
+        this.value = 0;
+        this.hold = 0;
+        this.x = this.y = this.roll = 0;
+    }
+    /** Trauma that gives a shake of about `amplitude` world units. */
+    traumaFor(amplitude) {
+        if (!(amplitude > 0))
+            return 0;
+        return Math.min(1, Math.pow(amplitude / this.o.maxOffset, 1 / this.o.exponent));
+    }
+}

package/dist/runtime/feel/tween.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Juicy UI tweens: a tiny tween manager with an easing table, and DOM
+ * helpers (pop, shake, count up) built on it. The helpers use the CSS
+ * `scale` and `translate` properties, so they never fight a transform the
+ * page already sets.
+ */
+export type EaseFn = (t: number) => number;
+export declare const Ease: {
+    readonly linear: (t: number) => number;
+    readonly quadIn: (t: number) => number;
+    readonly quadOut: (t: number) => number;
+    readonly quadInOut: (t: number) => number;
+    readonly cubicOut: (t: number) => number;
+    readonly cubicInOut: (t: number) => number;
+    readonly sineInOut: (t: number) => number;
+    readonly expoOut: (t: number) => number;
+    readonly backOut: (t: number) => number;
+    readonly elasticOut: (t: number) => number;
+    readonly bounceOut: (t: number) => number;
+};
+export type EaseName = keyof typeof Ease;
+export interface TweenOptions {
+    /** Seconds. */
+    readonly duration: number;
+    readonly ease?: EaseName | EaseFn;
+    /** Seconds before it starts (start values are read when it starts). */
+    readonly delay?: number;
+    /** Play back to the start after each forward play. */
+    readonly yoyo?: boolean;
+    /** Extra plays after the first (-1 forever). Default 0. */
+    readonly repeat?: number;
+    readonly onUpdate?: () => void;
+    readonly onDone?: () => void;
+}
+type NumericKeys<T> = {
+    [K in keyof T]: T[K] extends number ? K : never;
+}[keyof T];
+export type TweenProps<T> = Partial<Record<NumericKeys<T>, number>>;
+export declare class Tweens {
+    private list;
+    private nextId;
+    /** Tween numeric properties of `target` to `props`. Returns a handle for `cancel`. */
+    to<T extends object>(target: T, props: TweenProps<T>, opts: TweenOptions): number;
+    /** Stop a tween by handle, or every tween on a target object. Values stay where they are. */
+    cancel(handleOrTarget: number | object): void;
+    /** Tweens running or waiting. */
+    get active(): number;
+    tick(dt: number): void;
+}
+/** The shared UI tween manager. It drives itself on requestAnimationFrame in a browser; call `uiTweens.tick(dt)` elsewhere. */
+export declare const uiTweens: Tweens;
+/** A minimal element: anything with a style and text (real elements, or fakes in tests). */
+export interface FeelElement {
+    readonly style: {
+        scale: string;
+        translate: string;
+    };
+    textContent: string | null;
+}
+/** Punch an element's scale up to `scale` and spring it back (level-up, coin gain). */
+export declare function pop(el: FeelElement, scale?: number, ms?: number, tweens?: Tweens): void;
+/** Shake an element sideways by up to `px`, decaying over `ms` (denied action, damage taken). */
+export declare function shakeEl(el: FeelElement, px?: number, ms?: number, tweens?: Tweens): void;
+/** Count a number up in an element's text (scores, balances). */
+export declare function countUp(el: FeelElement, from: number, to: number, ms?: number, format?: (n: number) => string, tweens?: Tweens): void;
+export {};

package/dist/runtime/feel/tween.js

@@ -0,0 +1,180 @@
+const c1 = 1.70158;
+const c3 = c1 + 1;
+const bounce = (t) => {
+    const n = 7.5625;
+    const d = 2.75;
+    if (t < 1 / d)
+        return n * t * t;
+    if (t < 2 / d)
+        return n * (t -= 1.5 / d) * t + 0.75;
+    if (t < 2.5 / d)
+        return n * (t -= 2.25 / d) * t + 0.9375;
+    return n * (t -= 2.625 / d) * t + 0.984375;
+};
+export const Ease = {
+    linear: (t) => t,
+    quadIn: (t) => t * t,
+    quadOut: (t) => 1 - (1 - t) * (1 - t),
+    quadInOut: (t) => (t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2),
+    cubicOut: (t) => 1 - Math.pow(1 - t, 3),
+    cubicInOut: (t) => (t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2),
+    sineInOut: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+    expoOut: (t) => (t >= 1 ? 1 : 1 - Math.pow(2, -10 * t)),
+    backOut: (t) => 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2),
+    elasticOut: (t) => t <= 0 ? 0 : t >= 1 ? 1 : Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * ((2 * Math.PI) / 3)) + 1,
+    bounceOut: bounce,
+};
+export class Tweens {
+    list = [];
+    nextId = 1;
+    /** Tween numeric properties of `target` to `props`. Returns a handle for `cancel`. */
+    to(target, props, opts) {
+        const keys = Object.keys(props);
+        const rec = target;
+        const to = keys.map((k) => Number(props[k]));
+        const ease = typeof opts.ease === "function" ? opts.ease : Ease[opts.ease ?? "cubicOut"];
+        const id = this.nextId++;
+        this.list.push({
+            id,
+            target: rec,
+            keys,
+            from: keys.map(() => 0),
+            to,
+            started: false,
+            delay: Math.max(0, opts.delay ?? 0),
+            elapsed: 0,
+            duration: Math.max(1e-4, opts.duration),
+            ease,
+            yoyo: opts.yoyo === true,
+            repeatsLeft: opts.repeat ?? 0,
+            forward: true,
+            onUpdate: opts.onUpdate,
+            onDone: opts.onDone,
+        });
+        return id;
+    }
+    /** Stop a tween by handle, or every tween on a target object. Values stay where they are. */
+    cancel(handleOrTarget) {
+        this.list = this.list.filter((r) => (typeof handleOrTarget === "number" ? r.id !== handleOrTarget : r.target !== handleOrTarget));
+    }
+    /** Tweens running or waiting. */
+    get active() {
+        return this.list.length;
+    }
+    tick(dt) {
+        if (dt <= 0 || this.list.length === 0)
+            return;
+        const done = [];
+        for (const r of this.list) {
+            let left = dt;
+            if (r.delay > 0) {
+                const d = Math.min(r.delay, left);
+                r.delay -= d;
+                left -= d;
+                if (r.delay > 0)
+                    continue;
+            }
+            if (!r.started) {
+                r.started = true;
+                r.from = r.keys.map((k) => Number(r.target[k] ?? 0));
+            }
+            r.elapsed += left;
+            while (r.elapsed >= r.duration) {
+                // A play finished: decide the next one.
+                if (r.repeatsLeft === 0 && (!r.yoyo || !r.forward))
+                    break;
+                if (r.yoyo && r.forward) {
+                    r.forward = false;
+                }
+                else {
+                    if (r.repeatsLeft > 0)
+                        r.repeatsLeft--;
+                    r.forward = true;
+                }
+                r.elapsed -= r.duration;
+            }
+            const finished = r.elapsed >= r.duration;
+            const p = Math.min(1, r.elapsed / r.duration);
+            const e = r.ease(r.forward ? p : 1 - p);
+            for (let i = 0; i < r.keys.length; i++) {
+                const a = r.from[i] ?? 0;
+                const b = r.to[i] ?? 0;
+                r.target[r.keys[i]] = finished ? (r.forward ? b : a) : a + (b - a) * e;
+            }
+            r.onUpdate?.();
+            if (finished)
+                done.push(r);
+        }
+        if (done.length > 0) {
+            this.list = this.list.filter((r) => !done.includes(r));
+            for (const r of done)
+                r.onDone?.();
+        }
+    }
+}
+/** The shared UI tween manager. It drives itself on requestAnimationFrame in a browser; call `uiTweens.tick(dt)` elsewhere. */
+export const uiTweens = new Tweens();
+let rafOn = false;
+let rafLast = 0;
+function ensureLoop() {
+    if (rafOn || typeof requestAnimationFrame === "undefined")
+        return;
+    rafOn = true;
+    rafLast = 0;
+    const loop = (t) => {
+        const dt = rafLast === 0 ? 1 / 60 : Math.min(0.1, (t - rafLast) / 1000);
+        rafLast = t;
+        uiTweens.tick(dt);
+        if (uiTweens.active > 0)
+            requestAnimationFrame(loop);
+        else
+            rafOn = false;
+    };
+    requestAnimationFrame(loop);
+}
+const states = new WeakMap();
+function stateOf(el) {
+    let st = states.get(el);
+    if (!st) {
+        st = { s: 1, dx: 0 };
+        states.set(el, st);
+    }
+    return st;
+}
+/** Punch an element's scale up to `scale` and spring it back (level-up, coin gain). */
+export function pop(el, scale = 1.25, ms = 260, tweens = uiTweens) {
+    const st = stateOf(el);
+    tweens.cancel(st);
+    st.s = scale;
+    el.style.scale = String(scale);
+    tweens.to(st, { s: 1 }, { duration: ms / 1000, ease: "backOut", onUpdate: () => (el.style.scale = st.s.toFixed(4)) });
+    if (tweens === uiTweens)
+        ensureLoop();
+}
+/** Shake an element sideways by up to `px`, decaying over `ms` (denied action, damage taken). */
+export function shakeEl(el, px = 6, ms = 280, tweens = uiTweens) {
+    const st = stateOf(el);
+    const prog = { t: 0 };
+    tweens.to(prog, { t: 1 }, {
+        duration: ms / 1000,
+        ease: "linear",
+        onUpdate: () => {
+            st.dx = Math.sin(prog.t * Math.PI * 9) * px * (1 - prog.t);
+            el.style.translate = `${st.dx.toFixed(2)}px 0`;
+        },
+        onDone: () => {
+            st.dx = 0;
+            el.style.translate = "";
+        },
+    });
+    if (tweens === uiTweens)
+        ensureLoop();
+}
+/** Count a number up in an element's text (scores, balances). */
+export function countUp(el, from, to, ms = 600, format = (n) => String(Math.round(n)), tweens = uiTweens) {
+    const v = { n: from };
+    el.textContent = format(from);
+    tweens.to(v, { n: to }, { duration: ms / 1000, ease: "expoOut", onUpdate: () => (el.textContent = format(v.n)) });
+    if (tweens === uiTweens)
+        ensureLoop();
+}

package/dist/runtime/feel/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared shapes of the game-feel kit. Kept free of
+ * three.js and the DOM so the kit imports anywhere, including node tests.
+ */
+/** Something that can play a pooled particle effect (the GPU particle system implements it). */
+export interface ParticleSink {
+    burst(preset: string, x: number, y: number, z: number, opts?: ParticleBurstOptions): void;
+}
+export interface ParticleBurstOptions {
+    /** Particle count override. */
+    readonly count?: number;
+    /** Tint as 0xRRGGBB. */
+    readonly color?: number;
+    /** Size multiplier. */
+    readonly scale?: number;
+    /** Bias direction in the ground plane (e.g. the hit direction). */
+    readonly dirX?: number;
+    readonly dirZ?: number;
+}
+/** World position to CSS pixels on the canvas. */
+export type Projector = (x: number, y: number, z: number) => {
+    x: number;
+    y: number;
+    onScreen: boolean;
+};
+/** Anything that takes trauma and an optional FOV punch: a CameraRig, or a bare Trauma. */
+export interface TraumaTarget {
+    addTrauma(amount: number): void;
+    punch?(fovKickDegrees: number): void;
+}

package/dist/runtime/feel/types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared shapes of the game-feel kit. Kept free of
+ * three.js and the DOM so the kit imports anywhere, including node tests.
+ */
+export {};

package/dist/runtime/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @netforge/engine/runtime: the client runtime. Used by templates and
+ * the Launcher shell, never imported by generated game code (which sees
+ * only the declarative API at the package root).
+ */
+export { createRenderer } from "./renderer.js";
+export type { Backend, RendererHandle, RendererOptions } from "./renderer.js";
+export { InstancedCrowd } from "./crowd.js";
+export { boundsShift, CameraRig, fieldBounds, groundFootprint } from "./camera.js";
+export type { CameraRigOptions, GroundBounds } from "./camera.js";
+export { InputController } from "./input.js";
+export type { InputOptions, LookTarget } from "./input.js";
+export { AssetLoader } from "./assets.js";
+export type { AssetLoaderOptions } from "./assets.js";
+export { FrameStats } from "./stats.js";
+export { lerp, lerpAngle, damp } from "./interpolate.js";
+export { ArenaClient } from "./arena.js";
+export type { ArenaOptions, ArenaStats } from "./arena.js";
+export { collectManifest, resetRegistry } from "../api/registry.js";
+export { SystemScheduler } from "../api/scheduler.js";
+export type { SystemHost } from "../api/scheduler.js";
+export * from "./feel/index.js";
+export * from "./render/index.js";
+export * from "./styles/index.js";
+export { createStyledView } from "./styles/view.js";
+export type { StyledView, StyledViewOptions } from "./styles/view.js";
+export { createPixelStyle, PIXEL_PALETTE, pixelBlock } from "./styles/pixel/index.js";
+export type { PixelStyleOptions } from "./styles/pixel/index.js";

package/dist/runtime/index.js

@@ -0,0 +1,26 @@
+/**
+ * @netforge/engine/runtime: the client runtime. Used by templates and
+ * the Launcher shell, never imported by generated game code (which sees
+ * only the declarative API at the package root).
+ */
+export { createRenderer } from "./renderer.js";
+export { InstancedCrowd } from "./crowd.js";
+export { boundsShift, CameraRig, fieldBounds, groundFootprint } from "./camera.js";
+export { InputController } from "./input.js";
+export { AssetLoader } from "./assets.js";
+export { FrameStats } from "./stats.js";
+export { lerp, lerpAngle, damp } from "./interpolate.js";
+export { ArenaClient } from "./arena.js";
+export { collectManifest, resetRegistry } from "../api/registry.js";
+export { SystemScheduler } from "../api/scheduler.js";
+// Game feel kit (§13): trauma shake, hit-stop clock, hit flash, knockback offsets,
+// damage numbers, tweens, audio hooks, rumble and the FeelKit facade.
+export * from "./feel/index.js";
+// Render pipeline (§5): lighting and shadows, post, atmosphere, quality tiers,
+// GPU particles, decals, animated characters and crowds, createRenderStack.
+export * from "./render/index.js";
+// Art styles (§10): each style's kit (look, world, crowds, particles), by style id.
+export * from "./styles/index.js";
+// A template that draws without the render stack applies a style with createStyledView.
+export { createStyledView } from "./styles/view.js";
+export { createPixelStyle, PIXEL_PALETTE, pixelBlock } from "./styles/pixel/index.js";

package/dist/runtime/input.d.ts

@@ -0,0 +1,38 @@
+import type { InputCommand } from "@netforge/engine-sim";
+export interface InputOptions {
+    /** Radians of yaw/pitch per pixel of mouse movement. */
+    readonly mouseSensitivity?: number;
+    /** Radians per pixel of touch-drag look. */
+    readonly touchSensitivity?: number;
+    /** Force the touch UI on (default: when the device reports coarse pointers / touch). */
+    readonly touch?: boolean;
+}
+export interface LookTarget {
+    look(dYaw: number, dPitch: number): void;
+    readonly yaw: number;
+}
+/**
+ * Keyboard + mouse (pointer lock) and touch (nipplejs virtual stick on the
+ * left half, drag-to-look and action buttons on the right). `sample()`
+ * produces one sequence-numbered InputCommand per fixed tick.
+ */
+export declare class InputController {
+    private readonly element;
+    private readonly look;
+    private readonly keys;
+    private mouseButtons;
+    private stickX;
+    private stickY;
+    private touchButtons;
+    private seq;
+    private readonly cleanup;
+    private readonly o;
+    readonly touch: boolean;
+    constructor(element: HTMLElement, look: LookTarget, opts?: InputOptions);
+    private on;
+    private bindDesktop;
+    private bindTouch;
+    /** One command for the next fixed tick. */
+    sample(tick: number): InputCommand;
+    dispose(): void;
+}

package/dist/runtime/input.js

@@ -0,0 +1,159 @@
+import { Button } from "@netforge/engine-sim";
+const KEY_BUTTONS = {
+    Space: Button.Jump,
+    ShiftLeft: Button.Sprint,
+    ShiftRight: Button.Sprint,
+    KeyE: Button.Use,
+    KeyF: Button.Fire,
+    KeyQ: Button.Alt,
+};
+/**
+ * Keyboard + mouse (pointer lock) and touch (nipplejs virtual stick on the
+ * left half, drag-to-look and action buttons on the right). `sample()`
+ * produces one sequence-numbered InputCommand per fixed tick.
+ */
+export class InputController {
+    element;
+    look;
+    keys = new Set();
+    mouseButtons = 0;
+    stickX = 0;
+    stickY = 0;
+    touchButtons = 0;
+    seq = 0;
+    cleanup = [];
+    o;
+    touch;
+    constructor(element, look, opts = {}) {
+        this.element = element;
+        this.look = look;
+        this.o = {
+            mouseSensitivity: 0.0025,
+            touchSensitivity: 0.006,
+            touch: opts.touch ?? (globalThis.matchMedia?.("(pointer: coarse)").matches || "ontouchstart" in globalThis),
+            ...opts,
+        };
+        this.touch = this.o.touch;
+        this.bindDesktop();
+        if (this.touch)
+            void this.bindTouch();
+    }
+    on(target, type, fn) {
+        target.addEventListener(type, fn, { passive: false });
+        this.cleanup.push(() => target.removeEventListener(type, fn));
+    }
+    bindDesktop() {
+        const el = this.element;
+        this.on(window, "keydown", (e) => {
+            if (e.code === "Space")
+                e.preventDefault();
+            this.keys.add(e.code);
+        });
+        this.on(window, "keyup", (e) => this.keys.delete(e.code));
+        this.on(window, "blur", () => {
+            this.keys.clear();
+            this.mouseButtons = 0;
+        });
+        this.on(el, "mousedown", (e) => {
+            if (this.touch)
+                return;
+            if (document.pointerLockElement !== el)
+                void el.requestPointerLock?.();
+            this.mouseButtons |= e.button === 0 ? Button.Fire : e.button === 2 ? Button.Alt : 0;
+        });
+        this.on(window, "mouseup", (e) => {
+            this.mouseButtons &= ~(e.button === 0 ? Button.Fire : e.button === 2 ? Button.Alt : 0);
+        });
+        this.on(el, "contextmenu", (e) => e.preventDefault());
+        this.on(window, "mousemove", (e) => {
+            if (document.pointerLockElement !== el)
+                return;
+            const s = this.o.mouseSensitivity;
+            this.look.look(-e.movementX * s, e.movementY * s);
+        });
+    }
+    async bindTouch() {
+        // nipplejs is only downloaded on touch devices.
+        const nipple = await import("nipplejs");
+        const left = document.createElement("div");
+        left.style.cssText = "position:absolute;left:0;top:0;bottom:0;width:50%;touch-action:none;z-index:2";
+        const right = document.createElement("div");
+        right.style.cssText = "position:absolute;right:0;top:0;bottom:0;width:50%;touch-action:none;z-index:2";
+        this.element.append(left, right);
+        this.cleanup.push(() => {
+            left.remove();
+            right.remove();
+        });
+        const sticks = nipple.create({ zone: left, mode: "dynamic", color: "white", size: 110 });
+        sticks.on("move", (evt) => {
+            this.stickX = evt.data.vector.x;
+            this.stickY = evt.data.vector.y;
+        });
+        sticks.on("end", () => {
+            this.stickX = 0;
+            this.stickY = 0;
+        });
+        this.cleanup.push(() => sticks.destroy());
+        // Right half: drag to look; two buttons for jump and fire.
+        let lastX = 0;
+        let lastY = 0;
+        let lookId = null;
+        this.on(right, "pointerdown", (e) => {
+            if (e.target !== right)
+                return;
+            lookId = e.pointerId;
+            lastX = e.clientX;
+            lastY = e.clientY;
+        });
+        this.on(right, "pointermove", (e) => {
+            if (e.pointerId !== lookId)
+                return;
+            const s = this.o.touchSensitivity;
+            this.look.look(-(e.clientX - lastX) * s, (e.clientY - lastY) * s);
+            lastX = e.clientX;
+            lastY = e.clientY;
+        });
+        const endLook = (e) => {
+            if (e.pointerId === lookId)
+                lookId = null;
+        };
+        this.on(right, "pointerup", endLook);
+        this.on(right, "pointercancel", endLook);
+        const mk = (label, bit, bottom, rightPx) => {
+            const b = document.createElement("button");
+            b.textContent = label;
+            b.style.cssText = `position:absolute;bottom:${bottom}px;right:${rightPx}px;width:76px;height:76px;border-radius:50%;border:2px solid rgba(255,255,255,.6);background:rgba(255,255,255,.12);color:#fff;font:600 13px system-ui;touch-action:none`;
+            b.addEventListener("pointerdown", (e) => {
+                e.preventDefault();
+                this.touchButtons |= bit;
+            });
+            const up = () => {
+                this.touchButtons &= ~bit;
+            };
+            b.addEventListener("pointerup", up);
+            b.addEventListener("pointercancel", up);
+            b.addEventListener("pointerleave", up);
+            right.append(b);
+        };
+        mk("JUMP", Button.Jump, 32, 120);
+        mk("PULSE", Button.Fire, 110, 32);
+    }
+    /** One command for the next fixed tick. */
+    sample(tick) {
+        const k = this.keys;
+        let mx = (k.has("KeyD") || k.has("ArrowRight") ? 1 : 0) - (k.has("KeyA") || k.has("ArrowLeft") ? 1 : 0);
+        let mz = (k.has("KeyW") || k.has("ArrowUp") ? 1 : 0) - (k.has("KeyS") || k.has("ArrowDown") ? 1 : 0);
+        if (this.stickX !== 0 || this.stickY !== 0) {
+            mx = this.stickX;
+            mz = this.stickY;
+        }
+        let buttons = this.mouseButtons | this.touchButtons;
+        for (const code of k)
+            buttons |= KEY_BUTTONS[code] ?? 0;
+        return { seq: ++this.seq, tick, moveX: mx, moveZ: mz, yaw: this.look.yaw, buttons };
+    }
+    dispose() {
+        for (const fn of this.cleanup.splice(0))
+            fn();
+    }
+}

package/dist/runtime/interpolate.d.ts

@@ -0,0 +1,6 @@
+/** Linear interpolation. */
+export declare const lerp: (a: number, b: number, t: number) => number;
+/** Interpolate angles along the shortest arc (radians). */
+export declare function lerpAngle(a: number, b: number, t: number): number;
+/** Frame-rate independent exponential smoothing factor for a rate in 1/s. */
+export declare const damp: (rate: number, dt: number) => number;