Use consistent childlike Reachy voice and wobbler

app/src/game/emotions/emotionController.js

@@ -6,23 +6,23 @@ import { signed } from "../signed.js";
 export function reachySay(text, reachy = null) {
   try { globalThis.dispatchEvent?.(new CustomEvent("reachy-speech-start", { detail: { text: String(text) } })); } catch { /* recording hook is optional */ }
   if (!globalThis.speechSynthesis || !globalThis.SpeechSynthesisUtterance) return Promise.resolve();
-  reachy?.setWobbler?.(true);
+  reachy?.setWobbler?.(true, "speech");
   return new Promise((resolve) => {
     const utterance = new SpeechSynthesisUtterance(text);
     utterance.lang = "en-US";
     const voices = speechSynthesis.getVoices?.() ?? [];
-    // Prefer a lower, traditionally masculine English system voice. Voice
+    // Prefer a stable, traditionally masculine English system voice. Voice
     // names vary by browser/OS, so keep a small ordered set of known names
     // and fall back to any English voice when none is installed.
-    const maleHints = /daniel|alex|david|mark|arthur|thomas|george|google uk english male|microsoft (david|mark|ryan)/i;
+    const maleHints = /david|mark|guy|daniel|alex|arthur|thomas|george|ryan|google uk english male|microsoft (david|mark|ryan)/i;
     const voice = voices.find((candidate) => maleHints.test(candidate.name) && /^en[-_]gb/i.test(candidate.lang))
       ?? voices.find((candidate) => maleHints.test(candidate.name) && /^en[-_]/i.test(candidate.lang))
       ?? voices.find((candidate) => /^en[-_]gb/i.test(candidate.lang))
       ?? voices.find((candidate) => /^en[-_]/i.test(candidate.lang));
     if (voice) utterance.voice = voice;
-    utterance.pitch = 0.58;
-    utterance.rate = 0.82;
-    const done = () => { reachy?.setWobbler?.(false); resolve(); };
+    utterance.pitch = 1.12;
+    utterance.rate = 0.92;
+    const done = () => { reachy?.setWobbler?.(false, "speech"); resolve(); };
     utterance.onend = done;
     utterance.onerror = done;
     speechSynthesis.cancel();
@@ -75,6 +75,8 @@ export function createEmotionController({ runtime, reachy, setState }) {
   async function playReachy(emotion, definition) {
     const motion = await loadReachyEmotion(definition.motion);
     playUrl(signed(`./robot/reachy/emotions/${definition.motion}.ogg`), { gain: 0.9 });
-    await reachy.playMotion(motion);
+    reachy.setWobbler(true, "emotion");
+    try { await reachy.playMotion(motion); }
+    finally { reachy.setWobbler(false, "emotion"); }
   }
 }

app/src/game/reachy/reachyController.js

@@ -0,0 +1,106 @@
+import { MOTOR_NAMES, HOME, INITIAL_MOTOR_POSITIONS, poseToTarget, interpolateTarget, createReachyKinematics } from "./reachyKinematics.js";
+import { REACHY_PREFIX } from "./reachyWorld.js";
+import { abortError } from "../simulationTimeline.js";
+import { Matrix4 } from "three";
+
+export function createReachyController({ mujoco, getWorld, calibration, timeline, onState = () => {}, isLocked = () => false }) {
+  const ik = createReachyKinematics(calibration);
+  let target = poseToTarget(HOME), motorTargets = [...INITIAL_MOTOR_POSITIONS];
+  let boundModel, addresses = [];
+  let active = null, queue = [], speed = 1;
+  const wobblerSources = new Set();
+  const publish = (extra = {}) => onState({ playing: !!active, queue: queue.map((q) => q.label), speed, ...extra });
+  function apply(next) {
+    const motors = ik(next); // validate the complete target before changing any motor
+    target = next;
+    motorTargets = motors;
+  }
+  function write() {
+    const { model, data } = getWorld();
+    if (boundModel !== model) {
+      addresses = MOTOR_NAMES.map((name) => {
+        const id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_ACTUATOR.value, REACHY_PREFIX + name);
+        if (id < 0) throw new Error(`Missing Reachy actuator ${name}`);
+        return id;
+      });
+      boundModel = model;
+    }
+    let output = motorTargets;
+    if (wobblerSources.size) {
+      const wobbleTarget = { ...target, head: target.head.clone().multiply(new Matrix4().makeRotationZ(Math.sin(performance.now() * 0.012) * 0.055)) };
+      output = ik(wobbleTarget);
+    }
+    addresses.forEach((id, i) => { data.ctrl[id] = output[i]; });
+  }
+  async function goto(next, duration, signal, playbackSpeed = speed) {
+    if (!Number.isFinite(duration) || duration <= 0) throw new Error("Duration must be positive");
+    ik(next);
+    const from = target;
+    const seconds = duration / playbackSpeed;
+    await timeline.run({ duration: seconds, signal, update(t) {
+      const u = Math.min(1, t / seconds);
+      const blend = 10 * u ** 3 - 15 * u ** 4 + 6 * u ** 5;
+      apply(interpolateTarget(from, next, blend));
+    } });
+  }
+  async function ownPlayback(task, externalSignal) {
+    if (active) throw new Error("Reachy is already playing");
+    if (externalSignal?.aborted) throw abortError();
+    const playback = new AbortController();
+    active = playback;
+    const abort = () => playback.abort();
+    externalSignal?.addEventListener("abort", abort, { once: true });
+    publish({ error: null });
+    try { await task(playback.signal); }
+    catch (error) { if (error.name !== "AbortError") publish({ error: error.message }); throw error; }
+    finally { externalSignal?.removeEventListener("abort", abort); active = null; publish(); }
+  }
+  const api = {
+    write,
+    get busy() { return !!active; },
+    setWobbler(value, source = "default") {
+      if (value) wobblerSources.add(source);
+      else wobblerSources.delete(source);
+    },
+    get target() { return target; },
+    get motorTargets() { return [...motorTargets]; },
+    stop() { active?.abort(); },
+    clear() { active?.abort(); queue = []; publish(); },
+    setSpeed(value) {
+      if (isLocked()) return;
+      if (!Number.isFinite(value) || value < 0.25 || value > 2) throw new Error("Playback speed must be 0.25–2");
+      speed = value; publish();
+    },
+    enqueue(pose, duration, label = "Custom pose") {
+      if (isLocked()) return;
+      ik(poseToTarget(pose));
+      if (!Number.isFinite(duration) || duration <= 0) throw new Error("Duration must be positive");
+      queue.push({ pose: { ...pose }, duration, label }); publish();
+    },
+    playQueue() {
+      if (isLocked()) return Promise.reject(new Error("Emotion playback owns the controls"));
+      return ownPlayback(async (signal) => {
+        while (queue.length) {
+          const entry = queue.shift(); publish();
+          await goto(poseToTarget(entry.pose), entry.duration, signal);
+        }
+      });
+    },
+    playSequence(sequence) {
+      if (isLocked()) return Promise.reject(new Error("Emotion playback owns the controls"));
+      return ownPlayback(async (signal) => {
+        for (const entry of sequence) await goto(poseToTarget(entry.pose), entry.duration, signal);
+      });
+    },
+    // Recorded motion uses original timestamps and quaternion interpolation.
+    // Installed by the recorded-move adapter in the emotion phase.
+    playMotion(motion, signal) {
+      return ownPlayback(async (ownedSignal) => {
+        await goto(motion.sample(0), 0.7, ownedSignal, 1);
+        await timeline.run({ duration: motion.duration, signal: ownedSignal, update: (t) => apply(motion.sample(t)) });
+      }, signal);
+    },
+  };
+  publish();
+  return api;
+}