@adatechnology/game-characters-three 0.2.1 → 0.3.0

package/dist/index.js

@@ -75,6 +75,7 @@ var HIP_PIVOT = "vec3(0.,0.95,0.)";
 var createBodyChunk = ({ hipHeight = 0.95 } = {}) => hipHeight === 0.95 ? BODY_CHUNK : BODY_CHUNK.replaceAll(HIP_PIVOT, `vec3(0.,${hipHeight},0.)`);
 
 // src/instanced/body-geometry.ts
+import { shapeGeometries } from "@adatechnology/game-shapes-three";
 import { TEAM_GAME } from "@adatechnology/game-characters";
 var negativeFirst = (first, second) => first[0] <= second[0] ? [first, second] : [second, first];
 var jointsOf = (body) => {
@@ -124,7 +125,8 @@ var mergeBody = (list, three) => {
   merged.computeBoundingSphere();
   return merged;
 };
-var buildInstancedBody = (three, { segments, body = TEAM_GAME }) => {
+var buildInstancedBody = (host, { segments, body = TEAM_GAME }) => {
+  const three = shapeGeometries(host);
   const joints = jointsOf(body);
   const parts = [];
   const half = Math.max(4, segments >> 1);
@@ -299,13 +301,15 @@ var LOD_CASTS_SHADOW = [true, true, false];
 var lodAt = (distance2, distances = LOD_DISTANCES) => distance2 < distances[0] ? 0 : distance2 < distances[1] ? 1 : 2;
 
 // src/instanced/bake.ts
+import { shapeGeometries as shapeGeometries2 } from "@adatechnology/game-shapes-three";
 var BAKE_NEUTRAL_POSE = { lean: 0, armL: 0, armR: 0, elbL: 0, elbR: 0, legL: 0, legR: 0, kneeL: 0, kneeR: 0, headX: 0, headZ: 0, drop: 0, armOut: 0, neck: 0, headFwd: 0 };
 var BLOOD_LIFT_NEAR = 6e-3;
 var BLOOD_LIFT_FAR = 0.012;
 var FAR_LOD = 0.6;
 var EYE_SCALE = 2.2;
 var EYE_DEPTH_SCALE = 1.4;
-var bakeBody = (three, builders, spec, lod) => {
+var bakeBody = (host, builders, spec, lod) => {
+  const three = shapeGeometries2(host);
   const root = spec.retrato && builders.buildPortrait ? builders.buildPortrait(spec.retrato, lod) : builders.buildBest({ ...spec, pose: { ...BAKE_NEUTRAL_POSE, ...spec.pose ?? {} } }, lod);
   const rig = root.userData.rig;
   const P = rig.P;
@@ -448,6 +452,7 @@ var bakeVariants = (three, builders, types) => {
 var createVariantBatches = (three, variant, time) => variant.geometries.map((geometry, level) => createBodyBatch(three, geometry, { max: LOD_BATCH_CAPACITY[level], castShadow: LOD_CASTS_SHADOW[level], time }));
 
 // src/instanced/flying-limbs.ts
+import { shapeGeometries as shapeGeometries3 } from "@adatechnology/game-shapes-three";
 var GRAVITY = 9.8;
 var FLOOR_Y = 0.07;
 var BOUNCE = -0.3;
@@ -455,7 +460,8 @@ var FRICTION = 0.6;
 var SPIN_DAMPING = 0.5;
 var REST_SPEED = 0.4;
 var LEG_COLOR = 2896704;
-var createFlyingLimbs = (three, { max = 40, random, effects = {} }) => {
+var createFlyingLimbs = (host, { max = 40, random, effects = {} }) => {
+  const three = shapeGeometries3(host);
   const limbs = [];
   const mesh = new three.InstancedMesh(new three.CapsuleGeometry(0.065, 0.32, 2, 6), new three.MeshLambertMaterial({ color: 16777215 }), max);
   mesh.count = 0;
@@ -642,8 +648,10 @@ var createRigAnimator = (options = {}) => {
 };
 
 // src/rich/best-builder.ts
+import { shapeGeometries as shapeGeometries4 } from "@adatechnology/game-shapes-three";
 import { createBloodStream, createRng, drawAppearance } from "@adatechnology/game-characters";
-var createBestBuilder = (THREE, { types, random = Math.random }) => {
+var createBestBuilder = (host, { types, random = Math.random }) => {
+  const THREE = shapeGeometries4(host);
   const options = { types, random };
   let LK = 1, topM_ref = null;
   const SPH = (r, w = 8, h = 6, ...a) => new THREE.SphereGeometry(r, Math.max(4, Math.round(w * LK)), Math.max(3, Math.round(h * LK)), ...a);
@@ -1208,6 +1216,7 @@ var createBestBuilder = (THREE, { types, random = Math.random }) => {
 };
 
 // src/rich/person-builder.ts
+import { shapeGeometries as shapeGeometries6 } from "@adatechnology/game-shapes-three";
 import { MOVES, createRng as createRng2 } from "@adatechnology/game-characters";
 
 // src/rich/accessories/face-features.ts
@@ -1245,8 +1254,8 @@ var FACE_FEATURES = [
   },
   {
     ids: ["stubble"],
-    apply: ({ Hd, THREE, add, cmat, scaleHex, sp }) => {
-      const b = add(Hd, new THREE.SphereGeometry(0.123, 16, 12), cmat(scaleHex(sp.skin, 0.62)), 0, 1.705, 0.032);
+    apply: ({ Hd, THREE, add, cmat, scaleHex: scaleHex2, sp }) => {
+      const b = add(Hd, new THREE.SphereGeometry(0.123, 16, 12), cmat(scaleHex2(sp.skin, 0.62)), 0, 1.705, 0.032);
       b.scale.set(1, 0.74, 1);
     }
   },
@@ -1938,9 +1947,11 @@ EXTRAS.rifle_tape = EXTRAS.rifle_front;
 EXTRAS.dbl_front = EXTRAS.rifle_front;
 
 // src/rich/person-kit.ts
-var createPersonKit = (THREE, { random: R, createCanvas = () => document.createElement("canvas") }) => {
+import { shapeGeometries as shapeGeometries5 } from "@adatechnology/game-shapes-three";
+var createPersonKit = (host, { random: R, createCanvas = () => document.createElement("canvas") }) => {
+  const THREE = shapeGeometries5(host);
   const T = THREE;
-  const scaleHex = (hex2, factor) => {
+  const scaleHex2 = (hex2, factor) => {
     const channel = (shift) => (hex2 >> shift & 255) / 255 * factor * 255;
     return channel(16) << 16 ^ channel(8) << 8 ^ channel(0) << 0;
   };
@@ -2050,7 +2061,7 @@ var createPersonKit = (THREE, { random: R, createCanvas = () => document.createE
       return o;
     };
     const sy = 0.8 + R() * 0.4, seed = R() * 10;
-    const core = skin ? stainM(color, { roughness: 0.12, metalness: 0.1 }) : stainM(scaleHex(color, 0.72));
+    const core = skin ? stainM(color, { roughness: 0.12, metalness: 0.1 }) : stainM(scaleHex2(color, 0.72));
     const a = push(add(parent, blobGeo(blobR(40, skin ? 0.4 : 0.9, seed), r * 0.82, r * 0.82 * sy), core, x, y, z + 4e-3));
     if (!skin) {
       push(add(parent, blobGeo(blobR(48, 1.6, seed + 0.3), r * 1.3, r * 1.3 * sy), stainM(color, { transparent: true, opacity: 0.5, depthWrite: false }), x, y, z + 2e-3));
@@ -2070,14 +2081,15 @@ var createPersonKit = (THREE, { random: R, createCanvas = () => document.createE
     }
     return a;
   }
-  return { THREE, PI, SEG, R, scaleHex, Bx, add, cmat, ball, ring, cap, limb, mlimb, torsoGeo, splat, stainM, chessTex };
+  return { THREE, PI, SEG, R, scaleHex: scaleHex2, Bx, add, cmat, ball, ring, cap, limb, mlimb, torsoGeo, splat, stainM, chessTex };
 };
 
 // src/rich/person-builder.ts
 var PAGE_EYES = { lento: 14926657, corredor: 15022379, brutamonte: 15698474 };
-var createPersonBuilder = (THREE, options = {}) => {
+var createPersonBuilder = (host, options = {}) => {
+  const THREE = shapeGeometries6(host);
   const kit = createPersonKit(THREE, { random: options.random ?? createRng2(77), createCanvas: options.createCanvas });
-  const { PI, R, scaleHex, Bx, add, cmat, ball, ring, cap, limb, mlimb, torsoGeo, splat, stainM, chessTex } = kit;
+  const { PI, R, scaleHex: scaleHex2, Bx, add, cmat, ball, ring, cap, limb, mlimb, torsoGeo, splat, stainM, chessTex } = kit;
   const reduce = options.reducedMotion ?? false;
   const detailed = (options.detail ?? 0) === 0;
   const EYE = { ...PAGE_EYES, ...options.zombieEyes };
@@ -2178,7 +2190,7 @@ var createPersonBuilder = (THREE, options = {}) => {
     const ridge = ball(Hd, 0.1, skinM, 0, 1.842, 0.105);
     ridge.scale.set(1.3, 0.28, 0.55);
     add(Hd, new THREE.SphereGeometry(0.021, 10, 8), skinM, 0, 1.762, 0.182);
-    add(Hd, Bx(0.064, 0.013, 0.02), cmat(scaleHex(sp.skin, 0.68)), 0, 1.703, 0.156);
+    add(Hd, Bx(0.064, 0.013, 0.02), cmat(scaleHex2(sp.skin, 0.68)), 0, 1.703, 0.156);
     const bags = add(Hd, Bx(0.2, 0.022, 0.012), new THREE.MeshBasicMaterial({ color: 3811882, transparent: true, opacity: 0 }), 0, 1.79, 0.166);
     bags.castShadow = false;
     const hc = cmat(sp.hair.c), hs = sp.hair.s;
@@ -2215,7 +2227,7 @@ var createPersonBuilder = (THREE, options = {}) => {
       t.rotation.x = 0.25;
     }
     const f = sp.face || [];
-    for (const feature of FACE_FEATURES) if (feature.ids.some((id) => f.includes(id))) feature.apply({ THREE, PI, Hd, add, Bx, cmat, hc, sp, f, scaleHex });
+    for (const feature of FACE_FEATURES) if (feature.ids.some((id) => f.includes(id))) feature.apply({ THREE, PI, Hd, add, Bx, cmat, hc, sp, f, scaleHex: scaleHex2 });
     if (sp.hat) {
       const k = sp.hat.k, c = cmat(sp.hat.c);
       HATS.find((hat) => hat.kinds.includes(k))?.apply({ THREE, PI, Hd, add, Bx, cmat, cap, c, k, sp });
@@ -2432,6 +2444,7 @@ var createPersonBuilder = (THREE, options = {}) => {
 };
 
 // src/eyes.ts
+import { shapeGeometries as shapeGeometries7 } from "@adatechnology/game-shapes-three";
 var GLOW_SIZE = 64;
 var createGlowTexture = (three, createCanvas) => {
   const make = createCanvas ?? (typeof document === "undefined" ? void 0 : () => document.createElement("canvas"));
@@ -2448,7 +2461,8 @@ var createGlowTexture = (three, createCanvas) => {
   context.fillRect(0, 0, GLOW_SIZE, GLOW_SIZE);
   return new three.CanvasTexture(canvas);
 };
-var createEye = (three, { color, radius = 0.02, glow, glowOpacity = 0.55, texture = null }) => {
+var createEye = (host, { color, radius = 0.02, glow, glowOpacity = 0.55, texture = null }) => {
+  const three = shapeGeometries7(host);
   const eye = new three.Group();
   const ball = new three.Mesh(new three.SphereGeometry(radius, 10, 8), new three.MeshBasicMaterial({ color }));
   ball.userData.eye = 1;
@@ -3436,6 +3450,59 @@ var personSpecOf = (profession) => {
   return spec;
 };
 
+// src/test-area/knock.ts
+import { blastShove } from "@adatechnology/game-contracts";
+var KNOCK_DOWN_SPEED = 2.5;
+var KNOCKED_DOWN_ANGLE = 1.35;
+var LIE_SECONDS = 1.6;
+var STAND_UP_PER_SPEED = 0.25;
+var FALL_SECONDS = 0.25;
+var RISE_SECONDS = 0.6;
+var GROUND_FRICTION = 7;
+var GRAVITY3 = 9.81;
+var CHEST = 1.1;
+var bodyMass = (height, build = 1) => 70 * (height / 1.75) ** 2 * build;
+function knockOf(blast, feet, mass, options) {
+  const hit = blastShove(blast, { position: [feet[0], feet[1] + CHEST, feet[2]], mass }, options);
+  if (!hit) return void 0;
+  const [dx, dy, dz] = hit.direction;
+  return { velocity: [dx * hit.speed, Math.max(0, dy * hit.speed), dz * hit.speed], airborne: dy > 0, lying: 0, lieLeft: 0, down: hit.speed >= KNOCK_DOWN_SPEED };
+}
+function stepKnock(knock, position, dt, groundAt, alive) {
+  const v = knock.velocity;
+  position.x += v[0] * dt;
+  position.z += v[2] * dt;
+  const ground = groundAt(position.x, position.z);
+  if (knock.airborne || position.y > ground + 1e-4) {
+    v[1] -= GRAVITY3 * dt;
+    position.y += v[1] * dt;
+    if (position.y <= ground) {
+      position.y = ground;
+      v[1] = 0;
+      knock.airborne = false;
+    }
+  } else position.y = ground;
+  const horizontal = Math.hypot(v[0], v[2]);
+  if (!knock.airborne && horizontal > 0) {
+    const slowed = Math.max(0, horizontal - GROUND_FRICTION * dt);
+    v[0] *= slowed / horizontal;
+    v[2] *= slowed / horizontal;
+  }
+  const moving = horizontal > 0.05 || knock.airborne;
+  if (knock.down) {
+    if (moving) knock.lying = Math.min(1, knock.lying + dt / FALL_SECONDS);
+    else {
+      knock.lying = 1;
+      if (alive) {
+        knock.lieLeft = knock.lieLeft > 0 ? knock.lieLeft : LIE_SECONDS + Math.hypot(v[0], v[2]) * STAND_UP_PER_SPEED;
+        knock.lieLeft -= dt;
+        if (knock.lieLeft <= 0) knock.down = false;
+      }
+    }
+  } else if (knock.lying > 0) knock.lying = Math.max(0, knock.lying - dt / RISE_SECONDS);
+  return !moving && !knock.down && knock.lying === 0;
+}
+
 // src/test-area/scenarios.ts
 import { SEGMENT_IDS } from "@adatechnology/game-characters";
 var LIMB_SEGMENTS = ["upperArmL", "forearmL", "handL", "upperArmR", "forearmR", "handR", "thighL", "shinL", "footL", "thighR", "shinR", "footR"];
@@ -3840,6 +3907,17 @@ function createCharactersTestModule(options = {}) {
   };
   const animate = (entry, dt) => {
     const { root, character } = entry;
+    if (entry.knock) {
+      const rig = root.userData.rig;
+      const ground = (x, z) => host?.groundAt(x, z) ?? 0;
+      const done = stepKnock(entry.knock, root.position, dt, ground, character.alive);
+      if (done) entry.knock = void 0;
+      if (character.alive && rig) rig.fig.rotation.x = -(entry.knock?.lying ?? 0) * KNOCKED_DOWN_ANGLE;
+      if (entry.knock && entry.knock.lying > 0 && character.alive) {
+        entry.eyes?.off();
+        return;
+      }
+    }
     if (!character.alive) {
       entry.tilt = Math.min(1, entry.tilt + dt * 2);
       const rig = root.userData.rig;
@@ -4045,6 +4123,15 @@ function createCharactersTestModule(options = {}) {
       wounds = createWounds(lent.THREE, { random, scene: scene2, groundAt: (x, z) => lent.groundAt(x, z), ...bridge ? { bridge } : {}, ...sound ? { sound } : {} });
       for (const entry of entries.values()) trackEntry(entry);
       const stopChange = lent.bench?.onChange(onChange);
+      const stopEvents = lent.on((event) => {
+        if (event.type !== "explosion") return;
+        for (const entry of entries.values()) {
+          if (!entry.root.parent) continue;
+          const p2 = entry.root.position;
+          const knock = knockOf(event, [p2.x, p2.y, p2.z], bodyMass(entry.character.spec.height, entry.character.spec.build), lent.blastShove);
+          if (knock) entry.knock = entry.knock ? { ...knock, lying: entry.knock.lying } : knock;
+        }
+      });
       const stopFrame = lent.onFrame((dt) => {
         time += dt;
         for (const [id, entry] of entries) {
@@ -4060,6 +4147,7 @@ function createCharactersTestModule(options = {}) {
       });
       return () => {
         stopChange?.();
+        stopEvents();
         stopFrame();
         clearOverlays();
         wounds?.dispose();
@@ -4095,7 +4183,1023 @@ var BODY_MATERIAL_DEF = {
 var registerBodyMaterial = (world) => {
   if (!world.materials.has(BODY_MATERIAL_DEF.id)) world.materials.set(BODY_MATERIAL_DEF.id, BODY_MATERIAL_DEF);
 };
+
+// src/player/avatar.ts
+import {
+  POSE_CLIPS,
+  clipEventsBetween,
+  createPoseClipRegistry,
+  createRng as createRng4,
+  filterPoseChannels,
+  samplePoseClip,
+  walkCadence,
+  walkGait
+} from "@adatechnology/game-characters";
+
+// src/presets/player-avatar.json
+var player_avatar_default = {
+  source: {
+    file: "site/pages/jogo/zombiada-modo-livre.html",
+    variable: "PB specs[0] ('voc\xEA') and PLAYER_COR",
+    note: "The team game's player body: the Besti\xE1rio/Elenco human body. Overridable by `createPlayerAvatar(THREE, { spec, shirtColor })`."
+  },
+  spec: {
+    type: "Lento",
+    human: true,
+    decay: 0,
+    seed: 4242,
+    skin: "b07a52",
+    fem: false,
+    life: 1,
+    hs: "short",
+    hair: "2a1e16"
+  },
+  shirtColor: "3d5a73"
+};
+
+// src/player/avatar.ts
+var TWO_PI = Math.PI * 2;
+var MAX_GAIT = 1.4;
+var CLIP_BLEND = 0.12;
+var FALL_SECONDS2 = 0.3;
+var HIP_HEIGHT = 0.95;
+var WALK_ARM = 0.45;
+var WALK_BOB = 0.035;
+var WALK_LEAN = 0.04;
+var CROUCH = { thigh: -0.95, thighWalk: 0.3, shin: 1.9, lean: 0.25, drop: -0.35 };
+var AIMED = { shoulder: -1.42, perAim: 0.85, swing: 0.02, zRight: -0.54, zLeft: 0.36, elbowRight: -0.04, elbowLeft: -0.12 };
+var DOWN = { thighWalk: 0.5, shinSwing: 0.85, shinBend: 1.3, armHigh: -2.8, armLow: -0.35, armWave: 0.3, armZ: 0.5, armZWave: 0.3, tilt: 1.5, roll: 0.3, hipY: 0.16, hipZ: 0.6, hipZFlip: 1.2 };
+var HAND_OFFSET = { x: 0, y: -0.33, z: 0.04 };
+var hexOf = (value) => typeof value === "string" ? Number.parseInt(value, 16) : value;
+var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var fract = (value) => value - Math.floor(value);
+var createPlayerAvatar = (THREE, options = {}) => {
+  const spec = { ...player_avatar_default.spec, ...options.spec };
+  for (const key of ["skin", "hair"]) if (typeof spec[key] === "string") spec[key] = hexOf(spec[key]);
+  const best = createBestBuilder(THREE, { types: [{ name: String(spec.type), eye: 0 }], random: createRng4(Number(spec.seed ?? 1)) });
+  const body = best.build(spec);
+  best.topM().color.setHex(options.shirtColor ?? hexOf(player_avatar_default.shirtColor));
+  const rig = body.userData.rig;
+  const profile = { f: 1.1, a: 0.28, k: 0.35, arm: WALK_ARM, bob: WALK_BOB };
+  const animator = createRigAnimator({ gaits: { [rig.type]: profile } });
+  const clips = options.clips ?? createPoseClipRegistry(POSE_CLIPS);
+  const blendDefault = options.blend ?? CLIP_BLEND;
+  const fallSeconds = options.fallSeconds ?? FALL_SECONDS2;
+  const smooth = options.cascade ?? true;
+  const root = new THREE.Group();
+  const tilt = new THREE.Group();
+  tilt.add(body);
+  root.add(tilt);
+  const colorOf2 = (object) => object?.material?.color?.getHex();
+  const meshesOf = (node) => node.children.filter((child) => child.isMesh);
+  const shirt = options.shirtColor ?? hexOf(player_avatar_default.shirtColor);
+  const shoe = meshesOf(rig.legs[0].kn).find((mesh) => mesh.scale.z > 1.5);
+  const forearm = colorOf2(meshesOf(rig.arms[1].el)[0]);
+  const colors = {
+    skin: Number(spec.skin),
+    shirt,
+    trousers: colorOf2(meshesOf(rig.legs[0].g)[0]) ?? 2962496,
+    shoes: colorOf2(shoe) ?? 1841690,
+    longSleeves: forearm === shirt
+  };
+  const sockets = { R: new THREE.Object3D(), L: new THREE.Object3D() };
+  const armOf = { R: rig.arms[1], L: rig.arms[0] };
+  for (const side of ["R", "L"]) {
+    sockets[side].name = `hand_${side}`;
+    sockets[side].position.set(HAND_OFFSET.x, HAND_OFFSET.y, HAND_OFFSET.z);
+    armOf[side].el.add(sockets[side]);
+  }
+  const legRestX = rig.legs.map((leg) => leg.g.position.x);
+  const legSide = (index) => index === 0 ? 1 : -1;
+  let cycles = 0;
+  let time = 0;
+  let fall = 0;
+  let run = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = (event, onEvent) => {
+    onEvent?.(event);
+    for (const listener of listeners) listener(event);
+  };
+  const readPose = () => ({
+    lean: rig.upper.rotation.x,
+    twist: rig.upper.rotation.y,
+    side: rig.upper.rotation.z,
+    drop: rig.fig.position.y - rig.dropBase,
+    headX: rig.headG.rotation.x,
+    headY: rig.headG.rotation.y,
+    headZ: rig.headG.rotation.z,
+    armR: rig.arms[0].g.rotation.x,
+    armL: rig.arms[1].g.rotation.x,
+    elbR: rig.arms[0].el.rotation.x,
+    elbL: rig.arms[1].el.rotation.x,
+    armRz: rig.arms[0].g.rotation.z,
+    armLz: rig.arms[1].g.rotation.z,
+    legL: rig.legs[0].g.rotation.x,
+    legR: rig.legs[1].g.rotation.x,
+    kneeL: rig.legs[0].kn.rotation.x,
+    kneeR: rig.legs[1].kn.rotation.x
+  });
+  const armed = (pitch, gait, hip) => {
+    const aim = clamp((pitch + 1) / 3, 0, 0.99) * 3 - 1;
+    const shoulder = AIMED.shoulder + aim * AIMED.perAim + AIMED.swing * Math.sin(cycles * TWO_PI) * gait;
+    rig.legs.forEach((leg, index) => {
+      const x = legRestX[index];
+      leg.g.rotation.y = hip;
+      leg.g.position.x = x * Math.cos(hip);
+      leg.g.position.z = -x * Math.sin(hip);
+    });
+    return { armR: shoulder, armL: shoulder, armRz: AIMED.zRight, armLz: AIMED.zLeft, elbR: AIMED.elbowRight, elbL: AIMED.elbowLeft };
+  };
+  const resetLegYaw = () => {
+    rig.legs.forEach((leg, index) => {
+      leg.g.rotation.y = 0;
+      leg.g.position.x = legRestX[index];
+      leg.g.position.z = 0;
+    });
+  };
+  const crouchPose = (gait) => {
+    const swing = (leg) => {
+      const legS = legSide(leg);
+      return CROUCH.thigh - Math.sin(cycles * TWO_PI) * legS * CROUCH.thighWalk * gait;
+    };
+    return {
+      legL: swing(0),
+      legR: swing(1),
+      kneeL: CROUCH.shin,
+      kneeR: CROUCH.shin,
+      lean: WALK_LEAN * gait + CROUCH.lean,
+      drop: Math.abs(Math.sin(cycles * TWO_PI)) * WALK_BOB * gait + CROUCH.drop
+    };
+  };
+  const downPose = () => {
+    const ph = cycles * TWO_PI;
+    const gait = 1;
+    const leg = (index) => {
+      const legS = legSide(index);
+      const walkS = Math.sin(ph) * legS;
+      const bend = fract(cycles * 3) * legS > 0.3 ? fract(cycles * 3) * DOWN.shinBend : Math.max(0, Math.cos(ph + (legS > 0 ? 0 : Math.PI))) * DOWN.shinSwing * gait;
+      return { hip: -walkS * DOWN.thighWalk * gait, knee: bend };
+    };
+    const arm = (index) => {
+      const side = index === 0 ? 1 : -1;
+      const armS = Math.sin(ph) * (side > 0 ? 1 : -1);
+      const shoulder = fract(cycles * 5) > 0.5 && side > 0 ? DOWN.armHigh : DOWN.armLow + DOWN.armWave * Math.sin(cycles * 5 + side);
+      return { shoulder, z: side * (DOWN.armZ + DOWN.armZWave * Math.sin(cycles * 3)), elbow: -0.35 - Math.max(0, armS) * 0.4 * gait };
+    };
+    const [l, r] = [leg(0), leg(1)];
+    const [a0, a1] = [arm(0), arm(1)];
+    return {
+      legL: l.hip,
+      kneeL: l.knee,
+      legR: r.hip,
+      kneeR: r.knee,
+      armR: a0.shoulder,
+      armRz: a0.z,
+      elbR: a0.elbow,
+      armL: a1.shoulder,
+      armLz: a1.z,
+      elbL: a1.elbow,
+      lean: WALK_LEAN * gait,
+      drop: Math.abs(Math.sin(ph)) * WALK_BOB * gait
+    };
+  };
+  const placeBody = (progress) => {
+    const fk = progress * progress * (3 - 2 * progress);
+    const flip = fract(cycles * 1.7) >= 0.5 ? 1 : 0;
+    tilt.rotation.set((-DOWN.tilt + flip * 2 * DOWN.tilt) * fk, 0, Math.sin(cycles * 7) * DOWN.roll * fk, "XYZ");
+    const hip = new THREE.Vector3(0, HIP_HEIGHT, 0);
+    const target = new THREE.Vector3(0, DOWN.hipY, -DOWN.hipZ + flip * DOWN.hipZFlip);
+    const place = new THREE.Vector3(0, HIP_HEIGHT * (1 - fk), 0).addScaledVector(target, fk);
+    tilt.position.copy(place.sub(hip.applyEuler(tilt.rotation)));
+  };
+  const fireClipEvents = (r, from, to) => {
+    for (const event of clipEventsBetween(r.clip, from, to)) emit({ ...event, clip: r.clip.id }, r.onEvent);
+  };
+  const stepClip = (dt, down) => {
+    if (!run) return;
+    const r = run;
+    const from = r.time;
+    r.time += dt;
+    const { duration } = r.clip;
+    if (r.clip.loop && r.time > duration) {
+      fireClipEvents(r, from, duration);
+      r.time -= duration * Math.floor(r.time / duration);
+      fireClipEvents(r, -1e-9, r.time);
+    } else {
+      fireClipEvents(r, from, Math.min(r.time, duration));
+      if (r.time >= duration && !r.clip.loop) r.target = 0;
+    }
+    r.weight = r.blend <= 0 ? r.target : clamp(r.weight + (r.target ? dt : -dt) / r.blend, 0, 1);
+    if (r.target === 0 && r.weight <= 0) {
+      run = null;
+      return;
+    }
+    if (down) return;
+    const sampled = filterPoseChannels(samplePoseClip(r.clip, Math.min(r.time, duration)), r.clip.channels ?? "full");
+    const current = readPose();
+    const blended = {};
+    for (const [name, value] of Object.entries(sampled)) if (name in current) blended[name] = current[name] + (value - current[name]) * r.weight;
+    animator.setPose(rig, blended);
+  };
+  return {
+    root,
+    rig,
+    colors,
+    three: THREE,
+    get playing() {
+      return run ? run.clip.id : null;
+    },
+    update(dt, state = {}) {
+      const speed = state.speed ?? 0;
+      const moving = speed >= 0.05;
+      if (moving) cycles += dt * walkCadence(speed);
+      const gait = Math.min(MAX_GAIT, walkGait(speed));
+      profile.arm = WALK_ARM * gait;
+      profile.bob = WALK_BOB * gait;
+      time = cycles / walkCadence(Math.max(speed, 0));
+      animator.animate(body, time, { speed });
+      const down = !!state.down;
+      fall = fallSeconds <= 0 ? down ? 1 : 0 : clamp(fall + (down ? dt : -dt) / fallSeconds, 0, 1);
+      resetLegYaw();
+      if (down) animator.setPose(rig, downPose());
+      else {
+        if (state.crouch) animator.setPose(rig, crouchPose(gait));
+        if (state.armed) animator.setPose(rig, armed(state.pitch ?? 0, gait, state.hip ?? 0));
+      }
+      placeBody(fall);
+      stepClip(dt, down);
+      if (smooth) animator.cascade(rig, dt);
+    },
+    play(clip, playOptions = {}) {
+      const found = typeof clip === "string" ? clips.get(clip) : clip;
+      if (!found) throw new Error(`Unknown pose clip: ${String(clip)}`);
+      run = { clip: found, time: 0, weight: run?.weight ?? 0, target: 1, blend: playOptions.blend ?? blendDefault, ...playOptions.onEvent ? { onEvent: playOptions.onEvent } : {} };
+      fireClipEvents(run, -1e-9, 0);
+      run.time = 0;
+    },
+    stop() {
+      if (run) run.target = 0;
+    },
+    hand: (side) => sockets[side],
+    on(_type, listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    dispose() {
+      run = null;
+      listeners.clear();
+      body.traverse((object) => {
+        const mesh = object;
+        mesh.geometry?.dispose();
+        const material = mesh.material;
+        if (Array.isArray(material)) material.forEach((m) => m.dispose());
+        else material?.dispose();
+      });
+      root.removeFromParent();
+    }
+  };
+};
+
+// src/player/room-avatar.ts
+import { ATTACK_CLIPS, FIRST_PERSON_CLIPS } from "@adatechnology/game-characters-people";
+import { mirrorPoseClip } from "@adatechnology/game-characters";
+
+// src/first-person/arms.ts
+import { clipEventsBetween as clipEventsBetween2, sampleFirstPersonClip } from "@adatechnology/game-characters";
+
+// src/presets/first-person-arms.json
+var first_person_arms_default = {
+  source: {
+    note: "Authored in the kit: no team delivered first-person arms. The rig is in metres in the camera's space (x right, y up, the view looks down -z); rest poses use the hand frame of HandPose in game-contracts, Euler [roll, yaw, pitch] in the order YZX (yaw pi/2 points the fingers forward)."
+  },
+  rig: {
+    shoulder: [0.16, -0.36, 0.18],
+    upper: 0.32,
+    fore: 0.3,
+    reachShift: 0.35,
+    wrist: 0.07,
+    elbowPole: [0.45, -1, 0.2],
+    shoulderLeft: [-0.07, -0.46, 0.18],
+    elbowPoleLeft: [-0.1, -1, 0.2],
+    radius: { shoulder: 0.04, elbow: 0.034, wrist: 0.028, cuff: 0.031 },
+    hip: [0.12, -0.82, 0.04],
+    thigh: 0.46,
+    shin: 0.46,
+    kneePole: [0.1, 0.5, -1],
+    foot: { p: [0.13, -0.85, -0.05], r: [0, 1.5708, 0] }
+  },
+  stances: {
+    relaxed: {
+      R: { p: [0.2, -0.2, -0.36], r: [0.2, 1.45, -0.4], grip: 0.35 },
+      L: "mirror"
+    },
+    fists: {
+      R: { p: [0.15, -0.12, -0.4], r: [0, 1.5, 0.15], grip: 1 },
+      L: "mirror"
+    },
+    hold: { follow: true, fallback: "relaxed" }
+  },
+  bob: { frequency: 2.3, x: 6e-3, y: 8e-3, run: 1.5, fullSpeed: 4, crouch: 0.02 }
+};
+
+// src/first-person/hand.ts
+var FINGERS = [
+  { z: -0.03, lengths: [0.034, 0.024, 0.02], width: 0.016 },
+  { z: -0.0105, lengths: [0.038, 0.027, 0.022], width: 0.0165 },
+  { z: 9e-3, lengths: [0.035, 0.025, 0.02], width: 0.0155 },
+  { z: 0.027, lengths: [0.029, 0.02, 0.018], width: 0.0135 }
+];
+var PALM = { length: 0.09, thick: 0.026, width: 0.09, wristWidth: 0.066 };
+var FINGER_THICK = 0.0135;
+var CURL = { near: 1.05, mid: 1.25, far: 0.85, spread: 0.06 };
+var THUMB = { base: [5e-3, -6e-3, -0.044], near: 0.034, far: 0.028, width: 0.019 };
+var createHandMesh = (THREE, skin, wristSkin = skin) => {
+  const root = new THREE.Group();
+  root.name = "first-person-hand";
+  const geometries = [];
+  const box = (parent, sx, sy, sz, x, y, z, material = skin) => {
+    const geometry = new THREE.BoxGeometry(sx, sy, sz);
+    geometries.push(geometry);
+    const mesh = new THREE.Mesh(geometry, material);
+    mesh.position.set(x, y, z);
+    mesh.frustumCulled = false;
+    parent.add(mesh);
+    return mesh;
+  };
+  const palmGeometry = new THREE.BoxGeometry(PALM.length, PALM.thick, PALM.width);
+  const palmPosition = palmGeometry.getAttribute("position");
+  for (let i = 0; i < palmPosition.count; i++) {
+    if (palmPosition.getX(i) < 0) palmPosition.setZ(i, palmPosition.getZ(i) * PALM.wristWidth / PALM.width);
+  }
+  palmGeometry.computeVertexNormals();
+  geometries.push(palmGeometry);
+  const palm = new THREE.Mesh(palmGeometry, skin);
+  palm.frustumCulled = false;
+  root.add(palm);
+  const wristGeometry = new THREE.CylinderGeometry(0.03, 0.033, 0.05, 8);
+  wristGeometry.rotateZ(Math.PI / 2);
+  geometries.push(wristGeometry);
+  const wrist = new THREE.Mesh(wristGeometry, wristSkin);
+  wrist.position.set(-PALM.length / 2 - 0.018, 0, 0);
+  wrist.frustumCulled = false;
+  root.add(wrist);
+  const joints = [];
+  FINGERS.forEach((finger, index) => {
+    const segments = [];
+    let parent = root;
+    let at = PALM.length / 2;
+    finger.lengths.forEach((length, k) => {
+      const group = new THREE.Group();
+      group.position.set(at, k === 0 ? 2e-3 : 0, k === 0 ? finger.z : 0);
+      const taper = 1 - k * 0.07;
+      box(group, length, FINGER_THICK * taper, finger.width * taper, length / 2, 0, 0);
+      parent.add(group);
+      segments.push(group);
+      parent = group;
+      at = length;
+    });
+    joints.push({ segments, weight: 1 + index * (CURL.spread / CURL.near) });
+  });
+  const thumbNear = new THREE.Group();
+  thumbNear.rotation.order = "YZX";
+  thumbNear.position.set(...THUMB.base);
+  box(thumbNear, THUMB.near, FINGER_THICK * 1.1, THUMB.width, THUMB.near / 2, 0, 0);
+  const thumbFar = new THREE.Group();
+  thumbFar.position.set(THUMB.near, 0, 0);
+  box(thumbFar, THUMB.far, FINGER_THICK, THUMB.width * 0.9, THUMB.far / 2, 0, 0);
+  thumbNear.add(thumbFar);
+  root.add(thumbNear);
+  let lastGrip = 0;
+  let indexCurl;
+  const curl = [CURL.near, CURL.mid, CURL.far];
+  const applyIndex = () => {
+    const finger = joints[0];
+    if (!finger) return;
+    const k = indexCurl === void 0 ? lastGrip : Math.min(1, Math.max(0, indexCurl));
+    finger.segments.forEach((segment, i) => segment.rotation.z = -curl[i] * k * finger.weight);
+  };
+  const setGrip = (grip) => {
+    const k = Math.min(1, Math.max(0, grip));
+    lastGrip = k;
+    for (const joint of joints) joint.segments.forEach((segment, i) => segment.rotation.z = -curl[i] * k * joint.weight);
+    thumbNear.rotation.set(0, 0.55 - 1.45 * k, -0.1 - 0.75 * k);
+    thumbFar.rotation.z = -0.1 - 0.7 * k;
+    applyIndex();
+  };
+  const setIndex = (value) => {
+    indexCurl = value;
+    applyIndex();
+  };
+  setGrip(0);
+  return {
+    root,
+    setGrip,
+    setIndex,
+    dispose() {
+      for (const geometry of geometries) geometry.dispose();
+    }
+  };
+};
+
+// src/first-person/ik.ts
+var solveTwoBone = (root, target, upper, lower, pole, out) => {
+  const line = out.line.copy(target).sub(root);
+  let distance2 = line.length();
+  if (distance2 < 1e-6) line.set(0, 0, -1);
+  else line.divideScalar(distance2);
+  const min = Math.abs(upper - lower) + 1e-4;
+  const max = upper + lower - 1e-4;
+  out.clamped = distance2 > max || distance2 < min;
+  distance2 = Math.min(max, Math.max(min, distance2));
+  const along = (distance2 * distance2 + upper * upper - lower * lower) / (2 * distance2);
+  const across = Math.sqrt(Math.max(0, upper * upper - along * along));
+  const side = out.side.copy(pole);
+  side.addScaledVector(line, -side.dot(line));
+  if (side.lengthSq() < 1e-8) side.set(0, 1, 0).addScaledVector(line, -line.y);
+  if (side.lengthSq() < 1e-8) side.set(1, 0, 0);
+  side.normalize();
+  out.joint.copy(root).addScaledVector(line, along).addScaledVector(side, across);
+  out.end.copy(root).addScaledVector(line, distance2);
+  return out;
+};
+var createTwoBone = (THREE) => ({ joint: new THREE.Vector3(), end: new THREE.Vector3(), clamped: false, line: new THREE.Vector3(), side: new THREE.Vector3() });
+
+// src/first-person/arms.ts
+var DEFAULT_BLEND = 0.18;
+var ELBOW_SEGMENTS = 8;
+var REACH_SLACK = 0.97;
+var CONTACT_PROBE = 1.4;
+var CONTACT_MIN = 0.12;
+var CONTACT_MARGIN = 5e-3;
+var CONTACT_PALM = 0.03;
+var FOOT_LENGTH = 0.24;
+var FOOT_SHOWN = 1e-3;
+var FILL = 0.3;
+var FIRST_PERSON_STANCES = first_person_arms_default.stances;
+var FIRST_PERSON_RIG = first_person_arms_default.rig;
+var FIRST_PERSON_BOB = first_person_arms_default.bob;
+var hexOf2 = (value) => typeof value === "string" ? Number.parseInt(value, 16) : value;
+var scaleHex = (hex2, factor) => {
+  const channel = (shift) => Math.round((hex2 >> shift & 255) * factor);
+  return channel(16) << 16 | channel(8) << 8 | channel(0);
+};
+var mix = (a, b, k) => a + (b - a) * k;
+var ease = (k) => k * k * (3 - 2 * k);
+var FIRST_PERSON_COLORS = {
+  skin: hexOf2(player_avatar_default.spec.skin),
+  sleeve: hexOf2(player_avatar_default.shirtColor),
+  cuff: scaleHex(hexOf2(player_avatar_default.shirtColor), 0.72),
+  trouser: 2962496,
+  shoe: 1841690
+};
+var newPose = (THREE) => ({ p: new THREE.Vector3(), q: new THREE.Quaternion(), grip: 0, scale: 1 });
+var copyPose = (to, from) => {
+  to.p.copy(from.p);
+  to.q.copy(from.q);
+  to.grip = from.grip;
+  to.scale = from.scale;
+  return to;
+};
+var mixPose = (THREE, out, a, b, k) => {
+  out.p.lerpVectors(a.p, b.p, k);
+  out.q.copy(a.q).slerp(b.q, k);
+  out.grip = mix(a.grip, b.grip, k);
+  out.scale = mix(a.scale, b.scale, k);
+  return out;
+};
+var mirrorRotation = (THREE, q) => {
+  const m = new THREE.Matrix4().makeRotationFromQuaternion(q);
+  const e = m.elements;
+  for (const [i, j] of [[0, 1], [0, 2], [1, 0], [2, 0]]) e[j * 4 + i] = -e[j * 4 + i];
+  return new THREE.Quaternion().setFromRotationMatrix(m);
+};
+var mirrorQuaternion = (THREE, q) => {
+  const m = new THREE.Matrix4().makeRotationFromQuaternion(q);
+  const e = m.elements;
+  for (let column = 0; column < 3; column++) e[column * 4] = -e[column * 4];
+  for (let row = 0; row < 3; row++) e[8 + row] = -e[8 + row];
+  return new THREE.Quaternion().setFromRotationMatrix(m);
+};
+function createFirstPersonArms(THREE, options = {}) {
+  const colors = { ...FIRST_PERSON_COLORS, ...options.colors };
+  const rig = {
+    ...FIRST_PERSON_RIG,
+    ...options.rig,
+    radius: { ...FIRST_PERSON_RIG.radius, ...options.rig?.radius },
+    foot: options.rig?.foot ?? FIRST_PERSON_RIG.foot
+  };
+  const stances = { ...FIRST_PERSON_STANCES, ...options.stances };
+  const bob = { ...FIRST_PERSON_BOB, ...options.bob };
+  const blendSeconds = options.blend ?? DEFAULT_BLEND;
+  const clips = new Map((options.clips ?? []).map((clip) => [clip.id, clip]));
+  const root = new THREE.Group();
+  root.name = "first-person-arms";
+  root.userData.viewmodel = true;
+  const lit = (color) => new THREE.MeshLambertMaterial({ color, emissive: scaleHex(color, FILL) });
+  const materials = {
+    skin: lit(colors.skin),
+    sleeve: lit(colors.sleeve),
+    cuff: lit(colors.cuff),
+    trouser: lit(colors.trouser),
+    shoe: lit(colors.shoe),
+    sole: lit(scaleHex(colors.shoe, 0.55))
+  };
+  const geometries = [];
+  const Y = new THREE.Vector3(0, 1, 0);
+  const limb = (parent, wide, narrow, length, material) => {
+    const geometry = new THREE.CylinderGeometry(narrow, wide, length, 8, 1);
+    geometry.translate(0, length / 2, 0);
+    geometries.push(geometry);
+    const mesh = new THREE.Mesh(geometry, material);
+    mesh.frustumCulled = false;
+    mesh.userData.length = length;
+    parent.add(mesh);
+    return mesh;
+  };
+  const ball = (parent, radius, material) => {
+    const geometry = new THREE.SphereGeometry(radius, ELBOW_SEGMENTS, 6);
+    geometries.push(geometry);
+    const mesh = new THREE.Mesh(geometry, material);
+    mesh.frustumCulled = false;
+    parent.add(mesh);
+    return mesh;
+  };
+  const place = (segment, from, to) => {
+    const direction = new THREE.Vector3().subVectors(to, from);
+    const length = direction.length();
+    segment.position.copy(from);
+    if (length > 1e-6) segment.quaternion.setFromUnitVectors(Y, direction.divideScalar(length));
+    segment.scale.y = length / segment.userData.length;
+  };
+  const arms = {};
+  for (const side of ["R", "L"]) {
+    const sign = side === "R" ? 1 : -1;
+    const hand = createHandMesh(THREE, materials.skin);
+    const anchor = new THREE.Group();
+    anchor.name = `first-person-hand-${side}`;
+    const mirror = new THREE.Group();
+    mirror.scale.z = sign;
+    mirror.add(hand.root);
+    anchor.add(mirror);
+    root.add(anchor);
+    const upper = limb(root, rig.radius.shoulder, rig.radius.elbow, rig.upper, materials.sleeve);
+    const fore = limb(root, rig.radius.elbow, rig.radius.wrist, rig.fore, materials.sleeve);
+    const cuff = limb(root, rig.radius.cuff, rig.radius.cuff, 0.03, materials.cuff);
+    const elbow = ball(root, rig.radius.elbow * 1.02, materials.sleeve);
+    elbow.name = `first-person-elbow-${side}`;
+    arms[side] = { side, sign, hand, anchor, upper, fore, cuff, elbow, shown: newPose(THREE), from: newPose(THREE), mode: null, blend: 1, drawn: newPose(THREE), joints: { shoulder: new THREE.Vector3(), elbow: new THREE.Vector3(), wrist: new THREE.Vector3() } };
+  }
+  const leg = new THREE.Group();
+  leg.name = "first-person-leg";
+  leg.visible = false;
+  root.add(leg);
+  const thigh = limb(leg, 0.088, 0.068, rig.thigh, materials.trouser);
+  const shin = limb(leg, 0.068, 0.05, rig.shin, materials.trouser);
+  const knee = ball(leg, 0.07, materials.trouser);
+  const shoe = new THREE.Group();
+  const shoeBox = (sx, sy, sz, x, y, material) => {
+    const geometry = new THREE.BoxGeometry(sx, sy, sz);
+    geometries.push(geometry);
+    const mesh = new THREE.Mesh(geometry, material);
+    mesh.position.set(x, y, 0);
+    mesh.frustumCulled = false;
+    shoe.add(mesh);
+  };
+  shoeBox(0.27, 0.07, 0.1, 0.065, -0.05, materials.shoe);
+  shoeBox(0.27, 0.025, 0.104, 0.065, -0.095, materials.sole);
+  shoeBox(0.1, 0.05, 0.088, 0.17, -5e-3, materials.shoe);
+  leg.add(shoe);
+  const shoulderOf = (sign, out) => sign === -1 && rig.shoulderLeft ? out.set(...rig.shoulderLeft) : out.set(rig.shoulder[0] * sign, rig.shoulder[1], rig.shoulder[2]);
+  const poleOf = (sign) => sign === -1 && rig.elbowPoleLeft ? new THREE.Vector3(...rig.elbowPoleLeft) : new THREE.Vector3(rig.elbowPole[0] * sign, rig.elbowPole[1], rig.elbowPole[2]);
+  const kneePole = new THREE.Vector3(...rig.kneePole);
+  const hip = new THREE.Vector3(...rig.hip);
+  const euler = new THREE.Euler(0, 0, 0, "YZX");
+  const quaternionOf = (r) => new THREE.Quaternion().setFromEuler(euler.set(r[0], r[1], r[2], "YZX"));
+  const restPose = (rest, mirror, out) => {
+    out.p.set(...rest.p);
+    out.q.copy(quaternionOf(rest.r));
+    if (mirror) {
+      out.p.x = -out.p.x;
+      out.q.copy(mirrorQuaternion(THREE, out.q));
+    }
+    out.grip = rest.grip ?? 0;
+    out.scale = 1;
+    return out;
+  };
+  const DEFAULT_REST = { p: [0.17, -0.3, -0.3], r: [0, 1.5, 0], grip: 0.3 };
+  const stanceRest = (id, side, out) => {
+    const stance = stances[id] ?? stances.relaxed;
+    const right = stance?.R ?? DEFAULT_REST;
+    const left = stance?.L;
+    if (side === "R") return restPose(right, false, out);
+    return left && left !== "mirror" ? restPose(left, false, out) : restPose(right, true, out);
+  };
+  const camPosition = new THREE.Vector3();
+  const camQuaternion = new THREE.Quaternion();
+  const camInverse = new THREE.Quaternion();
+  const clamped = newPose(THREE);
+  const probeAt = new THREE.Vector3();
+  const probeForward = new THREE.Vector3();
+  const probeFingers = new THREE.Vector3();
+  let contact;
+  const keepOutside = (pose, reach) => {
+    if (!contact) return pose;
+    probeAt.set(pose.p.x, pose.p.y, 0).applyQuaternion(camQuaternion).add(camPosition);
+    probeForward.set(0, 0, -1).applyQuaternion(camQuaternion);
+    const distance2 = contact([probeAt.x, probeAt.y, probeAt.z], [probeForward.x, probeForward.y, probeForward.z], CONTACT_PROBE);
+    if (distance2 === null) return pose;
+    const limit = Math.max(CONTACT_MIN, distance2 - reach - CONTACT_MARGIN);
+    if (-pose.p.z <= limit) return pose;
+    copyPose(clamped, pose);
+    clamped.p.z = -limit;
+    return clamped;
+  };
+  const forward = (pose, length) => Math.max(CONTACT_PALM, -probeFingers.set(1, 0, 0).applyQuaternion(pose.q).z * length * pose.scale);
+  const handReach = (pose) => forward(pose, 0.085);
+  const camScale = new THREE.Vector3();
+  const toCamera = (target, grip, scale, out) => {
+    out.p.set(...target.position).sub(camPosition).applyQuaternion(camInverse);
+    out.q.set(...target.quaternion).premultiply(camInverse);
+    out.grip = grip;
+    out.scale = scale;
+    return out;
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  let run = null;
+  const emit = (event) => {
+    for (const listener of listeners) listener(event);
+  };
+  const fire = (clip, from, to) => {
+    for (const event of clipEventsBetween2(clip, from, to)) emit({ ...event, clip: clip.id });
+  };
+  let stanceId = "relaxed";
+  let phase = 0;
+  let swing = 0;
+  let sink = 0;
+  let first = true;
+  const bobOffset = new THREE.Vector3();
+  const desired = newPose(THREE);
+  const channelPose = newPose(THREE);
+  const mixed = newPose(THREE);
+  let indexCurl;
+  const bone = createTwoBone(THREE);
+  const shoulder = new THREE.Vector3();
+  const wristAt = new THREE.Vector3();
+  const palmAt = new THREE.Vector3();
+  const fingers = new THREE.Vector3();
+  const towards = new THREE.Vector3();
+  const fromChannel = (channel, side, base, out) => {
+    out.p.set(...channel.p);
+    out.q.copy(quaternionOf(channel.r));
+    if (channel.mirror && side === "L") {
+      out.p.x = -out.p.x;
+      out.q.copy(mirrorQuaternion(THREE, out.q));
+    }
+    out.grip = channel.grip ?? base.grip;
+    out.scale = base.scale;
+    return out;
+  };
+  const drawArm = (arm, pose) => {
+    copyPose(arm.drawn, pose);
+    const scale = pose.scale;
+    fingers.set(1, 0, 0).applyQuaternion(pose.q);
+    wristAt.copy(pose.p).addScaledVector(fingers, -rig.wrist * scale);
+    shoulderOf(arm.sign, shoulder).add(bobOffset);
+    const excess = shoulder.distanceTo(wristAt) - (rig.upper + rig.fore) * REACH_SLACK;
+    if (excess > 0 && rig.reachShift > 0) shoulder.addScaledVector(towards.subVectors(wristAt, shoulder).normalize(), Math.min(excess, rig.reachShift));
+    solveTwoBone(shoulder, wristAt, rig.upper, rig.fore, poleOf(arm.sign), bone);
+    palmAt.copy(bone.end).addScaledVector(fingers, rig.wrist * scale);
+    arm.drawn.p.copy(palmAt);
+    arm.anchor.position.copy(palmAt);
+    arm.anchor.quaternion.copy(pose.q);
+    arm.anchor.scale.setScalar(scale);
+    arm.hand.setGrip(pose.grip);
+    arm.hand.setIndex(arm.side === "R" ? indexCurl : void 0);
+    arm.joints.shoulder.copy(shoulder);
+    arm.joints.elbow.copy(bone.joint);
+    arm.joints.wrist.copy(bone.end);
+    place(arm.upper, shoulder, bone.joint);
+    place(arm.fore, bone.joint, bone.end);
+    arm.elbow.position.copy(bone.joint);
+    const toWrist = new THREE.Vector3().subVectors(bone.end, bone.joint).normalize();
+    place(arm.cuff, new THREE.Vector3().copy(bone.end).addScaledVector(toWrist, -0.02), new THREE.Vector3().copy(bone.end).addScaledVector(toWrist, 0.012));
+  };
+  const footPose = newPose(THREE);
+  const footRest = newPose(THREE);
+  const ankle = new THREE.Vector3();
+  const hipMirrored = new THREE.Vector3(-hip.x, hip.y, hip.z);
+  const kneePoleMirrored = new THREE.Vector3(-kneePole.x, kneePole.y, kneePole.z);
+  const drawLeg = (pose, left) => {
+    const origin = left ? hipMirrored : hip;
+    solveTwoBone(origin, pose.p, rig.thigh, rig.shin, left ? kneePoleMirrored : kneePole, bone);
+    ankle.copy(bone.end);
+    place(thigh, origin, bone.joint);
+    place(shin, bone.joint, ankle);
+    knee.position.copy(bone.joint);
+    shoe.position.copy(ankle);
+    shoe.quaternion.copy(pose.q);
+  };
+  const modeOf = (key, arm) => {
+    if (arm.mode === key) return;
+    copyPose(arm.from, arm.shown);
+    arm.mode = key;
+    arm.blend = first ? 1 : 0;
+  };
+  return {
+    root,
+    get playing() {
+      return run ? run.clip.id : null;
+    },
+    get stance() {
+      return stanceId;
+    },
+    play(id, options2) {
+      const clip = clips.get(id);
+      if (!clip) return false;
+      run = { clip, time: 0, left: options2?.leg === "left" };
+      fire(clip, -1e-9, 0);
+      return true;
+    },
+    stop() {
+      run = null;
+    },
+    update(dt, state) {
+      const { camera } = state;
+      contact = state.contact;
+      camera.updateWorldMatrix(true, false);
+      camera.matrixWorld.decompose(camPosition, camQuaternion, camScale);
+      camInverse.copy(camQuaternion).invert();
+      root.position.copy(camPosition);
+      root.quaternion.copy(camQuaternion);
+      root.updateMatrixWorld(true);
+      const speed = state.speed ?? 0;
+      const target = Math.min(1, speed / bob.fullSpeed) * (state.running ? bob.run : 1);
+      swing += (target - swing) * Math.min(1, dt * 8);
+      phase += dt * speed * bob.frequency;
+      sink += ((state.crouch ? 1 : 0) - sink) * Math.min(1, dt * 8);
+      bobOffset.set(Math.sin(phase) * bob.x * swing, Math.sin(phase * 2) * bob.y * swing - bob.crouch * sink, 0);
+      stanceId = state.stance ?? "relaxed";
+      const stance = stances[stanceId] ?? stances.relaxed;
+      const targets = state.targets ?? null;
+      if (run) {
+        const from = run.time;
+        run.time += dt;
+        fire(run.clip, from, Math.min(run.time, run.clip.duration));
+      }
+      const sample = run ? sampleFirstPersonClip(run.clip, Math.min(run.time, run.clip.duration)) : null;
+      for (const side of ["R", "L"]) {
+        const arm = arms[side];
+        const target2 = targets?.[side];
+        let mode;
+        if (stance?.follow && target2) {
+          mode = "target";
+          toCamera(target2, (side === "L" ? targets?.gripL : void 0) ?? targets?.grip ?? 1, targets?.scale ?? 1, desired);
+        } else {
+          mode = `rest:${stance?.follow ? stance.fallback ?? "relaxed" : stanceId}`;
+          stanceRest(stance?.follow ? stance.fallback ?? "relaxed" : stanceId, side, desired);
+          desired.p.add(bobOffset);
+        }
+        modeOf(mode, arm);
+        if (side === "R") indexCurl = mode === "target" ? targets?.fingers?.index : void 0;
+        arm.blend = blendSeconds <= 0 ? 1 : Math.min(1, arm.blend + dt / blendSeconds);
+        if (arm.blend >= 1) copyPose(arm.shown, desired);
+        else mixPose(THREE, arm.shown, arm.from, desired, ease(arm.blend));
+        const channel = sample?.[side];
+        if (channel && channel.w > 0) {
+          fromChannel(channel, side, arm.shown, channelPose);
+          mixPose(THREE, mixed, arm.shown, channelPose, channel.w);
+          drawArm(arm, mode === "target" ? mixed : keepOutside(mixed, handReach(mixed)));
+        } else drawArm(arm, mode === "target" ? arm.shown : keepOutside(arm.shown, handReach(arm.shown)));
+      }
+      const foot = sample?.F;
+      leg.visible = !!foot && foot.w > FOOT_SHOWN;
+      if (foot && leg.visible) {
+        restPose(rig.foot, false, footRest);
+        fromChannel(foot, "R", footRest, footPose);
+        mixPose(THREE, mixed, footRest, footPose, foot.w);
+        copyPose(footPose, mixed);
+        if (run?.left) {
+          footPose.p.x = -footPose.p.x;
+          footPose.q.copy(mirrorRotation(THREE, footPose.q));
+        }
+        drawLeg(contact ? keepOutside(footPose, forward(footPose, FOOT_LENGTH)) : footPose, run?.left ?? false);
+      }
+      if (run && run.time >= run.clip.duration) run = null;
+      first = false;
+    },
+    on(_type, listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    joints(side) {
+      const { shoulder: shoulder2, elbow, wrist } = arms[side].joints;
+      return { shoulder: shoulder2.clone(), elbow: elbow.clone(), wrist: wrist.clone() };
+    },
+    handPose(side) {
+      const pose = arms[side].drawn;
+      return { position: pose.p.clone(), quaternion: pose.q.clone(), grip: pose.grip };
+    },
+    dispose() {
+      run = null;
+      listeners.clear();
+      for (const arm of Object.values(arms)) arm.hand.dispose();
+      for (const geometry of geometries) geometry.dispose();
+      for (const material of Object.values(materials)) material.dispose();
+      root.removeFromParent();
+    }
+  };
+}
+
+// src/player/room-avatar.ts
+var impactOf = (clip) => clip.events?.find((event) => event.type === "impact")?.t ?? null;
+var toRoomAvatar = (avatar, options = {}) => {
+  const arms = options.firstPerson === false ? null : createFirstPersonArms(avatar.three, {
+    colors: { skin: avatar.colors.skin, sleeve: avatar.colors.longSleeves ? avatar.colors.shirt : avatar.colors.skin, trouser: avatar.colors.trousers, shoe: avatar.colors.shoes, ...options.firstPerson?.colors },
+    clips: options.firstPersonClips ?? FIRST_PERSON_CLIPS,
+    ...options.firstPerson
+  });
+  const strikes = new Map((options.strikeClips ?? ATTACK_CLIPS).map((clip) => [clip.id, clip]));
+  const mirrored = /* @__PURE__ */ new Map();
+  const leftOf = (clip) => {
+    let found = mirrored.get(clip.id);
+    if (!found) mirrored.set(clip.id, found = mirrorPoseClip(clip, `${clip.id}_left`));
+    return found;
+  };
+  return {
+    root: avatar.root,
+    avatar,
+    arms,
+    ...arms ? { firstPerson: { root: arms.root, update: (dt, state) => arms.update(dt, state) } } : {},
+    update: (dt, state) => avatar.update(dt, { speed: state.speed, running: state.running, crouch: state.crouch, down: state.down, armed: state.armed, pitch: -state.pitch }),
+    hand: (side) => avatar.hand(side),
+    strike: (clipId, strikeOptions) => {
+      const clip = strikes.get(clipId);
+      if (!clip) return null;
+      const left = strikeOptions?.leg === "left";
+      avatar.play(left ? leftOf(clip) : clip);
+      arms?.play(clipId, left ? { leg: "left" } : void 0);
+      return impactOf(clip);
+    }
+  };
+};
+
+// src/player/test-module.ts
+import { POSE_CLIPS as POSE_CLIPS2, POSE_CLIP_LOCALES } from "@adatechnology/game-characters";
+
+// src/player/test-text.ts
+var AVATAR_TEXT = {
+  en: {
+    group: "Avatar",
+    name: "Player body",
+    actions: {
+      camera_first: "Camera: 1st person",
+      camera_third: "Camera: 3rd person",
+      crouch: "Crouch",
+      stand: "Stand up",
+      fall: "Fall down",
+      get_up: "Get up",
+      armed_on: "Armed: on",
+      armed_off: "Armed: off",
+      stop_clip: "Stop clip"
+    },
+    play: "Play",
+    metrics: { camera: "Camera", clip: "Clip playing", last_event: "Last clip event", state: "State", joints: "Joints" },
+    none: "none"
+  },
+  "pt-BR": {
+    group: "Avatar",
+    name: "Corpo do jogador",
+    actions: {
+      camera_first: "C\xE2mera: 1\xAA pessoa",
+      camera_third: "C\xE2mera: 3\xAA pessoa",
+      crouch: "Agachar",
+      stand: "Levantar",
+      fall: "Cair",
+      get_up: "Levantar do ch\xE3o",
+      armed_on: "Armado: ligado",
+      armed_off: "Armado: desligado",
+      stop_clip: "Parar clipe"
+    },
+    play: "Tocar",
+    metrics: { camera: "C\xE2mera", clip: "Clipe tocando", last_event: "\xDAltimo evento do clipe", state: "Estado", joints: "Juntas" },
+    none: "nenhum"
+  }
+};
+
+// src/player/test-module.ts
+var AVATAR_AREA_ID = "avatar_area";
+var round = (value) => (Math.round(value * 100) / 100).toString();
+function createAvatarTestModule(options) {
+  const clips = options.clips ?? POSE_CLIPS2;
+  const textOf = (locale) => AVATAR_TEXT[locale ?? options.locale ?? "pt-BR"] ?? AVATAR_TEXT["pt-BR"];
+  const phaseLabel = (label, locale) => {
+    const id = locale ?? options.locale ?? "pt-BR";
+    const table = { ...POSE_CLIP_LOCALES[id] ?? POSE_CLIP_LOCALES["pt-BR"], ...options.clipLocales?.[id] ?? options.clipLocales?.["pt-BR"] };
+    return typeof label === "string" ? table[label] ?? label : "";
+  };
+  const state = { crouch: false, down: false, armed: null };
+  let host = null;
+  let lastEvent = "";
+  const log = (action, extra = {}) => {
+    const entry = { type: "avatar", action, ...extra };
+    host?.log(JSON.stringify(entry), entry);
+  };
+  const push = (action, patch, extra = {}) => {
+    Object.assign(state, patch);
+    options.state?.set(patch);
+    log(action, { crouch: state.crouch, down: state.down, armed: state.armed, ...extra });
+  };
+  const setCamera = (mode) => {
+    options.camera?.set(mode);
+    log(`camera_${mode}`, { mode: options.camera?.mode() ?? null });
+  };
+  const onChange = (change) => {
+    if (change.kind !== "action") return;
+    switch (change.id) {
+      case "camera_first":
+        return setCamera("first");
+      case "camera_third":
+        return setCamera("third");
+      case "crouch":
+        return push("crouch", { crouch: true });
+      case "stand":
+        return push("stand", { crouch: false });
+      case "fall":
+        return push("fall", { down: true });
+      case "get_up":
+        return push("get_up", { down: false });
+      case "armed_on":
+        return push("armed_on", { armed: true });
+      case "armed_off":
+        return push("armed_off", { armed: false });
+      case "stop_clip":
+        options.avatar.stop();
+        return log("stop_clip", { playing: options.avatar.playing });
+      default: {
+        const clip = clips.find((item) => `play_${item.id}` === change.id);
+        if (!clip) return;
+        options.avatar.play(clip);
+        log("play_clip", { clip: clip.id, duration: clip.duration, loop: clip.loop ?? false, channels: clip.channels ?? "full" });
+      }
+    }
+  };
+  const joints = () => {
+    const rig = options.avatar.rig;
+    const [armA, armB] = rig.arms;
+    const [legA, legB] = rig.legs;
+    return `arms ${round(armA.g.rotation.x)}/${round(armB.g.rotation.x)} elbows ${round(armA.el.rotation.x)}/${round(armB.el.rotation.x)} legs ${round(legA.g.rotation.x)}/${round(legB.g.rotation.x)} knees ${round(legA.kn.rotation.x)}/${round(legB.kn.rotation.x)} lean ${round(rig.upper.rotation.x)}`;
+  };
+  return {
+    id: AVATAR_AREA_ID,
+    name: textOf().name,
+    group: textOf().group,
+    state,
+    items: () => [],
+    area: () => ({ placements: [], view: { eye: [0, 1.7, 6], target: [0, 1.2, 0] } }),
+    controls: (locale) => {
+      const text = textOf(locale);
+      const action = (id, name, hint) => ({ kind: "action", id, name, ...hint ? { hint } : {} });
+      return [
+        action("camera_first", text.actions.camera_first),
+        action("camera_third", text.actions.camera_third),
+        action("crouch", text.actions.crouch),
+        action("stand", text.actions.stand),
+        action("fall", text.actions.fall),
+        action("get_up", text.actions.get_up),
+        action("armed_on", text.actions.armed_on),
+        action("armed_off", text.actions.armed_off),
+        ...clips.map((clip) => action(`play_${clip.id}`, `${text.play}: ${clip.id}`)),
+        action("stop_clip", text.actions.stop_clip)
+      ];
+    },
+    metrics: (locale) => {
+      const text = textOf(locale);
+      return [
+        { id: "camera", name: text.metrics.camera, read: () => options.camera?.mode() ?? text.none },
+        { id: "clip", name: text.metrics.clip, read: () => options.avatar.playing ?? text.none },
+        { id: "last_event", name: text.metrics.last_event, read: () => lastEvent || text.none },
+        { id: "state", name: text.metrics.state, read: () => `${state.crouch ? "crouch " : ""}${state.down ? "down " : ""}${state.armed === null ? "" : state.armed ? "armed" : "unarmed"}`.trim() || text.none },
+        { id: "joints", name: text.metrics.joints, read: joints }
+      ];
+    },
+    attach(lent) {
+      host = lent;
+      const stopChange = lent.bench?.onChange(onChange);
+      const stopEvents = options.avatar.on("event", (event) => {
+        lastEvent = `${event.clip} ${event.type} ${round(event.t)}s${event.data && "label" in event.data ? ` ${phaseLabel(event.data.label)}` : ""}`;
+        log("clip_event", { clip: event.clip, event: event.type, t: event.t, data: event.data ?? null });
+        if (event.type === "impact") log("impact", { clip: event.clip, t: event.t, kind: event.data?.kind ?? null });
+      });
+      return () => {
+        stopChange?.();
+        stopEvents();
+        host = null;
+      };
+    }
+  };
+}
 export {
+  AVATAR_AREA_ID,
   BAKE_NEUTRAL_POSE,
   BODY_CHUNK,
   BODY_MATERIAL_DEF,
@@ -4105,6 +5209,10 @@ export {
   CHARACTER_SOUND_BANK,
   EXTRAS,
   FACE_FEATURES,
+  FIRST_PERSON_BOB,
+  FIRST_PERSON_COLORS,
+  FIRST_PERSON_RIG,
+  FIRST_PERSON_STANCES,
   HAND_ITEMS,
   HATS,
   HIT_PRESETS,
@@ -4126,6 +5234,7 @@ export {
   blobRadii,
   bloodLookOfAge,
   buildInstancedBody,
+  createAvatarTestModule,
   createBestBuilder,
   createBodyBatch,
   createBodyChunk,
@@ -4133,12 +5242,14 @@ export {
   createCharacterSound,
   createCharactersTestModule,
   createEye,
+  createFirstPersonArms,
   createFluidsBridge,
   createFlyingLimbs,
   createFlyingPieces,
   createGlowTexture,
   createPendulum,
   createPersonBuilder,
+  createPlayerAvatar,
   createRigAnimator,
   createVariantBatches,
   createWoundMaterials,
@@ -4153,8 +5264,10 @@ export {
   makeStump,
   registerBodyMaterial,
   ringWound,
+  solveTwoBone,
   starGeometry,
   stepPendulum,
+  toRoomAvatar,
   woundBodyOf,
   woundDecal
 };