971176fc4f
- welcome: one-page menu (vitrine brand lockup, landing-size h1, controls grid with pad variant), pre-boot spinner veil - in-game: live colour + legs/rollers quickbar bottom-left, back button, big mode readout top-right, telemetry stack bottom-right (peers, speed, odometer, fps, ctrl rate) - ghosts: snapshot interpolation at 15 Hz replaces the exponential chase (no more micro-stutter, background tabs degrade gracefully) - modules landed with this batch: ceremony (entrance/respawn), fx (wireframe/glitch), controls stack, ball actor, comic stickers Co-authored-by: Cursor <cursoragent@cursor.com>
189 lines
8.5 KiB
JavaScript
189 lines
8.5 KiB
JavaScript
// Controller: the video-game-style input core. Aggregates pluggable input
|
|
// SOURCES (keyboard, gamepad, later touch) into one game-facing surface:
|
|
//
|
|
// - a continuous COMMAND: the [vx, vy, wz] twist the policy tracks, plus
|
|
// auxiliary analog AXES (jaw 0..1, camera-orbit rates -1..1);
|
|
// - discrete ACTIONS: edge-triggered events (roll, kicks, ball spawn...)
|
|
// dispatched to subscribers the moment a source fires them;
|
|
// - HUD support: per-source pressed-state snapshots and activity info so
|
|
// the hint keycaps can light up per physical control and per device.
|
|
//
|
|
// The game code (rl.js) instantiates the sources, registers them here,
|
|
// calls update(dt) once per render frame, reads getCommand()/getAxes()
|
|
// where it builds the policy observation, and subscribes its trigger
|
|
// functions with on(action, cb).
|
|
//
|
|
// ── Source interface contract ────────────────────────────────────────────
|
|
// Every input source module (keyboard.js, gamepad.js, a future touch.js
|
|
// with a virtual joystick + buttons) implements:
|
|
//
|
|
// id Unique string ("keyboard", "gamepad", "touch"...). Action
|
|
// subscribers receive it as meta.source, so game code can
|
|
// attribute HUD flashes / keycap lighting to the right device.
|
|
// connected Boolean hardware presence. Keyboard: always true. Gamepad:
|
|
// a pad is currently reported by navigator.getGamepads().
|
|
// command Float32Array(3) [vx, vy, wz], ALREADY scaled to the game's
|
|
// velocity limits (sources take a getVelocityLimits() callback
|
|
// returning [fwd, back, ang], so limits can change at runtime,
|
|
// e.g. the legs <-> rollers switch). Must be a stable array
|
|
// reference updated in place: getCommand() hands it out
|
|
// without copying, and the control loop reads it between
|
|
// render frames.
|
|
// axes { jaw, orbitX, orbitY } - auxiliary continuous channels.
|
|
// jaw in [0, 1] (mouth opening), orbit axes in [-1, 1]
|
|
// (camera orbit rate; the inertia/smoothing lives downstream
|
|
// in the camera code, sources report raw deflection). Stable
|
|
// object reference, updated in place. Channels a source does
|
|
// not drive stay 0.
|
|
// pressed Plain object of booleans (stable reference) mirroring which
|
|
// physical controls are currently down. HUD highlighting
|
|
// only - never game logic.
|
|
// isActive() Whether the source currently claims authority over the
|
|
// continuous command. Keyboard: any move key held. Gamepad:
|
|
// stick deflected, and it keeps the claim until its smoothed
|
|
// command settles back to ~zero.
|
|
// init() Attach event listeners / hardware hooks. Called by
|
|
// Controller.init(), NOT at construction (rl.js constructs
|
|
// the sources early but arms the listeners at the same point
|
|
// in the boot where they historically went live).
|
|
// dispose() Detach everything init() attached.
|
|
// poll(dt) Per-frame tick (dt in seconds, clamped by the caller).
|
|
// Read the hardware, update command/axes/pressed in place,
|
|
// and fire edge-triggered actions via this.onAction(name).
|
|
// onAction (name, meta?) => void, assigned by the Controller at
|
|
// registration. Sources may call it from poll() (gamepad
|
|
// button edges) or straight from event handlers (keyboard:
|
|
// keeps the historical press-to-effect latency).
|
|
//
|
|
// ── Arbitration ──────────────────────────────────────────────────────────
|
|
// Continuous command: sources are registered in PRIORITY order (first =
|
|
// highest). Each frame the first source reporting isActive() owns the
|
|
// twist; when none is active the LAST registered source's command is used
|
|
// as the fallback (it reads zero when idle). With [gamepad, keyboard] this
|
|
// reproduces the historical `padActive ? padCmd : velCmd` exactly: live
|
|
// sticks win over held keys, and the keyboard takes back over once the
|
|
// pad's smoothed command has settled.
|
|
// Aux axes are merged across ALL sources regardless of who owns the twist
|
|
// (the pad triggers drive the jaw even while walking on the keyboard):
|
|
// jaw = max over sources, orbit = largest-magnitude value per axis.
|
|
//
|
|
// ── Actions ──────────────────────────────────────────────────────────────
|
|
// roll one-shot roll (crouch-glide in roller mode; game decides)
|
|
// kickL, kickR one-shot kicks, explicit foot
|
|
// alternateKick one-shot kick, feet alternated by the game
|
|
// spawnBall pop / respawn the kickable ball
|
|
// sitToggle sit <-> stand (game gates it to legs mode)
|
|
// locoToggle legs <-> rollers switch
|
|
// chaseToggle chase camera on/off
|
|
// reset full sim reset (Space)
|
|
// walk back to the walk/run mode (pad DpadUp short press)
|
|
// quack chirp + jaw flap (pad RT edge, Schmitt-triggered)
|
|
//
|
|
// ── Input lock ───────────────────────────────────────────────────────────
|
|
// setLocked(true) zeroes getCommand() - the twist gate used while the
|
|
// entrance/respawn ceremony plays. Discrete actions still dispatch: each
|
|
// game trigger applies its own lock policy (e.g. Space-reset and the
|
|
// chase-cam toggle historically work while locked, kicks don't).
|
|
|
|
const ZERO_CMD = new Float32Array(3);
|
|
|
|
export class Controller {
|
|
#sources = [];
|
|
#listeners = new Map(); // action -> Set(cb)
|
|
#locked = false;
|
|
#axes = { jaw: 0, orbitX: 0, orbitY: 0 };
|
|
|
|
constructor({ sources = [] } = {}) {
|
|
for (const s of sources) this.addSource(s);
|
|
}
|
|
|
|
// Register in priority order (first registered wins arbitration ties).
|
|
addSource(source) {
|
|
source.onAction = (action, meta) =>
|
|
this.#dispatch(action, { source: source.id, ...meta });
|
|
this.#sources.push(source);
|
|
}
|
|
|
|
// Read-only source list, for advanced per-source queries the merged view
|
|
// can't answer (e.g. "is ANY source commanding a turn right now?").
|
|
get sources() {
|
|
return this.#sources;
|
|
}
|
|
|
|
// Arm every source's listeners/hardware hooks.
|
|
init() {
|
|
for (const s of this.#sources) s.init?.();
|
|
}
|
|
|
|
dispose() {
|
|
for (const s of this.#sources) s.dispose?.();
|
|
}
|
|
|
|
// Per-frame tick: poll every source (they fire their edge actions from
|
|
// inside poll), then merge the aux axes.
|
|
update(dt) {
|
|
for (const s of this.#sources) s.poll?.(dt);
|
|
let jaw = 0, ox = 0, oy = 0;
|
|
for (const s of this.#sources) {
|
|
const a = s.axes;
|
|
if (!a) continue;
|
|
jaw = Math.max(jaw, a.jaw ?? 0);
|
|
if (Math.abs(a.orbitX ?? 0) > Math.abs(ox)) ox = a.orbitX;
|
|
if (Math.abs(a.orbitY ?? 0) > Math.abs(oy)) oy = a.orbitY;
|
|
}
|
|
this.#axes.jaw = jaw;
|
|
this.#axes.orbitX = ox;
|
|
this.#axes.orbitY = oy;
|
|
}
|
|
|
|
setLocked(v) {
|
|
this.#locked = !!v;
|
|
}
|
|
|
|
get locked() {
|
|
return this.#locked;
|
|
}
|
|
|
|
// Merged continuous twist [vx, vy, wz] (see the arbitration notes above).
|
|
// Returns live source arrays without copying - treat as read-only.
|
|
getCommand() {
|
|
if (this.#locked) return ZERO_CMD;
|
|
for (const s of this.#sources) if (s.isActive()) return s.command;
|
|
const fallback = this.#sources[this.#sources.length - 1];
|
|
return fallback ? fallback.command : ZERO_CMD;
|
|
}
|
|
|
|
// Merged aux axes { jaw, orbitX, orbitY }, refreshed by update().
|
|
getAxes() {
|
|
return this.#axes;
|
|
}
|
|
|
|
// Any source claiming twist authority (HUD "user is driving" signal).
|
|
anyActive() {
|
|
return this.#sources.some((s) => s.isActive());
|
|
}
|
|
|
|
// Per-source pressed snapshots for HUD keycap highlighting:
|
|
// { keyboard: {...}, gamepad: {...} }.
|
|
getPressed() {
|
|
const out = {};
|
|
for (const s of this.#sources) out[s.id] = s.pressed ?? {};
|
|
return out;
|
|
}
|
|
|
|
// Subscribe to a discrete action; cb(meta) with meta.source = source id.
|
|
// Returns an unsubscribe function.
|
|
on(action, cb) {
|
|
let set = this.#listeners.get(action);
|
|
if (!set) this.#listeners.set(action, (set = new Set()));
|
|
set.add(cb);
|
|
return () => set.delete(cb);
|
|
}
|
|
|
|
#dispatch(action, meta) {
|
|
const set = this.#listeners.get(action);
|
|
if (!set) return;
|
|
for (const cb of set) cb(meta);
|
|
}
|
|
}
|