diff --git a/app/src/game/audio.js b/app/src/game/audio.js
index 13e95cc..d8229b6 100644
--- a/app/src/game/audio.js
+++ b/app/src/game/audio.js
@@ -21,7 +21,7 @@ import { signed } from "./signed.js";
// point early-returns, master gain pinned to 0, context never resumed).
// Node-returning helpers (busNode, createEmitter) keep building their
// graph either way so callers stay untouched.
-const SOUND_DISABLED = true;
+const SOUND_DISABLED = false;
// ── Context, master, buses ────────────────────────────────────────────
const MASTER_LEVEL = 0.9;
diff --git a/app/src/game/controls/gamepad.js b/app/src/game/controls/gamepad.js
index de54504..a4256b7 100644
--- a/app/src/game/controls/gamepad.js
+++ b/app/src/game/controls/gamepad.js
@@ -46,6 +46,15 @@ const BTN_R3 = 11, BTN_DPAD_UP = 12, BTN_DPAD_DOWN = 13;
const DPAD_UP_HOLD_MS = 1000; // hold-to-switch-loco duration
+// The one pad-picking rule, shared by poll() and the haptics engine
+// (haptics.js): prefer a standard-mapping pad - the button indices above
+// are only guaranteed by the "standard" layout - and fall back to
+// whatever is connected.
+export function pickPad() {
+ const pads = [...(navigator.getGamepads?.() ?? [])].filter((p) => p && p.connected);
+ return pads.find((p) => p.mapping === "standard") ?? pads[0];
+}
+
export class GamepadSource {
id = "gamepad";
connected = false;
@@ -82,12 +91,10 @@ export class GamepadSource {
poll() {
const prev = this.pressed;
- // Prefer a standard-mapping pad: the button indices above are only
- // guaranteed by the "standard" layout. A non-standard pad (mapping "")
- // is a last-resort fallback - its indices are firmware-defined and
- // some mirror one combined trigger channel onto both trigger slots.
- const pads = [...(navigator.getGamepads?.() ?? [])].filter((p) => p && p.connected);
- const gp = pads.find((p) => p.mapping === "standard") ?? pads[0];
+ // A non-standard pad (mapping "") is a last-resort fallback in
+ // pickPad - its indices are firmware-defined and some mirror one
+ // combined trigger channel onto both trigger slots.
+ const gp = pickPad();
this.connected = !!gp;
if (!gp) {
if (this.#active) {
diff --git a/app/src/game/game.js b/app/src/game/game.js
index 29acc8b..6df5744 100644
--- a/app/src/game/game.js
+++ b/app/src/game/game.js
@@ -45,6 +45,7 @@ import {
import { Controller } from "./controls/controller.js";
import { KeyboardSource } from "./controls/keyboard.js";
import { GamepadSource } from "./controls/gamepad.js";
+import { haptics } from "./haptics.js";
import { TouchSource } from "./controls/touch.js";
import * as fx from "./fx/fx-wireframe.js";
import { createCeremony, CAM_RESET_S } from "./ceremony.js";
@@ -769,12 +770,12 @@ async function boot({ scene, camera, renderer }) {
}
}
}
- // Roller rumble: gain and slight pitch follow ground speed.
+ // Roller rumble: gain and slight pitch follow ground speed - and the
+ // pad's haptic bed mirrors it (texture on the weak motor).
const speed = Math.hypot(data.qvel[0], data.qvel[1]);
- setRumble(
- loco === "rollers" && !inputLocked ? Math.min(1, speed / 0.5) : 0,
- duckEmitter,
- );
+ const rollLevel = loco === "rollers" && !inputLocked ? Math.min(1, speed / 0.5) : 0;
+ setRumble(rollLevel, duckEmitter);
+ haptics.setBed(rollLevel);
// Body bumps: trunk |dv| against a nearby wall/prop. The proximity
// gate keeps gait/kick jerks (which rival slow wall hits) silent.
if (!inputLocked) {
@@ -790,6 +791,7 @@ async function boot({ scene, camera, renderer }) {
rate: 0.55 + 0.15 * u + Math.random() * 0.06, // way below the ball's range
out: duckEmitter.node,
});
+ haptics.pulse("bump", 0.5 + 0.5 * u); // shove felt in the hands
}
}
bumpPrevV[0] = v[0]; bumpPrevV[1] = v[1]; bumpPrevV[2] = v[2];
@@ -813,6 +815,12 @@ async function boot({ scene, camera, renderer }) {
rate: 1.25 - 0.45 * u + Math.random() * 0.08,
out: ballEmitter.node,
});
+ // Haptics only when the duck plausibly caused/received the hit:
+ // a far bounce off a wall shouldn't shake the hands.
+ const bq = ballQposAdr;
+ const dBall = Math.hypot(
+ data.qpos[bq] - data.qpos[0], data.qpos[bq + 1] - data.qpos[1]);
+ if (dBall < 0.6) haptics.pulse("ballHit", 0.4 + 0.6 * u);
}
}
ballPrevV[0] = v[b]; ballPrevV[1] = v[b + 1]; ballPrevV[2] = v[b + 2];
@@ -820,6 +828,9 @@ async function boot({ scene, camera, renderer }) {
} else {
ballPrevValid = false;
}
+ // Haptic channel scheduler: keeps the roller bed alive between pulses
+ // and cuts the motors when it falls silent. 50 Hz, like everything here.
+ haptics.tick();
}
async function controlStep() {
@@ -842,6 +853,7 @@ async function boot({ scene, camera, renderer }) {
const death = poseIsDead();
if (death === "exploded") {
+ haptics.pulse("explode");
resetSim();
} else if (recovery) {
// Recovery state machine owns the duck: settle -> stand policy ->
@@ -859,6 +871,7 @@ async function boot({ scene, camera, renderer }) {
recovery = null;
mode = "walk";
lastAction.fill(0);
+ haptics.pulse("recover"); // back on its feet: light double tap
syncButtons();
} else if (recovery.steps >= RECOVER_GIVEUP_STEPS) {
resetSim();
@@ -873,12 +886,18 @@ async function boot({ scene, camera, renderer }) {
fallDebounce = 0;
exitHeadMode();
recovery = { state: "fallen", steps: 0 };
+ // Haptic thud on the confirmed fall (one-shot: this transition
+ // fires once per fall, the recovery machine owns the duck after).
+ haptics.pulse("fall");
syncButtons();
}
} else {
fallDebounce = 0;
const now = performance.now();
const graceMs = mode === "roll" ? 5000 : 1000;
+ // First frame of a non-recoverable fall (rollers, sit, one-shots):
+ // same haptic thud, once - fallenSince latches until reset/upright.
+ if (fallenSince == null) haptics.pulse("fall");
fallenSince ??= now;
if (now - fallenSince > graceMs) resetSim();
}
@@ -949,6 +968,7 @@ async function boot({ scene, camera, renderer }) {
// Timed out mid-roll: don't hand a tipped duck to the walking
// policy (it has no get-up skill).
if (!upright) resetSim();
+ else haptics.pulse("land"); // rolled through and stuck the landing
syncButtons();
}
}
@@ -1065,6 +1085,27 @@ async function boot({ scene, camera, renderer }) {
return rollersLoading;
}
+ // Ghost-only roller rig: kinematics + THREE meshes, no physics model and
+ // no ONNX sessions - just enough to render roller-mode PEERS correctly
+ // for a visitor who never leaves legs mode (ensureRollers' full stack
+ // stays lazy). Kept resident once built; if the player later switches
+ // for real, getRigFor prefers the live locos.rollers rig and this one
+ // quietly remains as a clone source.
+ let ghostRollerRig = null;
+ let ghostRollerRigLoading = null;
+ function ensureGhostRollerRig() {
+ if (locos.rollers || ghostRollerRig || rollersLoading) return;
+ ghostRollerRigLoading ??= (async () => {
+ const rk = await loadKinematics(`${MODEL_DIR}/kinematics_rollers.json`);
+ ghostRollerRig = await buildRig(rk, {
+ materialForMesh: materialHookFor(VARIANTS[currentVariant]),
+ });
+ })().catch((e) => {
+ ghostRollerRigLoading = null; // next roller peer retries the load
+ console.warn("[ghosts] roller ghost rig load failed", e);
+ });
+ }
+
function activateLoco(name) {
const L = locos[name];
loco = name;
@@ -1878,6 +1919,7 @@ async function boot({ scene, camera, renderer }) {
mode = foot === "left" ? "kickL" : "kickR";
sitFlag = 0;
kickRun = { steps: 0 };
+ haptics.pulse("kick"); // swing launch; ball contact adds ballHit
syncButtons();
stickers?.pop("kick");
return true;
@@ -1999,10 +2041,14 @@ async function boot({ scene, camera, renderer }) {
// default instead of letting applyVariant throw on a bad key.
variantNames: Object.keys(VARIANTS),
defaultVariant: DEFAULT_VARIANT,
- // Ghost rig per locomotion flag: peers in roller mode clone the
- // roller rig once this tab has built it, and fall back to the leg
- // rig until then. Known v1 limitation, documented in the README.
- getRigFor: (l) => (l && locos.rollers ? locos.rollers.rig : locos.legs.rig),
+ // Ghost rig per locomotion flag: roller peers clone the live roller
+ // rig when this tab has it, else the lightweight ghost-only roller
+ // rig. hasRigFor/prepareRigFor let ghosts.js render legs as a
+ // stopgap while lazily loading the real thing, then rebuild.
+ getRigFor: (l) =>
+ (l ? (locos.rollers?.rig ?? ghostRollerRig ?? locos.legs.rig) : locos.legs.rig),
+ hasRigFor: (l) => !l || !!(locos.rollers || ghostRollerRig),
+ prepareRigFor: (l) => { if (l) ensureGhostRollerRig(); },
getLocalState: () => {
const qpos = data.qpos;
const j = new Array(NUM_JOINTS);
diff --git a/app/src/game/ghosts.js b/app/src/game/ghosts.js
index c718a05..87201e7 100644
--- a/app/src/game/ghosts.js
+++ b/app/src/game/ghosts.js
@@ -103,9 +103,15 @@ export async function initGhosts(env) {
const knownVariants = env.variantNames ? new Set(env.variantNames) : null;
const defaultVariant = env.defaultVariant ?? env.variantNames?.[0];
// Locomotion-variant rig source: state.l 1 = rollers, 0/absent = legs
- // (old clients never send it). Falls back to the leg rig when the local
- // tab hasn't built the roller rig yet - known v1 limitation.
+ // (old clients never send it). The host may not have the wanted rig yet
+ // (the roller stack is lazy): servedLoco says which flavor a ghost
+ // actually gets right now, and prepareRigFor warms the missing one in
+ // the background so a later packet can rebuild onto the real thing.
const rigFor = (l) => (env.getRigFor ? env.getRigFor(l ?? 0) : env.rig);
+ const servedLoco = (l) => {
+ const want = l ?? 0;
+ return env.hasRigFor && !env.hasRigFor(want) ? 0 : want;
+ };
// trystero 0.25 (backed by @trystero-p2p): makeAction returns
// { send, onMessage, onReceiveProgress } where onMessage is a SETTER -
// the receive handler is registered by assignment, not by calling it.
@@ -189,7 +195,12 @@ export async function initGhosts(env) {
at: Math.max(performance.now(), prevAt + RESPACE_MIN_MS),
});
const makeGhost = (state) => {
- const rig = cloneRig(rigFor(state.l));
+ // g.loco records the rig the ghost actually GOT (the served flavor),
+ // not the peer's flag: while the roller rig is still loading the ghost
+ // walks on legs, and the mismatch on later packets drives the rebuild.
+ const served = servedLoco(state.l);
+ if (served !== (state.l ?? 0)) env.prepareRigFor?.(state.l);
+ const rig = cloneRig(rigFor(served));
applyVariant(rig, state.v);
ghostify(rig);
scene.add(rig.placer);
@@ -199,7 +210,7 @@ export async function initGhosts(env) {
trunk.quaternion.set(state.p[4], state.p[5], state.p[6], state.p[3]);
return {
rig, trunk, buf: [snapOf(state)],
- variant: state.v, loco: state.l ?? 0,
+ variant: state.v, loco: served,
gapAvg: 1000 / SEND_HZ, // measured arrival cadence, ms
delay: INTERP_DELAY_MS, // current playback delay, ms
};
@@ -278,17 +289,23 @@ export async function initGhosts(env) {
g.revealed = true; // latched for the rest of this peer session
g.rig.placer.visible = true;
}
- // Peer switched legs <-> rollers: rebuild its ghost on the other rig
- // (cheap - cloneRig shares geometry). The snapshot buffer carries over
- // so the interpolated motion stays continuous across the swap.
+ // Peer switched legs <-> rollers, or the rig its mode needs just
+ // finished lazy-loading: rebuild the ghost on the right rig (cheap -
+ // cloneRig shares geometry). The snapshot buffer carries over so the
+ // interpolated motion stays continuous across the swap. While the
+ // wanted rig is still loading, keep warming it and stay on legs.
if (state.l !== g.loco) {
- const { lastSeen, spawn, revealed, buf, gapAvg, delay } = g;
- removeGhost(peerId);
- g = makeGhost(state);
- Object.assign(g, { lastSeen, spawn, revealed, buf, gapAvg, delay });
- g.rig.placer.visible = revealed;
- ghosts.set(peerId, g);
- return;
+ if (servedLoco(state.l) !== state.l) {
+ env.prepareRigFor?.(state.l);
+ } else {
+ const { lastSeen, spawn, revealed, buf, gapAvg, delay } = g;
+ removeGhost(peerId);
+ g = makeGhost(state);
+ Object.assign(g, { lastSeen, spawn, revealed, buf, gapAvg, delay });
+ g.rig.placer.visible = revealed;
+ ghosts.set(peerId, g);
+ return;
+ }
}
if (state.v !== g.variant) {
g.variant = state.v;
@@ -392,7 +409,7 @@ export async function initGhosts(env) {
meshes++; if (o.visible) visible++; op ??= o.material.opacity;
});
const w = g.trunk.getWorldPosition(g.trunk.position.clone());
- return { p: g.trunk.position.toArray(), world: w.toArray(), inScene: !!g.rig.placer.parent, revealed: g.revealed, meshes, visible, twins, op, v: g.variant, gapAvg: g.gapAvg, delay: g.delay, bufLen: g.buf.length };
+ return { p: g.trunk.position.toArray(), world: w.toArray(), inScene: !!g.rig.placer.parent, revealed: g.revealed, meshes, visible, twins, op, v: g.variant, l: g.loco, gapAvg: g.gapAvg, delay: g.delay, bufLen: g.buf.length };
}),
update() {
const now = performance.now();
diff --git a/app/src/game/haptics.js b/app/src/game/haptics.js
new file mode 100644
index 0000000..5b9882e
--- /dev/null
+++ b/app/src/game/haptics.js
@@ -0,0 +1,139 @@
+// Gamepad haptics engine: named one-shot pulses plus a continuous rumble
+// bed, multiplexed onto the single dual-rumble channel the Gamepad API
+// exposes per pad (playEffect always REPLACES the running effect - there
+// is no hardware mixing, so the mixing policy lives here).
+//
+// Model (the usual game-feel split):
+// strongMagnitude = heavy low-frequency motor -> mass, impacts, thuds
+// weakMagnitude = light high-frequency motor -> texture, ticks
+//
+// Pulses are named presets with a priority: while one is playing, a
+// lower-priority pulse is dropped (a wall bump can never eat the fall
+// thud) and an equal/higher one takes the channel. `scale` multiplies
+// both magnitudes so impact-style cues can ride the physics (ball |dv|,
+// bump strength). Presets may be sequences (multi-tap patterns) - taps
+// are scheduled with timeouts and cancelled wholesale if another pulse
+// takes over mid-pattern.
+//
+// The bed is a 0..1 level written every control step (roller ground
+// speed); it keeps the motors alive between pulses by re-issuing a short
+// overlapping effect, yields the instant a pulse fires, and resumes when
+// the pulse expires. Everything is fire-and-forget and safe without a
+// pad or actuator (Safari, some Firefox/driver stacks): silent no-op.
+
+import { pickPad } from "./controls/gamepad.js";
+
+// Kill switch, mirroring SOUND_DISABLED in audio.js: flip to true and
+// every entry point below early-returns.
+const HAPTICS_DISABLED = false;
+
+// One-shot presets. d/gap in ms, s/w = strong/weak magnitudes (0..1
+// before scale), prio decides who wins the single channel.
+const EFFECTS = {
+ // Confirmed fall (recovery entry or non-recoverable tip-over).
+ fall: { prio: 3, seq: [{ d: 450, s: 1.0, w: 0.7 }] },
+ // Solver explosion -> instant reset: the hardest hit in the game.
+ explode: { prio: 4, seq: [{ d: 550, s: 1.0, w: 1.0 }] },
+ // Barrel roll finished upright: landing thump.
+ land: { prio: 2, seq: [{ d: 170, s: 0.7, w: 0.35 }] },
+ // Kick swing launch (the ball contact rides ballHit on top).
+ kick: { prio: 1, seq: [{ d: 90, s: 0.5, w: 0.2 }] },
+ // Ball impact felt through the body - scaled by the hit's |dv|.
+ ballHit: { prio: 2, seq: [{ d: 120, s: 0.85, w: 0.4 }] },
+ // Trunk bump against a wall or prop - scaled by |dv|.
+ bump: { prio: 1, seq: [{ d: 130, s: 0.55, w: 0.25 }] },
+ // Recovery success (the duck got back up): light double tap.
+ recover: { prio: 2, seq: [{ d: 70, s: 0.3, w: 0.45 }, { gap: 90 }, { d: 100, s: 0.5, w: 0.65 }] },
+};
+
+// Bed tuning: texture-forward (weak motor), a whisper of mass underneath.
+const BED_REFRESH_MS = 240; // re-issue cadence; duration overlaps 2x
+const BED_STRONG = 0.12;
+const BED_WEAK = 0.4;
+const BED_FLOOR = 0.03; // below this the bed is considered off
+
+let current = { until: 0, prio: 0 }; // the pulse owning the channel
+let seqGen = 0; // generation token: bumping it cancels pending seq taps
+let bedLevel = 0;
+let bedIssuedAt = 0;
+let bedActive = false;
+
+const actuator = () => pickPad()?.vibrationActuator ?? null;
+
+const play = (act, step, scale) => {
+ act
+ .playEffect("dual-rumble", {
+ duration: step.d,
+ strongMagnitude: Math.min(1, step.s * scale),
+ weakMagnitude: Math.min(1, step.w * scale),
+ })
+ .catch(() => {});
+};
+
+function pulse(name, scale = 1) {
+ if (HAPTICS_DISABLED) return;
+ const fx = EFFECTS[name];
+ if (!fx) return;
+ const act = actuator();
+ if (!act?.playEffect) return;
+ const now = performance.now();
+ if (now < current.until && fx.prio < current.prio) return;
+ seqGen++; // cancel any in-flight sequence from the previous pulse
+ const gen = seqGen;
+ let at = 0;
+ let total = 0;
+ for (const step of fx.seq) total += (step.gap ?? 0) + (step.d ?? 0);
+ current = { until: now + total, prio: fx.prio };
+ bedActive = false; // the pulse owns the channel; tick() resumes the bed
+ for (const step of fx.seq) {
+ at += step.gap ?? 0;
+ if (!step.d) continue;
+ if (at === 0) {
+ play(act, step, scale);
+ } else {
+ setTimeout(() => {
+ if (gen !== seqGen) return; // a newer pulse took the channel
+ const a = actuator(); // pad may have been yanked meanwhile
+ if (a?.playEffect) play(a, step, scale);
+ }, at);
+ }
+ at += step.d;
+ }
+}
+
+// Continuous rumble level (0..1), meant to be written every control step
+// (it only becomes motion through tick()).
+function setBed(level) {
+ bedLevel = HAPTICS_DISABLED ? 0 : Math.max(0, Math.min(1, level));
+}
+
+// Channel scheduler, called once per control step: re-issues the bed
+// while it's on and no pulse owns the channel, and cuts the motors when
+// the bed falls silent (playEffect would otherwise finish the last
+// overlap on its own, a ~0.5 s tail).
+function tick() {
+ if (HAPTICS_DISABLED) return;
+ const now = performance.now();
+ if (now < current.until) return;
+ const act = actuator();
+ if (!act) return;
+ if (bedLevel > BED_FLOOR) {
+ if (now - bedIssuedAt >= BED_REFRESH_MS) {
+ bedIssuedAt = now;
+ bedActive = true;
+ act
+ .playEffect?.("dual-rumble", {
+ duration: BED_REFRESH_MS * 2,
+ strongMagnitude: Math.min(1, BED_STRONG * bedLevel),
+ weakMagnitude: Math.min(1, BED_WEAK * bedLevel),
+ })
+ .catch(() => {});
+ }
+ } else if (bedActive) {
+ bedActive = false;
+ bedIssuedAt = 0;
+ try { act.reset?.()?.catch?.(() => {}); } catch { /* older impls throw sync */ }
+ }
+}
+
+export const haptics = { pulse, setBed, tick };
diff --git a/app/src/ui/Hud.jsx b/app/src/ui/Hud.jsx
index 41daf9e..e06cea1 100644
--- a/app/src/ui/Hud.jsx
+++ b/app/src/ui/Hud.jsx
@@ -403,9 +403,7 @@ function Quickbar() {
})}
- {/* Sound is fully disabled for now (SOUND_DISABLED in audio.js);
- re-enable this toggle together with that flag. */}
- {/* */}
+
);
}