@netforge/engine 0.0.0-stage → 0.2.0

package/dist/runtime/feel/numbers.js

@@ -0,0 +1,172 @@
+/**
+ * Floating damage numbers. `NumberStack` is the DOM-free core (slots,
+ * merging, motion); `DamageNumbers` draws it with a fixed pool of DOM nodes
+ * moved by transforms only (no layout per frame).
+ */
+const DRIFT = [-14, 9, -5, 13, -10, 4, 11, -7];
+export class NumberStack {
+    slots;
+    /** Numbers shown (merges do not count). */
+    shown = 0;
+    merged = 0;
+    o;
+    seq = 0;
+    constructor(capacity = 48, opts = {}) {
+        this.o = { mergeMs: 120, lifeSeconds: 0.75, rise: 34, ...opts };
+        this.slots = Array.from({ length: Math.max(1, capacity) }, () => ({
+            active: false, id: -1, amount: 0, t: 1, x: 0, y: 0, drift: 0, big: false, kind: "damage", at: 0, gen: 0,
+        }));
+    }
+    /** Add a number; returns its slot index and whether it merged into an existing one. */
+    add(nowMs, n) {
+        const id = n.id ?? -1;
+        if (id >= 0) {
+            for (let i = 0; i < this.slots.length; i++) {
+                const s = this.slots[i];
+                if (s.active && s.id === id && nowMs - s.at <= this.o.mergeMs && s.kind === (n.kind ?? "damage")) {
+                    s.amount += n.amount;
+                    s.at = nowMs;
+                    s.x = n.x;
+                    s.y = n.y;
+                    s.big = s.big || n.big === true;
+                    // Re-pop without restarting the fade completely.
+                    s.t = Math.min(s.t, 0.08);
+                    this.merged++;
+                    return { index: i, merged: true };
+                }
+            }
+        }
+        // A free slot, else recycle the oldest (cap on screen).
+        let index = -1;
+        let oldest = -1;
+        let oldestT = -1;
+        for (let i = 0; i < this.slots.length; i++) {
+            const s = this.slots[i];
+            if (!s.active) {
+                index = i;
+                break;
+            }
+            if (s.t > oldestT) {
+                oldestT = s.t;
+                oldest = i;
+            }
+        }
+        if (index < 0)
+            index = oldest;
+        const s = this.slots[index];
+        s.active = true;
+        s.id = id;
+        s.amount = n.amount;
+        s.t = 0;
+        s.x = n.x;
+        s.y = n.y;
+        s.drift = DRIFT[this.seq++ % DRIFT.length] ?? 0;
+        s.big = n.big === true;
+        s.kind = n.kind ?? "damage";
+        s.at = nowMs;
+        s.gen++;
+        this.shown++;
+        return { index, merged: false };
+    }
+    update(dt) {
+        if (dt <= 0)
+            return;
+        const k = dt / this.o.lifeSeconds;
+        for (const s of this.slots) {
+            if (!s.active)
+                continue;
+            s.t = Math.min(1, s.t + k);
+            if (s.t >= 1)
+                s.active = false;
+        }
+    }
+    /** Where and how to draw a slot: an arc (rise with ease-out, sideways drift), a pop, then a fade. */
+    draw(s) {
+        const t = s.t;
+        const rise = this.o.rise * (1 - (1 - t) * (1 - t)) * (s.big ? 1.3 : 1);
+        const pop = t < 0.12 ? 1 + (0.12 - t) * (s.big ? 7 : 4.5) : 1;
+        const base = s.big ? 1.35 : 1;
+        return {
+            x: s.x + s.drift * t,
+            y: s.y - rise,
+            scale: base * pop,
+            opacity: t < 0.6 ? 1 : 1 - (t - 0.6) / 0.4,
+        };
+    }
+    get active() {
+        let n = 0;
+        for (const s of this.slots)
+            if (s.active)
+                n++;
+        return n;
+    }
+}
+/** The DOM pool. Construct only in a browser (it creates nodes under `host`). */
+export class DamageNumbers {
+    stack;
+    els = [];
+    colors;
+    format;
+    cls;
+    constructor(host, opts = {}) {
+        const o = typeof opts === "number" ? { capacity: opts } : opts;
+        this.stack = new NumberStack(o.capacity ?? 48, o);
+        this.colors = o.colors ?? {};
+        this.format = o.format ?? ((a) => String(Math.round(a)));
+        this.cls = o.className ?? "dmg";
+        const doc = host.ownerDocument ?? (typeof document !== "undefined" ? document : null);
+        if (!doc)
+            return;
+        for (let i = 0; i < this.stack.slots.length; i++) {
+            const el = doc.createElement("div");
+            el.className = this.cls;
+            el.style.opacity = "0";
+            el.style.willChange = "transform, opacity";
+            host.append(el);
+            this.els.push({ el, gen: -1, amount: Number.NaN, shown: false });
+        }
+    }
+    /** Numbers shown so far (playtest counters). */
+    get shown() {
+        return this.stack.shown;
+    }
+    /** The classic call: show(x, y, amount, big). */
+    show(x, y, amount, big = false) {
+        this.add({ x, y, amount, big });
+    }
+    add(n, nowMs = typeof performance !== "undefined" ? performance.now() : Date.now()) {
+        this.stack.add(nowMs, n);
+    }
+    update(dt) {
+        this.stack.update(dt);
+        const slots = this.stack.slots;
+        for (let i = 0; i < this.els.length; i++) {
+            const r = this.els[i];
+            const s = slots[i];
+            if (!r || !s)
+                continue;
+            if (!s.active) {
+                if (r.shown) {
+                    r.el.style.opacity = "0";
+                    r.shown = false;
+                }
+                continue;
+            }
+            if (r.gen !== s.gen) {
+                r.gen = s.gen;
+                r.el.className = s.big ? `${this.cls} big` : this.cls;
+                if (s.kind !== "damage")
+                    r.el.classList.add(s.kind);
+                r.el.style.color = this.colors[s.kind] ?? "";
+            }
+            if (r.amount !== s.amount) {
+                r.amount = s.amount;
+                r.el.textContent = this.format(s.amount);
+            }
+            const d = this.stack.draw(s);
+            r.shown = true;
+            r.el.style.opacity = d.opacity.toFixed(3);
+            r.el.style.transform = `translate(${d.x.toFixed(1)}px, ${d.y.toFixed(1)}px) translate(-50%, -50%) scale(${d.scale.toFixed(3)})`;
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Controller rumble (Gamepad API dual-rumble) with a phone vibration
+ * fallback, rate-limited so a swarm of hits is one buzz, not fifty.
+ */
+export interface RumbleActuator {
+    playEffect?(type: string, params: {
+        duration: number;
+        strongMagnitude: number;
+        weakMagnitude: number;
+        startDelay?: number;
+    }): Promise<unknown>;
+}
+export interface GamepadLike {
+    readonly connected?: boolean;
+    readonly vibrationActuator?: RumbleActuator | null;
+}
+export interface NavigatorLike {
+    getGamepads?(): readonly (GamepadLike | null)[];
+    vibrate?(pattern: number | number[]): boolean;
+}
+export interface RumbleOptions {
+    /** Least ms between pulses (a stronger pulse may still cut in). Default 70. */
+    readonly minGapMs?: number;
+    /** Use navigator.vibrate when no pad rumbles (phones). Default true. */
+    readonly vibrateFallback?: boolean;
+    readonly navigator?: NavigatorLike;
+    readonly now?: () => number;
+}
+export declare class Rumble {
+    enabled: boolean;
+    /** Pulses sent (playtest counters). */
+    pulses: number;
+    private last;
+    private lastStrength;
+    private lastUntil;
+    private readonly o;
+    constructor(opts?: RumbleOptions);
+    /** Rumble connected pads: `strong` and `weak` motors 0..1 for `ms`. Returns whether anything was sent. */
+    pulse(strong: number, weak?: number, ms?: number): boolean;
+}

package/dist/runtime/feel/rumble.js

@@ -0,0 +1,58 @@
+export class Rumble {
+    enabled = true;
+    /** Pulses sent (playtest counters). */
+    pulses = 0;
+    last = -Infinity;
+    lastStrength = 0;
+    lastUntil = 0;
+    o;
+    constructor(opts = {}) {
+        this.o = {
+            minGapMs: opts.minGapMs ?? 70,
+            vibrateFallback: opts.vibrateFallback ?? true,
+            nav: () => opts.navigator ?? (typeof navigator !== "undefined" ? navigator : undefined),
+            now: opts.now ?? (() => (typeof performance !== "undefined" ? performance.now() : Date.now())),
+        };
+    }
+    /** Rumble connected pads: `strong` and `weak` motors 0..1 for `ms`. Returns whether anything was sent. */
+    pulse(strong, weak = strong * 0.6, ms = 120) {
+        if (!this.enabled)
+            return false;
+        const s = Math.max(0, Math.min(1, strong));
+        const w = Math.max(0, Math.min(1, weak));
+        if (s === 0 && w === 0)
+            return false;
+        const now = this.o.now();
+        const busy = now < this.lastUntil;
+        const strength = Math.max(s, w);
+        // Rate limit, unless this one is clearly stronger than the one playing.
+        if (now - this.last < this.o.minGapMs && !(busy && strength > this.lastStrength * 1.5))
+            return false;
+        const nav = this.o.nav();
+        if (!nav)
+            return false;
+        let sent = false;
+        try {
+            for (const pad of nav.getGamepads?.() ?? []) {
+                const act = pad?.vibrationActuator;
+                if (!pad || pad.connected === false || !act?.playEffect)
+                    continue;
+                void act.playEffect("dual-rumble", { duration: ms, strongMagnitude: s, weakMagnitude: w, startDelay: 0 }).catch(() => undefined);
+                sent = true;
+            }
+            if (!sent && this.o.vibrateFallback && typeof nav.vibrate === "function" && strength >= 0.25) {
+                sent = nav.vibrate(Math.round(ms * Math.min(1, strength + 0.2))) !== false;
+            }
+        }
+        catch {
+            return false;
+        }
+        if (sent) {
+            this.pulses++;
+            this.last = now;
+            this.lastStrength = strength;
+            this.lastUntil = now + ms;
+        }
+        return sent;
+    }
+}

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

@@ -0,0 +1,96 @@
+/**
+ * The sound player: real CC0 samples for FeelKit's named cues and one
+ * music loop, with a mute that sticks.
+ *
+ *   const sound = new SoundPlayer(feel.audio, { key: "emberwatch" });
+ *   sound.load(soundBank(libraryBase));   // @netforge/asset-library: cue -> { url, gain }, music
+ *   sound.unlockOnGesture();              // browsers start audio on the first press
+ *   hudButton.onclick = () => label(sound.toggle());
+ *
+ * Effects decode into FeelAudio buffers under the same cue names, so every
+ * `feel.hit()`, `feel.kill()` and `audio.play("levelUp")` plays the sample
+ * and falls back to its synth recipe until it loads (or if it fails to
+ * decode). Music streams through an <audio> element (no decode of the whole
+ * track, no CORS needed for a CDN library), loops, fades in, pauses while
+ * the tab is hidden, and follows the mute. Nothing here runs without a
+ * browser: tests inject the element and the fetch.
+ */
+import type { FeelAudio } from "./audio.js";
+export interface SoundBankEntry {
+    readonly url: string;
+    /** The sample's mix level (1 = as recorded). */
+    readonly gain?: number;
+}
+/** Cue name -> sample, and an optional music loop (the asset library's `soundBank()` builds one). */
+export interface SoundBank {
+    readonly cues: Readonly<Record<string, SoundBankEntry>>;
+    readonly music?: SoundBankEntry | null;
+}
+/** The slice of HTMLAudioElement the music uses. */
+export interface MusicElement {
+    src: string;
+    loop: boolean;
+    volume: number;
+    muted: boolean;
+    preload: string;
+    readonly paused: boolean;
+    play(): Promise<void> | void;
+    pause(): void;
+}
+export interface SoundPlayerOptions {
+    /** Music volume 0..1 before the track's own gain. Default 0.4. */
+    readonly musicVolume?: number;
+    /** Effects volume multiplier on every sample's gain. Default 1. */
+    readonly sfxVolume?: number;
+    /** Start with music on (the mute still wins). Default true. */
+    readonly music?: boolean;
+    /** Storage key prefix for the remembered mute ("<key>:muted"). Default "netnet:sound". Null keeps nothing. */
+    readonly key?: string | null;
+    /** Seconds the music fades in over. Default 2. */
+    readonly fadeIn?: number;
+    /** Build the music element (tests). Default `new Audio()`. */
+    readonly createMusic?: () => MusicElement | null;
+    /** Fetch a sample's bytes (tests). Default `fetch`. */
+    readonly fetchBytes?: (url: string) => Promise<ArrayBuffer>;
+    /** Pause the music while the tab is hidden. Default true. */
+    readonly pauseWhenHidden?: boolean;
+}
+export declare class SoundPlayer {
+    readonly audio: FeelAudio;
+    /** Samples decoded so far, and ones that failed (they keep their synth recipe). */
+    readonly loaded: {
+        cues: number;
+        failed: number;
+        music: boolean;
+    };
+    private bank;
+    private music;
+    private musicGain;
+    private musicOn;
+    private mutedNow;
+    private fade;
+    private fadeTimer;
+    private readonly o;
+    constructor(audio: FeelAudio, opts?: SoundPlayerOptions);
+    /** Load a bank: samples decode once audio is unlocked; the music starts then too. */
+    load(bank: SoundBank): void;
+    private loadCue;
+    private startMusic;
+    private resumeMusic;
+    private applyMusic;
+    /** Start audio on the first pointer or key press (and music with it). */
+    unlockOnGesture(target?: EventTarget): void;
+    /** Muted: no effects, no music. Remembered in this browser. */
+    get muted(): boolean;
+    set muted(v: boolean);
+    /** Flip the mute; returns the new state (true = muted). */
+    toggle(): boolean;
+    /** Music on or off on its own (effects keep playing). */
+    get musicEnabled(): boolean;
+    set musicEnabled(v: boolean);
+    /** Whether the music element is playing right now. */
+    get musicPlaying(): boolean;
+    /** The bank in use (null before load). */
+    get current(): SoundBank | null;
+    dispose(): void;
+}

package/dist/runtime/feel/sound.js

@@ -0,0 +1,176 @@
+function readStore(key) {
+    try {
+        return typeof localStorage !== "undefined" ? localStorage.getItem(key) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeStore(key, value) {
+    try {
+        if (typeof localStorage !== "undefined")
+            localStorage.setItem(key, value);
+    }
+    catch {
+        // Private window or blocked storage: the choice lasts this page.
+    }
+}
+export class SoundPlayer {
+    audio;
+    /** Samples decoded so far, and ones that failed (they keep their synth recipe). */
+    loaded = { cues: 0, failed: 0, music: false };
+    bank = null;
+    music = null;
+    musicGain = 1;
+    musicOn;
+    mutedNow;
+    fade = 1;
+    fadeTimer = null;
+    o;
+    constructor(audio, opts = {}) {
+        this.audio = audio;
+        this.o = {
+            musicVolume: opts.musicVolume ?? 0.4,
+            sfxVolume: opts.sfxVolume ?? 1,
+            key: opts.key === undefined ? "netnet:sound" : opts.key,
+            fadeIn: opts.fadeIn ?? 2,
+            createMusic: opts.createMusic ?? (() => (typeof Audio !== "undefined" ? new Audio() : null)),
+            fetchBytes: opts.fetchBytes ?? (async (url) => (await fetch(url)).arrayBuffer()),
+            pauseWhenHidden: opts.pauseWhenHidden ?? true,
+        };
+        this.musicOn = opts.music ?? true;
+        this.mutedNow = this.o.key ? readStore(`${this.o.key}:muted`) === "1" : false;
+        audio.muted = this.mutedNow;
+        if (this.o.pauseWhenHidden && typeof document !== "undefined") {
+            document.addEventListener("visibilitychange", () => {
+                if (!this.music)
+                    return;
+                if (document.hidden)
+                    this.music.pause();
+                else
+                    this.resumeMusic();
+            });
+        }
+    }
+    /** Load a bank: samples decode once audio is unlocked; the music starts then too. */
+    load(bank) {
+        this.bank = bank;
+        this.audio.whenUnlocked((ctx) => {
+            for (const [cue, e] of Object.entries(bank.cues))
+                void this.loadCue(ctx, cue, e);
+            if (bank.music)
+                this.startMusic(bank.music);
+        });
+    }
+    async loadCue(ctx, cue, e) {
+        try {
+            const buffer = await ctx.decodeAudioData(await this.o.fetchBytes(e.url));
+            // Levels are absolute: undo the synth master so a sample's gain means the same in every game.
+            const master = Math.max(0.01, this.audio.master);
+            await this.audio.addBuffer(cue, buffer, { gain: ((e.gain ?? 1) * this.o.sfxVolume) / master });
+            this.loaded.cues++;
+        }
+        catch {
+            // Unsupported format or a missing file: the synth recipe keeps playing.
+            this.loaded.failed++;
+        }
+    }
+    startMusic(e) {
+        const el = this.music ?? this.o.createMusic();
+        if (!el)
+            return;
+        this.music = el;
+        this.musicGain = e.gain ?? 1;
+        el.loop = true;
+        el.preload = "auto";
+        if (el.src !== e.url)
+            el.src = e.url;
+        this.fade = this.o.fadeIn > 0 ? 0 : 1;
+        this.applyMusic();
+        this.resumeMusic();
+        this.loaded.music = true;
+        if (this.fade < 1) {
+            const step = 0.1 / this.o.fadeIn;
+            this.fadeTimer = setInterval(() => {
+                this.fade = Math.min(1, this.fade + step);
+                this.applyMusic();
+                if (this.fade >= 1 && this.fadeTimer) {
+                    clearInterval(this.fadeTimer);
+                    this.fadeTimer = null;
+                }
+            }, 100);
+        }
+    }
+    resumeMusic() {
+        const el = this.music;
+        if (!el || this.mutedNow || !this.musicOn)
+            return;
+        if (typeof document !== "undefined" && document.hidden)
+            return;
+        try {
+            const p = el.play();
+            if (p && typeof p.catch === "function")
+                p.catch(() => undefined);
+        }
+        catch {
+            // Autoplay refused: the next gesture's unlock tries again.
+        }
+    }
+    applyMusic() {
+        const el = this.music;
+        if (!el)
+            return;
+        el.volume = Math.max(0, Math.min(1, this.o.musicVolume * this.musicGain * this.fade));
+        el.muted = this.mutedNow || !this.musicOn;
+        if (el.muted)
+            el.pause();
+    }
+    /** Start audio on the first pointer or key press (and music with it). */
+    unlockOnGesture(target) {
+        this.audio.unlockOnGesture(target);
+    }
+    /** Muted: no effects, no music. Remembered in this browser. */
+    get muted() {
+        return this.mutedNow;
+    }
+    set muted(v) {
+        this.mutedNow = v;
+        this.audio.muted = v;
+        if (this.o.key)
+            writeStore(`${this.o.key}:muted`, v ? "1" : "0");
+        this.applyMusic();
+        if (!v) {
+            this.audio.unlock();
+            this.resumeMusic();
+        }
+    }
+    /** Flip the mute; returns the new state (true = muted). */
+    toggle() {
+        this.muted = !this.mutedNow;
+        return this.mutedNow;
+    }
+    /** Music on or off on its own (effects keep playing). */
+    get musicEnabled() {
+        return this.musicOn;
+    }
+    set musicEnabled(v) {
+        this.musicOn = v;
+        this.applyMusic();
+        if (v)
+            this.resumeMusic();
+    }
+    /** Whether the music element is playing right now. */
+    get musicPlaying() {
+        return !!this.music && !this.music.paused && !this.music.muted;
+    }
+    /** The bank in use (null before load). */
+    get current() {
+        return this.bank;
+    }
+    dispose() {
+        if (this.fadeTimer)
+            clearInterval(this.fadeTimer);
+        this.music?.pause();
+        this.music = null;
+    }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Damped springs for game feel: camera follow, FOV punch, knockback
+ * offsets, UI pops. `frequency` is the natural frequency in Hz and
+ * `damping` the damping ratio (1 = critically damped, no overshoot; below 1
+ * it wobbles). Integrated with fixed sub-steps, so any frame rate is stable.
+ */
+export interface SpringOptions {
+    readonly frequency?: number;
+    readonly damping?: number;
+}
+/**
+ * Advance one spring axis toward `target` by `dt` seconds with the exact
+ * solution of the damped oscillator, so it is stable at any stiffness and
+ * frame rate. `omega` is the natural frequency in rad/s, `zeta` the damping
+ * ratio. Returns [value, velocity].
+ */
+export declare function stepSpring(value: number, velocity: number, target: number, omega: number, zeta: number, dt: number): [number, number];
+export declare class Spring {
+    value: number;
+    velocity: number;
+    target: number;
+    frequency: number;
+    damping: number;
+    constructor(value?: number, opts?: SpringOptions);
+    /** Add velocity (an impulse). */
+    kick(velocity: number): void;
+    /** Jump to a value with no motion. */
+    snap(value: number): void;
+    step(dt: number): number;
+    /** At rest within `eps` of the target. */
+    settled(eps?: number): boolean;
+}
+/** Three springs sharing settings (a position or offset). */
+export declare class Spring3 {
+    readonly x: Spring;
+    readonly y: Spring;
+    readonly z: Spring;
+    constructor(x?: number, y?: number, z?: number, opts?: SpringOptions);
+    setTarget(x: number, y: number, z: number): void;
+    snap(x: number, y: number, z: number): void;
+    step(dt: number): void;
+}

package/dist/runtime/feel/spring.js

@@ -0,0 +1,95 @@
+/**
+ * Advance one spring axis toward `target` by `dt` seconds with the exact
+ * solution of the damped oscillator, so it is stable at any stiffness and
+ * frame rate. `omega` is the natural frequency in rad/s, `zeta` the damping
+ * ratio. Returns [value, velocity].
+ */
+export function stepSpring(value, velocity, target, omega, zeta, dt) {
+    if (dt <= 0 || omega <= 0)
+        return [value, velocity];
+    const y0 = value - target;
+    const v0 = velocity;
+    const t = dt;
+    if (Math.abs(zeta - 1) < 1e-4) {
+        const e = Math.exp(-omega * t);
+        const c = v0 + omega * y0;
+        return [target + (y0 + c * t) * e, (v0 - omega * t * c) * e];
+    }
+    if (zeta < 1) {
+        const wd = omega * Math.sqrt(1 - zeta * zeta);
+        const e = Math.exp(-zeta * omega * t);
+        const co = Math.cos(wd * t);
+        const si = Math.sin(wd * t);
+        const y = e * (y0 * co + ((v0 + zeta * omega * y0) / wd) * si);
+        const v = e * (v0 * co - ((zeta * omega * v0 + omega * omega * y0) / wd) * si);
+        return [target + y, v];
+    }
+    const s = Math.sqrt(zeta * zeta - 1);
+    const r1 = -omega * (zeta - s);
+    const r2 = -omega * (zeta + s);
+    const c1 = (v0 - r2 * y0) / (r1 - r2);
+    const c2 = y0 - c1;
+    const e1 = Math.exp(r1 * t);
+    const e2 = Math.exp(r2 * t);
+    return [target + c1 * e1 + c2 * e2, c1 * r1 * e1 + c2 * r2 * e2];
+}
+export class Spring {
+    value;
+    velocity = 0;
+    target;
+    frequency;
+    damping;
+    constructor(value = 0, opts = {}) {
+        this.value = value;
+        this.target = value;
+        this.frequency = opts.frequency ?? 4;
+        this.damping = opts.damping ?? 1;
+    }
+    /** Add velocity (an impulse). */
+    kick(velocity) {
+        this.velocity += velocity;
+    }
+    /** Jump to a value with no motion. */
+    snap(value) {
+        this.value = this.target = value;
+        this.velocity = 0;
+    }
+    step(dt) {
+        if (dt <= 0)
+            return this.value;
+        const [x, v] = stepSpring(this.value, this.velocity, this.target, this.frequency * Math.PI * 2, this.damping, dt);
+        this.value = x;
+        this.velocity = v;
+        return x;
+    }
+    /** At rest within `eps` of the target. */
+    settled(eps = 1e-3) {
+        return Math.abs(this.value - this.target) < eps && Math.abs(this.velocity) < eps;
+    }
+}
+/** Three springs sharing settings (a position or offset). */
+export class Spring3 {
+    x;
+    y;
+    z;
+    constructor(x = 0, y = 0, z = 0, opts = {}) {
+        this.x = new Spring(x, opts);
+        this.y = new Spring(y, opts);
+        this.z = new Spring(z, opts);
+    }
+    setTarget(x, y, z) {
+        this.x.target = x;
+        this.y.target = y;
+        this.z.target = z;
+    }
+    snap(x, y, z) {
+        this.x.snap(x);
+        this.y.snap(y);
+        this.z.snap(z);
+    }
+    step(dt) {
+        this.x.step(dt);
+        this.y.step(dt);
+        this.z.step(dt);
+    }
+}