@bitefoundry/retrieviewer 0.0.3 → 0.0.4

package/vendor/procedural-animals/src/species/goat/behaviour.js

@@ -1,509 +0,0 @@
-// Goat behaviour layer for the quadruped engine (species.motion.hooks, see core/motion/actions.js):
-//
-//   pose(engine, dt)        after the engine's solve: the ruminant's sideways grinding of the lower
-//                           jaw while chewing the cud, quick ear flicks (fly flicks, one ear at a time)
-//   update(P, dt, layer)    every frame over the action layer: cud chewing bouts (standing or lying),
-//                           the short tail flicking up, automatic idle variants (browsing, rearing to
-//                           browse, bleating, head shake, pawing, ear flicks), the buck's raised mane
-//                           in a threat
-//   actions                 browse (reach up, or rear onto the hind legs: opts.rear), bleat, headshake,
-//                           paw (scrape the ground with a foreleg), attack (rear up, twist the head,
-//                           drop and clash head-down), sleep (sternal, head turned back to the flank)
-//
-// Posture lengths (headRaise, neckReach, fwd) are engine units (x cfg.k): species metres / cfg.unit.
-import * as THREE from 'three';
-import { clamp, lerp, smooth, TAU, tv, tqa } from '../../core/motion/common.js';
-import { mx, mxLeg, POSTURES, ONESHOTS } from '../../core/motion/actions.js';
-
-const _q = new THREE.Quaternion(), _q2 = new THREE.Quaternion(), _qh = new THREE.Quaternion(), _qI = new THREE.Quaternion(), _s = new THREE.Vector3(1, 1, 1), _m = new THREE.Matrix4();
-const PI = Math.PI;
-// lop ears hang with gravity: the share of the way to the standing hang and the largest turn about the root (25 deg:
-// a lop ear's root lies in the head / neck skin blend, and turned further the skin round the root stretched 3x)
-export const HANG = { f: 0.8, max: 0.44 };
-const sm = (w) => w * w * (3 - 2 * w);
-
-function B(e) {
-  if (!e._goat) {
-    e._goat = {
-      cud: 0, cudOn: e.rand() < 0.6, cudT: 6 + e.rand() * 10, chewPh: 0, grind: 0,
-      ear: [{ a: 0, age: 9, next: 2 + e.rand() * 4 }, { a: 0, age: 9, next: 3 + e.rand() * 5 }],
-      tailT: 1 + e.rand() * 2, tailAge: 9,
-      idleT: 5 + e.rand() * 6,
-    };
-  }
-  return e._goat;
-}
-const busy = (L) => L.postures.length > 0 || L.oneshots.some((a) => !a.stopping);
-
-// ------------------------------------------------------------------------------------------------
-// pose: jaw grinding (lateral swing of the mandible) and ear flicks
-function pose(e, dt) {
-  const b = B(e);
-  // udder / scrotum: drawn up out of the ground when the body rests on it (lying, sleeping, dead)
-  const ud = e.bone.udder;
-  if (ud) {
-    // (a buck's scrotum hangs 12.5 cm below the udder bone's top, its bottom 0.325 m in the bind pose; held up until the
-    // hindquarters have risen)
-    const male = e.params?.sex === 'male';
-    const m = ud.matrixWorld.elements, sY = e.J.udderTop.y / 0.44;
-    const drop = (male ? 0.125 : 0.168 + 0.065 * (e.params?.udder || 0)) * sY;
-    const dl = Math.hypot(m[4], m[5], m[6]) || 1;
-    // (lying on its side the udder's axis is level: a lift toward the sky moved it out of the flank, and the rigid bag
-    // stood out sideways from the belly like a ball, floating beside the rump. There it hangs toward the ground about
-    // its attachment and draws up into the belly along its own axis, against the belly and the lower thigh)
-    const side = smooth(0.2, 0.75, 1 + m[5] / dl);
-    b.udSide = (b.udSide || 0) + (side - (b.udSide || 0)) * (1 - Math.exp(-dt * 6));
-    const top = tv().setFromMatrixPosition(ud.matrixWorld);
-    _q.setFromRotationMatrix(ud.matrixWorld);
-    if (b.udSide > 1e-3) {
-      _qh.setFromUnitVectors(tv(0, 1, 0).applyQuaternion(_q), tv(0, -1, 0)).slerp(_qI, 1 - 0.55 * b.udSide);
-      _q.premultiply(_qh);
-      top.addScaledVector(tv(0, 1, 0).applyQuaternion(_q), -(0.05 + 0.05 * (e.params?.udder || 0)) * sY * b.udSide);
-    }
-    // (the udder is its own rigid surface: all of it must clear the ground, up to 20 cm for a doe in milk; a buck's scrotum,
-    // 18 cm from the groin, 8 cm: lifted 14.5 cm it vanished into the body when he sat or lay down)
-    let want = Math.max(e.P.groundW, e.P.dropH > 0 ? 0.6 * Math.min(1, e.P.dropH) : 0) * (male ? 0.08 : 0.1 + 0.14 * (e.params?.udder || 0)) * e.cfg.s * (1 - b.udSide);
-    // ... and at least as much as its lowest point (the teat tips, the scrotum) needs to clear the ground: rising
-    // hind end first the posture's weights fell faster than the hindquarters rose, and the udder dipped 7 mm
-    // into the ground
-    const low = top.y + tv(0, 1, 0).applyQuaternion(_q).y * drop;
-    want = Math.max(want, e.terrainH(top.x, top.z) + 0.02 * e.cfg.s - low);
-    b.udLift = (b.udLift || 0) + (want - (b.udLift || 0)) * (1 - Math.exp(-dt * 12));
-    if (b.udLift > 1e-5 || b.udSide > 1e-3) {
-      top.y += Math.max(0, b.udLift);
-      ud.matrixWorld.compose(top, _q, _s);
-    }
-  }
-  // beard: a long beard that would reach into the ground (grazing, drinking, lying) swings back
-  // about the chin just enough, smoothly
-  const bd = e.bone.beard;
-  if (bd && (e.params?.beard || 0) > 0.01) {
-    const base = tv().setFromMatrixPosition(bd.matrixWorld);
-    _q.setFromRotationMatrix(bd.matrixWorld);
-    // the beard hangs from the chin skin: it follows the skull more than the opening jaw (the long
-    // lock amplified every jaw movement into a whip at its tip)
-    if (e.bone.head) { _q2.setFromRotationMatrix(e.bone.head.matrixWorld).multiply(b.beardRel || (b.beardRel = beardRelQ(e))); _q.slerp(_q2, 0.75); }
-    const len = b.beardLen ?? (b.beardLen = e.J.beardTop.distanceTo(e.J.beardTip));
-    liftOut(e, b.beardSt || (b.beardSt = {}), base, _q, len, dt, 0.04 * e.cfg.s);
-    bd.matrixWorld.compose(base, _q, _s);
-  }
-  // long lop ears (Nubian, Boer) hang below the muzzle: swung forward and out of the ground when
-  // grazing or lying
-  if (e.params?.ear === 'lop' && e.lod < 2) {
-    // ... and they hang with gravity: turned about the root toward the ear's standing hang (turned with the head's yaw),
-    // most of the way, while the head is upright (a rigid ear kept its standing angle to the skull, so with the head
-    // down to graze or drink it stood out behind the jaw like a plate; the Nubian standard: pendulous ears fall along
-    // the face). A head rolled onto its side (dead, lying flat) leaves the ears to the posture.
-    const qRel = _q2.setFromRotationMatrix(e.bone.head.matrixWorld).multiply(b.headInv || (b.headInv = e.bindQ.head.clone().invert()));
-    const lat = tv(1, 0, 0).applyQuaternion(qRel);
-    const psi = Math.atan2(-lat.z, lat.x);
-    const hang = HANG.f * (1 - smooth(0.35, 0.7, Math.abs(lat.y)));
-    for (let k = 0; k < 2 && hang > 1e-3; k++) {
-      const S = k === 0 ? 'L' : 'R', bone = e.bone['ear' + S];
-      if (!bone) continue;
-      const d0 = b['hang' + S] || (b['hang' + S] = tv(0, 1, 0).applyQuaternion(e.bindQ['ear' + S]).clone());
-      const want = tv().copy(d0).applyAxisAngle(tv(0, 1, 0), psi);
-      _q.setFromRotationMatrix(bone.matrixWorld);
-      const now = tv(0, 1, 0).applyQuaternion(_q);
-      _qh.setFromUnitVectors(now, want);
-      const ang = 2 * Math.acos(Math.min(1, Math.abs(_qh.w)));
-      _qh.slerp(_qI, 1 - Math.min(hang, ang > 1e-4 ? HANG.max / ang : 1));
-      bone.matrixWorld.compose(tv().setFromMatrixPosition(bone.matrixWorld), _q.premultiply(_qh), _s);
-    }
-    for (let k = 0; k < 2; k++) {
-      const S = k === 0 ? 'L' : 'R', bone = e.bone['ear' + S];
-      if (!bone) continue;
-      const st = b['lop' + S] || (b['lop' + S] = {});
-      const base = tv().setFromMatrixPosition(bone.matrixWorld);
-      _q.setFromRotationMatrix(bone.matrixWorld);
-      const len = st.len ?? (st.len = e.J['earBase' + S].distanceTo(e.J['earTip' + S]));
-      if (liftOut(e, st, base, _q, len, dt, 0.02 * e.cfg.s)) bone.matrixWorld.compose(base, _q, _s);
-    }
-  }
-  if (e.lod >= 2) return;
-  const jaw = e.bone.jaw;
-  if (jaw && b.grind > 1e-3) {
-    const base = tv().setFromMatrixPosition(jaw.matrixWorld);
-    _q.setFromRotationMatrix(jaw.matrixWorld);
-    const ax = tv(0, 0, 1).applyQuaternion(_q); // perpendicular to the jaw and to the lateral axis
-    const a = 0.07 * b.grind * Math.sin(b.chewPh);
-    jaw.matrixWorld.compose(base, tqa(ax, a).multiply(_q), _s);
-  }
-  for (let k = 0; k < 2; k++) {
-    const E = b.ear[k];
-    if (E.age > 0.5) continue;
-    const bone = k === 0 ? e.bone.earL : e.bone.earR;
-    if (!bone) continue;
-    // a flick: fast twist about the ear's long axis and a flap, decaying in ~0.4 s
-    const f = Math.sin(Math.min(1, E.age / 0.45) * PI * 2) * Math.exp(-E.age * 5) * (k === 0 ? 1 : -1);
-    const base = tv().setFromMatrixPosition(bone.matrixWorld);
-    _q.setFromRotationMatrix(bone.matrixWorld);
-    const along = tv(0, 1, 0).applyQuaternion(_q), flap = tv(0, 0, 1).applyQuaternion(_q);
-    _q.premultiply(tqa(along, 0.5 * f * E.a)).premultiply(tqa(flap, 0.35 * f * E.a));
-    bone.matrixWorld.compose(base, _q, _s);
-  }
-}
-
-// Keeps a hanging part (beard, lop ear) out of the ground: the smallest swing up about its root that
-// lifts sample points along it (fractions of its length) above the terrain, followed by a critically
-// damped spring (st: { lift, v }). Returns the rotated quaternion in _q (world) for the bone at base.
-function liftOut(e, st, base, q, len, dt, margin) {
-  const dir = tv(0, 1, 0).applyQuaternion(q);
-  let need = 0;
-  if (base.y - e.terrainH(base.x, base.z) < len + margin + 0.02 * e.cfg.s) {
-    for (const f of [1.12, 0.8, 0.5]) {
-      const pt = tv().copy(base).addScaledVector(dir, len * f);
-      const floor = e.terrainH(pt.x, pt.z) + margin;
-      if (pt.y < floor) need = Math.max(need, Math.asin(clamp((floor - pt.y) / (len * f), 0, 1)) * 1.35);
-    }
-  }
-  const om = 28, h = Math.min(dt, 0.05);
-  st.v = (st.v || 0) + (om * om * (need - (st.lift || 0)) - 2 * om * (st.v || 0)) * h;
-  st.lift = Math.max(0, (st.lift || 0) + st.v * h);
-  if (st.lift > 1e-4) {
-    const axis = tv().crossVectors(dir, tv(0, 1, 0));
-    if (axis.lengthSq() > 1e-8) q.premultiply(tqa(axis.normalize(), st.lift));
-  }
-  return st.lift > 1e-4;
-}
-
-// the beard bone's bind rotation relative to the head bone's (so the head-following beard keeps its
-// bind hang)
-function beardRelQ(e) {
-  return e.bindQ.head.clone().invert().multiply(e.bindQ.beard);
-}
-
-// ------------------------------------------------------------------------------------------------
-// update: cud chewing, tail flicks, ear flicks, idle variants
-function update(P, dt, L) {
-  const e = L.engine, b = B(e), cfg = e.cfg;
-  // a kid runs slower than dynamic similarity would give it (a 20 kg kid: ~5.2 m/s, not 6.5): requests
-  // above 0.8 of its scaled top speed are capped there (a cap on every speed also slowed the trot it jumps
-  // from, and the jump's crouch caught a foreleg mid-stride)
-  if (e.params?.age === 'juvenile' && e.wantSpeed > 0.8 * cfg.maxSpeed) P.speedScale *= 0.8 * cfg.maxSpeed / e.wantSpeed;
-  // a kid carries its head lower and further forward, on a less upright neck (kid_side, front2: with the
-  // adult's high, alert carriage its long legs and upright neck read as a llama); not in actions
-  if (e.params?.age === 'juvenile') {
-    let act = 0;
-    for (const a of L.oneshots) act = Math.max(act, a.w || 0);
-    for (const p of L.postures) act = Math.max(act, p.w || 0);
-    const kw = 1 - act;
-    P.headRaise -= (0.045 / cfg.unit) * kw;
-    P.neckReach += (0.025 / cfg.unit) * kw;
-    P.headPitch += 0.1 * kw;
-  }
-  const vn = e.speed / cfg.sq;
-  const still = 1 - smooth(0.1, 0.6, vn);
-  // --- rumination: chewing bouts of 20-40 s with pauses, standing or lying (not while asleep,
-  // eating, bleating or fighting)
-  b.cudT -= dt;
-  if (b.cudT <= 0) { b.cudOn = !b.cudOn; b.cudT = b.cudOn ? 18 + e.rand() * 22 : 8 + e.rand() * 14; }
-  const lying = L.postures.some((p) => p.name === 'lie') ? 1 : 0;
-  const quiet = L.oneshots.some((a) => !a.stopping && a.name !== 'hit' && a.name !== 'headshake') ? 0 : 1;
-  const asleep = L.postures.some((p) => p.name === 'sleep' || p.name === 'death') ? 1 : 0;
-  const want = b.cudOn && quiet && !asleep ? Math.max(still * L.idle.w, lying) : 0;
-  b.cud += (want - b.cud) * (1 - Math.exp(-dt * 3));
-  // chew rate ~1.3 Hz; every ~40 chews a bolus is swallowed (a short pause)
-  const rate = 1.3 * (1 - 0.8 * smooth(0.85, 1, (b.chewPh / TAU) % 40 / 40));
-  b.chewPh += dt * TAU * rate;
-  const chew = b.cud * (0.5 + 0.5 * Math.sin(b.chewPh));
-  b.grind = b.cud;
-  // (ruminating goats chew with the lips closed: a small drop of the jaw under the sideways grind, less
-  // than the lips' overlap; 0.1 rad opened the mouth 2 cm at the lips for most of an idle goat's time)
-  if (b.cud > 1e-3) { P.jaw = Math.max(P.jaw, 0.015 * chew); P.jawOmega = Math.max(P.jawOmega, 18); mx(P, 'eyelid', 0.25, b.cud * 0.6); }
-  // --- tail: held up, flicks in quick bursts (a few rapid side flicks)
-  b.tailT -= dt;
-  if (b.tailT <= 0) { b.tailT = 2 + e.rand() * 5; b.tailAge = 0; }
-  b.tailAge += dt;
-  const tw = b.tailAge < 0.8 ? Math.sin(PI * b.tailAge / 0.8) : 0;
-  if (tw > 0) { P.tailWag = Math.max(P.tailWag, 0.9 * tw * (1 - P.groundW)); mx(P, 'tailLift', 0.25, tw * 0.5); }
-  // --- ear flicks (one ear at a time, more often standing)
-  for (const E of b.ear) {
-    E.age += dt; E.next -= dt * (0.5 + 0.5 * still);
-    if (E.next <= 0) { E.next = 2.5 + e.rand() * 7; E.age = 0; E.a = (0.7 + 0.5 * e.rand()) * (1 - P.eyelid * 0.8) * (e.params?.ear === 'lop' ? 0.3 : 1); }
-  }
-  // --- lying on the side (dead): the ears fold back along the neck, out of the ground
-  const dead = L.postures.reduce((m, p) => (p.name === 'death' ? Math.max(m, p.w) : m), 0);
-  const flat = Math.max(smooth(0.3, 1.0, Math.abs(P.roll)), dead * smooth(0.3, 1, dead));
-  if (flat > 0) { mx(P, 'earFlat', 1.1, flat); mx(P, 'earTwitch', 0, flat); }
-  // ... and the head rests on the lower horn and ear, a little higher than a bare skull would
-  // (a long lop ear lies flat under the cheek: without the lift it was folded sharply about its root, out of
-  // the ground, and its root tore)
-  const lopLift = e.params?.ear === 'lop' ? 0.03 : 0;
-  if (dead > 0 && P.headW > 0) P.headPos.y += (0.035 + lopLift + 0.12 * (e.params?.horns?.len || 0)) * cfg.s * flat;
-  // (the head rolls over with the body rather than twisting on the atlas: the long throat stretched)
-  if (dead > 0) P.headRoll *= 1 - 0.45 * dead;
-  // --- lop ears hang: they hardly swivel, prick or flatten
-  if (e.params?.ear === 'lop') { P.earTwitch *= 0.25; P.earSwivel *= 0.3; P.earFlat *= 0.3; }
-  // --- lying / sleeping: the short tail lies flat, not curled round on the ground like a long tail
-  P.tailSide *= 0.2;
-  // --- grazing / drinking: the head pitches down ahead of the neck as it goes down (with both blended by
-  // the action's fade the neck was down before the nose had turned, and the poll opened 25 deg further than
-  // in the pose itself for a moment: the throat stretched)
-  for (const a of L.oneshots) {
-    if ((a.name !== 'eat' && a.name !== 'drink') || a.stopping || !(a.w > 0 && a.w < 1)) continue;
-    const pitch = a.tune?.pitch ?? 1.3;
-    const lead = Math.min(1, 3 * a.w) - a.w;
-    P.headPitch += lead * (pitch - P.headPitch);
-  }
-  // --- any other action interrupts grazing
-  if (L.oneshots.some((a) => !a.stopping && ['attack', 'jump', 'bleat', 'browse', 'paw'].includes(a.name))) for (const a of L.oneshots) if (a.name === 'eat' || a.name === 'drink') a.stopping = true;
-  // --- idle variants
-  if (e.idleVariants !== false && L.idle.w > 0.98 && !busy(L) && !e.input.look && !e.input.follow) {
-    b.idleT -= dt;
-    if (b.idleT <= 0) {
-      b.idleT = 7 + e.rand() * 10;
-      const r = e.rand();
-      if (r < 0.22) L.play('browse', { rear: e.rand() < 0.55 });
-      else if (r < 0.4) L.play('bleat');
-      else if (r < 0.58) L.play('headshake');
-      else if (r < 0.7) L.play('paw');
-      else if (r < 0.85) { b.ear[0].next = 0; b.ear[1].next = 0.25; }
-    }
-  } else if (busy(L)) b.idleT = Math.max(b.idleT, 3);
-}
-
-// ------------------------------------------------------------------------------------------------
-// browse: stretches the neck up to strip leaves (opts.rear: rises onto the hind legs, forelegs
-// raised as if resting on a trunk). Lips work, the head pulls back after each bite.
-const browse = {
-  kind: 'oneshot', fade: 0.5, needsStand: true,
-  start(inst, L) {
-    const e = L.engine;
-    inst.rear = inst.opts.rear ?? true;
-    inst.dur = inst.opts.loop ? Infinity : (inst.opts.duration ?? (inst.rear ? 5 : 4.5));
-    inst.yaw = (e.rand() - 0.5) * 0.5;
-  },
-  update(inst) { return inst.t >= inst.dur; },
-  apply(P, w, inst, L) {
-    const e = L.engine, cfg = e.cfg, t = inst.t, u = 1 / cfg.unit;
-    const up = w * smooth(0, 0.9, t);
-    // reach and bite cycle (~0.9 s): stretch, bite, pull back and chew
-    const c = (t * 1.1) % 1;
-    const bite = smooth(0.2, 0.35, c) * (1 - smooth(0.4, 0.7, c));
-    mx(P, 'lookW', 0, up);
-    mx(P, 'headPitch', -0.75 - 0.12 * bite, up); mx(P, 'headRaise', (0.1 + 0.015 * bite) * u, up); mx(P, 'neckReach', 0.03 * u, up);
-    mx(P, 'headYaw', inst.yaw + 0.1 * Math.sin(t * 0.8), up);
-    mx(P, 'jaw', 0.05 + 0.18 * bite, up); mx(P, 'jawOmega', 16, up);
-    mx(P, 'earFlat', -0.1, up); mx(P, 'tailLift', 0.15, up);
-    if (inst.rear) {
-      // up on the hind legs: the body comes down first, then the forefeet reach the ground again
-      const body = w * smooth(0.2, 1.3, t) * (1 - smooth(inst.dur - 1.2, inst.dur - 0.2, t));
-      const legs = Math.min(w * smooth(0.2, 0.7, t), w * smooth(0.004 * cfg.k, 0.04 * cfg.k, e.shY.x) + body);
-      mx(P, 'gaitW', 0, w); mx(P, 'legGait', 0, w);
-      // (body ~55 deg up: the neck still reaches up and forward, the forelegs half folded as if
-      // resting on a trunk)
-      mx(P, 'dropF', -1.2, body); mx(P, 'dropH', 0.15, body);
-      for (let i = 0; i < 2; i++) { mxLeg(P, i, 'tuck', 1, legs); P.legs[i].extend = lerp(P.legs[i].extend, 0.3, legs); }
-      mx(P, 'headPitch', 0.1 - 0.1 * bite, body); mx(P, 'headRaise', 0.0, body); mx(P, 'neckReach', 0.045 * u, body);
-    }
-  },
-};
-
-// bleat: head up, mouth open, jaw quiver, ears back a little
-const bleat = {
-  kind: 'oneshot', fade: 0.25,
-  start(inst) { inst.dur = inst.opts.duration ?? 1.7; inst.said = false; },
-  update(inst, dt, L) {
-    if (!inst.said && inst.t > 0.4) { inst.said = true; L.engine.emit('vocalize', { kind: 'bleat' }); }
-    return inst.t >= inst.dur;
-  },
-  apply(P, w, inst, L) {
-    const e = L.engine, t = inst.t, u = 1 / e.cfg.unit;
-    const up = w * smooth(0, 0.35, t);
-    const call = smooth(0.35, 0.5, t) * (1 - smooth(inst.dur - 0.45, inst.dur - 0.15, t));
-    mx(P, 'lookW', 0.3, up);
-    mx(P, 'headPitch', -0.55, up); mx(P, 'headRaise', 0.04 * u, up); mx(P, 'neckReach', 0.015 * u, up);
-    mx(P, 'jaw', 0.42 + 0.07 * Math.sin(t * TAU * 11), call * w); mx(P, 'jawOmega', 30, w);
-    mx(P, 'earFlat', 0.3, up); mx(P, 'breathAmp', 2.2, call * w); mx(P, 'tailLift', 0.2, up);
-  },
-};
-
-// head shake: fast rotations about the nose axis (flies, water), ears flapping
-const headshake = {
-  kind: 'oneshot', fade: 0.12,
-  start(inst) { inst.dur = 1.0; },
-  update(inst) { return inst.t >= inst.dur; },
-  apply(P, w, inst) {
-    const t = inst.t;
-    const env = smooth(0, 0.12, t) * (1 - smooth(0.55, 0.95, t)) * w;
-    const s = Math.sin(t * TAU * 4.2);
-    mx(P, 'headOmega', 5, env); // (the head springs follow the fast shake)
-    mx(P, 'headRoll', 0.42 * s, env); mx(P, 'headYaw', 0.16 * s, env); mx(P, 'headPitch', -0.1, env);
-    mx(P, 'earTwitch', 2.5, env); mx(P, 'eyelid', 0.5, env); mx(P, 'lookW', 0, env);
-  },
-};
-
-// paw: scrapes the ground two or three times with one foreleg (before lying down, or in agitation)
-// Each scrape (0.9 s): the hoof comes up and forward and is held there (~0.4 s, so the lifted foreleg reads:
-// a continuous 0.55 s loop was never caught lifted in the action strip), strikes down and drags back along
-// the ground.
-const PAW_T0 = 0.35, PAW_CYC = 0.9, PAW_N = 2;
-// hoof path per cycle phase f (0..1): [forward (x 0.07 m), height (x 0.1 m)]
-function pawPath(f) {
-  const up = smooth(0.0, 0.16, f) * (1 - smooth(0.6, 0.7, f));
-  const fwd = -0.15 + 1.15 * smooth(0.0, 0.2, f) - 1.15 * smooth(0.62, 0.98, f); // (periodic: -0.15 at both ends)
-  return [fwd, up];
-}
-const paw = {
-  kind: 'oneshot', fade: 0.3, needsStand: true,
-  start(inst, L) { const e = L.engine; inst.dur = PAW_T0 + PAW_N * PAW_CYC + 0.45; inst.leg = inst.opts.side === -1 ? 1 : inst.opts.side === 1 ? 0 : (e.rand() < 0.5 ? 0 : 1); inst.hits = 0; },
-  update(inst, dt, L) {
-    const e = L.engine;
-    // the strike lands at 0.68 of each cycle
-    const n = Math.floor(clamp((inst.t - PAW_T0 - 0.68 * PAW_CYC) / PAW_CYC + 1, 0, PAW_N));
-    if (n > inst.hits && inst.hits < PAW_N) {
-      inst.hits = n;
-      e.emit('footstep', { foot: e.legs[inst.leg].def.key, position: e.legs[inst.leg].contact.clone(), speed: 0, strength: 0.6, paw: true });
-    }
-    return inst.t >= inst.dur;
-  },
-  apply(P, w, inst, L) {
-    const e = L.engine, cfg = e.cfg, s = cfg.s, t = inst.t, i = inst.leg;
-    const tEnd = PAW_T0 + PAW_N * PAW_CYC;
-    const k = w * smooth(0.15, 0.35, t) * (1 - smooth(tEnd + 0.05, tEnd + 0.35, t));
-    mx(P, 'gaitW', 0, w); mx(P, 'legGait', 0, w);
-    mx(P, 'headPitch', 0.35, k); mx(P, 'headRaise', -0.05 / cfg.unit, k); mx(P, 'lookW', 0, k);
-    mx(P, 'side', -0.012 * (i === 0 ? 1 : -1) / cfg.unit, k); // weight onto the other three legs
-    const u = clamp((t - PAW_T0) / PAW_CYC, 0, PAW_N);
-    const f = u >= PAW_N ? 1 : u - Math.floor(u);
-    const [pf, pu] = u >= PAW_N ? [-0.15, 0] : pawPath(f);
-    const leg = e.legs[i];
-    const fwd = e.forward(e.heading, tv());
-    // (a clear lift, the hoof raised ~10 cm and brought forward, then struck down and dragged back: a 3.5 cm
-    // scrape did not read)
-    const tp = tv().copy(leg.plant).addScaledVector(fwd, 0.07 * s * pf);
-    tp.y += 0.1 * s * pu + 0.004 * s;
-    P.legs[i].target.lerp(tp, k / Math.max(1e-3, P.legs[i].reach + k));
-    mxLeg(P, i, 'reach', 1, k);
-  },
-};
-
-// attack: the goat's clash. Rises on the hind legs with the head twisted to one side, then drops
-// forward and brings the horns / forehead down onto the opponent (the impact at the forefeet's
-// landing). Buck: mane raised.
-const attack = {
-  kind: 'oneshot', fade: 0.15, needsStand: true,
-  start(inst, L) {
-    const e = L.engine;
-    inst.dur = 2.1; inst.hit = false;
-    inst.side = inst.opts.side ?? (e.rand() < 0.5 ? -1 : 1);
-    inst.run = smooth(0.8, 2.5, e.speed / e.cfg.sq);
-    inst.target = inst.opts.target ? inst.opts.target.clone() : null;
-  },
-  update(inst, dt, L) {
-    const e = L.engine;
-    if (!inst.hit && inst.t >= 1.18) {
-      inst.hit = true;
-      const p = new THREE.Vector3().copy(e.headPose.position);
-      const dir = inst.target ? inst.target.clone().sub(e.pos).setY(0).normalize() : e.forward(e.heading, new THREE.Vector3());
-      e.emit('attackHit', { position: p, direction: dir, style: 'headbutt' });
-    }
-    return inst.t >= inst.dur;
-  },
-  apply(P, w, inst, L) {
-    const e = L.engine, cfg = e.cfg, t = inst.t, u = 1 / cfg.unit;
-    if (inst.target) { P.look = inst.target; mx(P, 'lookW', 0.6, w); }
-    const rise = smooth(0.1, 0.8, t);
-    const drop = smooth(0.92, 1.2, t);
-    // (running: no rearing, a lowered-head charge into the clash)
-    const still = 1 - inst.run;
-    const up = rise * (1 - drop) * w * still;
-    const clash = smooth(0.98, 1.2, t) * (1 - smooth(1.45, 2.0, t)) * w;
-    const legsW = Math.max(up, w * still * smooth(0.1, 0.4, t) * (1 - smooth(1.02, 1.16, t)));
-    mx(P, 'gaitW', 0, w * still * (1 - smooth(1.6, 2.05, t))); mx(P, 'legGait', 0, w * still * (1 - smooth(1.5, 2.0, t)));
-    if (inst.run > 0) { const low = smooth(0.3, 0.9, t) * (1 - smooth(1.3, 1.9, t)) * w * inst.run; mx(P, 'headPitch', 0.8, low); mx(P, 'headRaise', -0.06 * u, low); }
-    // rear
-    mx(P, 'dropF', -1.35, up); mx(P, 'dropH', 0.2, up); mx(P, 'pitch', 0.05, up);
-    for (let i = 0; i < 2; i++) { mxLeg(P, i, 'tuck', 1, legsW); P.legs[i].extend = lerp(P.legs[i].extend, lerp(0.25, 0.9, smooth(0.85, 1.1, t)), legsW); }
-    mx(P, 'headRoll', 0.45 * inst.side, up); mx(P, 'headYaw', -0.2 * inst.side, up); mx(P, 'headPitch', 0.15, up);
-    mx(P, 'headRaise', 0.03 * u, up);
-    // drop and clash: head down, forehead first, body lunging forward, forequarters low
-    mx(P, 'dropF', 0.28 * still, clash); mx(P, 'fwd', 0.07 * u, clash); mx(P, 'headPitch', 0.95, clash);
-    mx(P, 'headRaise', -0.07 * u, clash); mx(P, 'neckReach', 0.03 * u, clash);
-    mx(P, 'earFlat', 0.8, w * smooth(0, 0.2, t)); mx(P, 'earTwitch', 0, w);
-    mx(P, 'tailLift', 0.4, w);
-    // (the buck's mane rises in the threat)
-    if (e.params?.sex === 'male' && e.params?.age !== 'juvenile') P.furRaise = Math.max(P.furRaise || 0, 0.6 * w);
-  },
-};
-
-// lie: the engine's kneeling lie (actions.lie: down front, up hind), with the rise finished a little
-// before the posture is released: its end-first springs (kF / kH) must settle at zero before the
-// posture instance is removed, or the legs jump in the last frame of standing up
-function lieApply(P, w, inst, L) {
-  const we = inst.target > 0 ? w : smooth(0.3, 1, w);
-  POSTURES.lie.apply(P, we, inst, L);
-}
-const lie = { kind: 'posture', fadeIn: 1.4, fadeOut: 1.3, apply: lieApply };
-
-// sleep: sternal (goats rarely sleep flat out), head turned back and resting against the flank,
-// eyes closed
-const sleep = {
-  kind: 'posture', fadeIn: 1.3, fadeOut: 1.0,
-  apply(P, w, inst, L) {
-    lieApply(P, w, inst, L);
-    const e = L.engine;
-    const c = sm(clamp(w, 0, 1)) * smooth(1.2, 3.2, inst.t);
-    mx(P, 'headYaw', inst.side * 0.8, c); mx(P, 'headPitch', 0.45, c); mx(P, 'headRaise', -0.07 / e.cfg.unit, c);
-    mx(P, 'bend', inst.side * 0.35, c);
-    mx(P, 'earFlat', 0.45, c); mx(P, 'earTwitch', 0.2, c);
-    mx(P, 'eyelid', 1, smooth(1.8, 3.2, inst.t) * w);
-    mx(P, 'breathRate', 0.6, c); mx(P, 'lookW', 0, c); mx(P, 'tailIdle', 0.2, c);
-  },
-};
-
-// death: the engine's collapse (legs buckle, topple onto the side, settle), with the body sinking level and
-// leaning to its side while the legs buckle (falls onto its side): the forelegs, the
-// longer pair, buckled further than the hind ones and the goat pitched onto its nose with its hindquarters
-// high before it rolled over
-const death = {
-  kind: 'posture', fadeIn: POSTURES.death.fadeIn, fadeOut: POSTURES.death.fadeOut,
-  apply(P, w, inst, L) {
-    POSTURES.death.apply(P, w, inst, L);
-    const e = L.engine, cfg = e.cfg, t = inst.t, side = inst.side;
-    const buckle = smooth(0, 0.35, t), fall = clamp((t - 0.3) / 0.55, 0, 1), fallE = fall * fall;
-    const settle = fall >= 1 ? Math.exp(-(t - 0.85) * 6) * Math.sin((t - 0.85) * 18) * 0.06 : 0;
-    const mv = e.air.active ? 0 : smooth(0.08, 0.45, e.speed / cfg.sk) * (1 - smooth(0.3, 0.7, t));
-    const kb = 1 - mv;
-    mx(P, 'dropF', lerp(0.42 * buckle * kb, 1, fallE), w);
-    mx(P, 'roll', side * (1.42 * (fallE + 0.22 * buckle * kb * (1 - fallE)) - settle), w);
-    // (the head goes down with the body as it goes over, not ahead of it: the engine drops it to the ground
-    // from 0.35 s, and the goat dived onto its nose before it rolled)
-    P.headW *= smooth(0.5, 1.05, t);
-  },
-};
-
-// hit: the engine's flinch (a shove away from the blow and a restep), held long enough to read on a goat: the
-// body leans and bends away for ~0.4 s with the head thrown up and away, then the goat shakes it off (the
-// engine's 0.12 s recoil barely showed in any frame)
-const hit = {
-  ...ONESHOTS.hit,
-  kind: 'oneshot',
-  start(inst, L) {
-    ONESHOTS.hit.start(inst, L);
-    inst.dur = 1.4;
-    inst.dead = L.postures.some((p) => p.name === 'death');
-  },
-  apply(P, w, inst) {
-    const t = inst.t;
-    const k = smooth(0, 0.1, t) * (1 - 0.55 * smooth(0.3, 0.75, t)) * (1 - smooth(0.75, 1.25, t)) * w * (inst.dead ? 0.4 : 1);
-    mx(P, 'roll', inst.lx * 0.22, k); mx(P, 'bend', -inst.lx * 0.36, k);
-    mx(P, 'pitch', inst.lz * 0.1, k); mx(P, 'dropF', 0.2, k); mx(P, 'dropH', 0.13, k);
-    P.headLocal.set(inst.lx * 0.08, 0.03, inst.lz * 0.07 - 0.03); mx(P, 'headLocalW', 1, k);
-    mx(P, 'headYaw', -inst.lx * 0.5, k); mx(P, 'headPitch', -0.3, k);
-    mx(P, 'earFlat', 1, w * (1 - smooth(0.55, 0.95, t))); mx(P, 'eyelid', 0.7, k);
-    mx(P, 'jaw', 0.16, k); mx(P, 'tailLift', -0.15, k);
-    if (inst.dead) return;
-    // shaking it off
-    const sh = smooth(0.7, 0.85, t) * (1 - smooth(1.12, 1.32, t)) * w;
-    mx(P, 'headOmega', 5, sh); mx(P, 'headRoll', 0.3 * Math.sin((t - 0.7) * TAU * 4.2), sh);
-    mx(P, 'earTwitch', 2.5, sh);
-  },
-};
-
-export const hooks = {
-  pose,
-  update,
-  actions: { browse, bleat, headshake, paw, attack, hit, lie, sleep, death },
-};