@adatechnology/game-characters-three 0.6.0 → 0.7.1

package/dist/index.global.js

@@ -1687,6 +1687,90 @@ var GameCharactersThree = (() => {
     shims.add(result);
     return result;
   }
+  var isTexture = (v) => !!v && typeof v === "object" && v.isTexture === true;
+  function texturesOf(material, out) {
+    for (const value of Object.values(material)) if (isTexture(value)) out.add(value);
+    const uniforms = material.uniforms;
+    if (uniforms) {
+      for (const u of Object.values(uniforms)) if (isTexture(u?.value)) out.add(u.value);
+    }
+  }
+  function collect(roots) {
+    const geometries = /* @__PURE__ */ new Set();
+    const materials = /* @__PURE__ */ new Set();
+    const textures = /* @__PURE__ */ new Set();
+    const skeletons = /* @__PURE__ */ new Set();
+    for (const root of roots) {
+      root.traverse((object2) => {
+        const o = object2;
+        if (o.geometry && typeof o.geometry.dispose === "function") geometries.add(o.geometry);
+        if (o.skeleton && typeof o.skeleton.dispose === "function") skeletons.add(o.skeleton);
+        const list2 = Array.isArray(o.material) ? o.material : o.material ? [o.material] : [];
+        for (const m of list2) {
+          if (!m || typeof m.dispose !== "function") continue;
+          materials.add(m);
+          texturesOf(m, textures);
+        }
+      });
+    }
+    return { geometries, materials, textures, skeletons };
+  }
+  var marked = /* @__PURE__ */ new WeakSet();
+  var shared = (r) => r.userData?.shared === true || marked.has(r);
+  function releaseObject3D(roots, options = {}) {
+    const list2 = Array.isArray(roots) ? roots : [roots];
+    const report2 = { geometries: 0, materials: 0, textures: 0 };
+    if (list2.length === 0) return report2;
+    const found = collect(list2);
+    const keepRoots = options.keep === void 0 ? [] : Array.isArray(options.keep) ? options.keep : [options.keep];
+    const releasing = new Set(list2);
+    for (const keep of keepRoots) {
+      const walk = (o) => {
+        if (releasing.has(o)) return;
+        const owner = o;
+        if (owner.geometry) found.geometries.delete(owner.geometry);
+        if (owner.skeleton) found.skeletons.delete(owner.skeleton);
+        const mats = Array.isArray(owner.material) ? owner.material : owner.material ? [owner.material] : [];
+        for (const m of mats) {
+          if (!m) continue;
+          found.materials.delete(m);
+          const t = /* @__PURE__ */ new Set();
+          texturesOf(m, t);
+          for (const x of t) found.textures.delete(x);
+        }
+        for (const c of o.children) walk(c);
+      };
+      walk(keep);
+    }
+    for (const g of found.geometries) {
+      if (shared(g)) continue;
+      g.dispose();
+      report2.geometries++;
+    }
+    for (const m of found.materials) {
+      if (shared(m)) continue;
+      m.dispose();
+      report2.materials++;
+    }
+    for (const t of found.textures) {
+      if (shared(t)) continue;
+      t.dispose();
+      report2.textures++;
+    }
+    for (const s of found.skeletons) s.dispose();
+    return report2;
+  }
+  function discardObject3D(objects, options = {}) {
+    const list2 = Array.isArray(objects) ? objects : [objects];
+    const keep = options.keep === void 0 ? [] : Array.isArray(options.keep) ? [...options.keep] : [options.keep];
+    for (const object2 of list2) {
+      let top = object2;
+      while (top.parent) top = top.parent;
+      object2.removeFromParent();
+      if (top !== object2 && !keep.includes(top)) keep.push(top);
+    }
+    return releaseObject3D(list2, { keep });
+  }
 
   // ../game-contracts/dist/index.js
   var DEFAULT_BLAST_SHOVE = { coupling: 0.02, maxSpeed: 20, lift: 0.3, minSpeed: 0.3, falloffPower: 2 };
@@ -5221,7 +5305,7 @@ var GameCharactersThree = (() => {
         });
       }
       const neckLen = 0.14 + Math.max(0, P.neck);
-      if (!cut.head) add(U, CYL(0.058, 0.068, neckLen, SEG), skinM, 0, 1.63 + Math.max(0, P.neck) / 2, 0);
+      const neck = cut.head ? void 0 : add(U, CYL(0.058, 0.068, neckLen, SEG), skinM, 0, 1.63 + Math.max(0, P.neck) / 2, 0);
       const headG = new THREE.Group();
       headG.position.set(0, 1.64 + P.neck, P.headFwd || 0);
       headG.rotation.x = P.headX;
@@ -5428,6 +5512,7 @@ var GameCharactersThree = (() => {
         if (o.userData.flap) flaps.push(o);
       });
       const rig = { flaps, dangles: arms.filter((a) => a.el.userData.dangle), type: spec.type || "Lento", fig, upper, headG, arms, legs, P, ph: spec.phase ?? options.random() * 6, dropBase: fig.position.y, leanBase: P.lean, hxBase: P.headX };
+      if (neck) Object.defineProperty(rig, "neck", { value: neck });
       if (spec.lying) {
         root.rotation.x = -PI / 2;
         root.position.set(0, 0.16 * P.s, 0.9 * P.s);
@@ -5438,8 +5523,8 @@ var GameCharactersThree = (() => {
       root.userData.rig = rig;
       return root;
     }
-    const marked = (...args) => markKitOrigin(build(...args), { owner: "game-characters-three", kind: "person" });
-    return { build: marked, TYPES, setLOD(k) {
+    const marked2 = (...args) => markKitOrigin(build(...args), { owner: "game-characters-three", kind: "person" });
+    return { build: marked2, TYPES, setLOD(k) {
       LK = k;
       SEG = Math.max(5, Math.round(16 * k));
     }, topM: () => topM_ref };
@@ -6907,7 +6992,10 @@ var GameCharactersThree = (() => {
     const quaternion = new three.Quaternion();
     const euler = new three.Euler();
     const trim = () => {
-      while (pieces.length > max) pieces.shift()?.object.removeFromParent();
+      while (pieces.length > max) {
+        const piece = pieces.shift();
+        if (piece) discardObject3D(piece.object);
+      }
     };
     const add = (object2, velocity, spin, tag) => {
       const piece = { object: object2, velocity, spin, rest: false, ...tag ? { tag } : {} };
@@ -6956,7 +7044,7 @@ var GameCharactersThree = (() => {
         }
       },
       clear() {
-        pieces.splice(0).forEach((piece) => piece.object.removeFromParent());
+        discardObject3D(pieces.splice(0).map((piece) => piece.object));
       }
     };
   };
@@ -8165,7 +8253,8 @@ var GameCharactersThree = (() => {
     const makeKit = () => options.createKit ? options.createKit({ penetration: settings.penetration, deathRule: settings.deathRule }) : createCharacters({ ...options.packs ? { packs: options.packs } : {}, penetration: settings.penetration, damage: { deathRule: settings.deathRule } });
     let kit = makeKit();
     let undead = options.createUndead ? options.createUndead(kit) : null;
-    const random = createRng(options.seed ?? 1);
+    let stream = createRng(options.seed ?? 1);
+    const random = () => stream();
     let seedCounter = 100;
     let host = null;
     let three = null;
@@ -8545,6 +8634,14 @@ var GameCharactersThree = (() => {
         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 stopReset = lent.onReset?.(() => {
+          stream = createRng(options.seed ?? 1);
+          seedCounter = 100;
+          time = 0;
+          selected = null;
+          lastCrossed = 0;
+          lastEnergy = 1;
+        });
         const stopEvents = lent.on((event) => {
           if (event.type !== "explosion") return;
           for (const entry of entries.values()) {
@@ -8558,6 +8655,8 @@ var GameCharactersThree = (() => {
           time += dt;
           for (const [id, entry] of entries) {
             if (!entry.root.parent) {
+              if (entry.body) wounds?.untrack(entry.body);
+              if (selected === entry) selected = null;
               entries.delete(id);
               continue;
             }
@@ -8569,6 +8668,7 @@ var GameCharactersThree = (() => {
         });
         return () => {
           stopChange?.();
+          stopReset?.();
           stopEvents();
           stopFrame();
           clearOverlays();
@@ -8678,8 +8778,22 @@ var GameCharactersThree = (() => {
     slack: 0.96,
     /** Where the elbow points: down and out from the body, a little back (body space, x outward). */
     elbowPole: [0.55, -1, -0.25],
+    /** The support arm's elbow: under the gun, hardly out of the body (the first-person arms' `elbowPoleLeft`), so the forearm meets the handguard nearer the aim's line. */
+    elbowPoleSupport: [0.1, -1, -0.2],
     /** From the wrist joint to the middle of the palm, metres of the body. */
-    palm: 0.042
+    palm: 0.042,
+    /** In a view the elbow keeps at least this interior bend where a hand is out of reach, right then left (the first-person arms' numbers). */
+    viewBend: [1.35, 0.95],
+    /** In a view a hand stays this far before a surface, metres. */
+    contactMargin: 5e-3,
+    /** In a view a hand is never nearer than this to the eye, metres. */
+    contactNearest: 0.12,
+    /** How far in front of the eye a surface is looked for, metres. */
+    contactProbe: 1.4,
+    /** How far a hand reaches forward of its middle at least (the thickness of the palm), and per metre of fingers pointing ahead. */
+    contactPalm: 0.03,
+    /** From the middle of the palm to the fingertips. */
+    contactFingers: 0.085
   };
   var createArmReach = (THREE, rig, hands) => {
     const arms = {
@@ -8700,11 +8814,17 @@ var GameCharactersThree = (() => {
     const v = { shoulder: new THREE.Vector3(), elbow: new THREE.Vector3(), wrist: new THREE.Vector3(), palm: new THREE.Vector3(), target: new THREE.Vector3(), pole: new THREE.Vector3(), a: new THREE.Vector3(), b: new THREE.Vector3(), c: new THREE.Vector3() };
     const q = { hand: new THREE.Quaternion(), parent: new THREE.Quaternion(), body: new THREE.Quaternion(), local: new THREE.Quaternion(), swing: new THREE.Quaternion(), twist: new THREE.Quaternion(), rest: new THREE.Quaternion() };
     const basis = new THREE.Matrix4();
+    const camera = { position: new THREE.Vector3(), quaternion: new THREE.Quaternion(), inverse: new THREE.Quaternion(), probe: new THREE.Vector3(), forward: new THREE.Vector3(), fingers: new THREE.Vector3(), hand: new THREE.Quaternion() };
+    let bendLimit = null;
     const yAxis = new THREE.Vector3(0, 1, 0);
     const lengthsOf = (arm) => {
       const scale = arm.g.getWorldScale(v.a).y;
       return { upper: arm.el.position.length() * scale, fore: arm.hand.position.length() * scale, palm: ARM_REACH.palm * scale };
     };
+    const limitOf = (side, upperLength, fore) => {
+      if (!bendLimit) return (upperLength + fore) * ARM_REACH.slack;
+      return Math.sqrt(upperLength * upperLength + fore * fore + 2 * upperLength * fore * Math.cos(bendLimit[side === "R" ? 0 : 1]));
+    };
     const wristOf = (side, pose, palm) => {
       q.hand.set(...pose.quaternion).multiply(handBasis[side]);
       v.palm.set(...pose.position);
@@ -8713,14 +8833,14 @@ var GameCharactersThree = (() => {
     const turnChest = (pose) => {
       const { upper: up, fore, palm } = lengthsOf(arms.L);
       wristOf("L", pose, palm);
-      const excess = arms.L.g.getWorldPosition(v.shoulder).distanceTo(v.wrist) - (up + fore) * ARM_REACH.slack;
+      const excess = arms.L.g.getWorldPosition(v.shoulder).distanceTo(v.wrist) - limitOf("L", up, fore);
       if (excess <= 0) return;
       const chestRadius = Math.hypot(arms.L.g.position.x, arms.L.g.position.z) * arms.L.g.getWorldScale(v.a).y;
       upper.rotation.y -= Math.min(ARM_REACH.chestTurn, excess / Math.max(0.05, chestRadius));
       upper.updateMatrixWorld(true);
     };
-    const protract = (arm, length) => {
-      const excess = arm.g.getWorldPosition(v.shoulder).distanceTo(v.wrist) - length * ARM_REACH.slack;
+    const protract = (arm, limit) => {
+      const excess = arm.g.getWorldPosition(v.shoulder).distanceTo(v.wrist) - limit;
       if (excess <= 0) return;
       const parent = arm.g.parent;
       v.b.copy(v.wrist).sub(v.shoulder).normalize().multiplyScalar(Math.min(excess, ARM_REACH.protraction)).add(v.shoulder);
@@ -8741,11 +8861,13 @@ var GameCharactersThree = (() => {
       const arm = arms[side];
       const { upper: up, fore, palm } = lengthsOf(arm);
       wristOf(side, pose, palm);
-      protract(arm, up + fore);
+      protract(arm, limitOf(side, up, fore));
       arm.g.getWorldPosition(v.shoulder);
       upper.getWorldQuaternion(q.body);
-      v.pole.set(ARM_REACH.elbowPole[0] * arm.outward, ARM_REACH.elbowPole[1], ARM_REACH.elbowPole[2]).applyQuaternion(q.body);
-      const most = Math.sqrt(up * up + fore * fore + 2 * up * fore * Math.cos(ARM_REACH.elbowMin));
+      const pole = side === "L" ? ARM_REACH.elbowPoleSupport : ARM_REACH.elbowPole;
+      v.pole.set(pole[0] * arm.outward, pole[1], pole[2]).applyQuaternion(q.body);
+      const lockLimit = Math.sqrt(up * up + fore * fore + 2 * up * fore * Math.cos(ARM_REACH.elbowMin));
+      const most = bendLimit ? Math.min(lockLimit, limitOf(side, up, fore)) : lockLimit;
       const least = Math.sqrt(up * up + fore * fore + 2 * up * fore * Math.cos(ARM_REACH.elbowMax));
       const line = v.c.copy(v.wrist).sub(v.shoulder);
       const distance3 = Math.min(most, Math.max(least, line.length()));
@@ -8770,6 +8892,20 @@ var GameCharactersThree = (() => {
       arm.el.getWorldQuaternion(q.parent);
       arm.hand.quaternion.copy(limitWrist(q.local.copy(q.parent.invert()).multiply(q.hand)));
     };
+    const keepOutside = (pose, outside) => {
+      const place = v.a.set(...pose.position).sub(camera.position).applyQuaternion(camera.inverse);
+      camera.probe.set(place.x, place.y, 0).applyQuaternion(camera.quaternion).add(camera.position);
+      camera.forward.set(0, 0, -1).applyQuaternion(camera.quaternion);
+      const distance3 = outside.contact([camera.probe.x, camera.probe.y, camera.probe.z], [camera.forward.x, camera.forward.y, camera.forward.z], ARM_REACH.contactProbe);
+      if (distance3 === null) return pose;
+      camera.hand.set(...pose.quaternion).premultiply(camera.inverse);
+      const ahead = Math.max(ARM_REACH.contactPalm, -camera.fingers.set(1, 0, 0).applyQuaternion(camera.hand).z * ARM_REACH.contactFingers);
+      const limit = Math.max(outside.nearest ?? ARM_REACH.contactNearest, distance3 - ahead - (outside.margin ?? ARM_REACH.contactMargin));
+      if (-place.z <= limit) return pose;
+      place.z = -limit;
+      place.applyQuaternion(camera.quaternion).add(camera.position);
+      return { ...pose, position: [place.x, place.y, place.z] };
+    };
     const save = () => {
       saved.twist = upper.rotation.y;
       for (const side of ["R", "L"]) {
@@ -8782,14 +8918,24 @@ var GameCharactersThree = (() => {
       }
     };
     return {
-      apply(targets) {
+      apply(targets, view) {
         if (!targets || !targets.R && !targets.L) return;
         save();
         applied = true;
         upper.updateWorldMatrix(true, true);
-        if (targets.L && targets.R) turnChest(targets.L);
-        if (targets.R) reach("R", targets.R);
-        if (targets.L) reach("L", targets.L);
+        let { R, L } = targets;
+        bendLimit = view ? view.reachBend ?? ARM_REACH.viewBend : null;
+        if (view?.keepOutside) {
+          view.camera.updateWorldMatrix(true, false);
+          view.camera.matrixWorld.decompose(camera.position, camera.quaternion, v.a);
+          camera.inverse.copy(camera.quaternion).invert();
+          if (R) R = keepOutside(R, view.keepOutside);
+          if (L) L = keepOutside(L, view.keepOutside);
+        }
+        if (L && R) turnChest(L);
+        if (R) reach("R", R);
+        if (L) reach("L", L);
+        bendLimit = null;
       },
       restore() {
         if (!applied) return;
@@ -8807,12 +8953,56 @@ var GameCharactersThree = (() => {
     };
   };
 
+  // src/player/head-hiding.ts
+  var isDrawable = (object2) => {
+    const flagged = object2;
+    return Boolean(flagged.isMesh || flagged.isSprite || flagged.isPoints);
+  };
+  var createHeadHider = (roots) => {
+    let isHiding = false;
+    let viewCamera = null;
+    const drawables = [];
+    for (const root of roots) root.traverse((object2) => isDrawable(object2) && drawables.push(object2));
+    for (const drawable of drawables) {
+      const previousBefore = drawable.onBeforeRender;
+      const previousAfter = drawable.onAfterRender;
+      let saved = [];
+      drawable.onBeforeRender = (renderer, scene2, camera, geometry, material, group) => {
+        previousBefore.call(drawable, renderer, scene2, camera, geometry, material, group);
+        if (!isHiding || camera !== viewCamera) return;
+        const drawn = Array.isArray(drawable.material) ? drawable.material : [material];
+        saved = drawn.map((entry) => ({ material: entry, colorWrite: entry.colorWrite, depthWrite: entry.depthWrite }));
+        for (const entry of drawn) {
+          entry.colorWrite = false;
+          entry.depthWrite = false;
+        }
+      };
+      drawable.onAfterRender = (renderer, scene2, camera, geometry, material, group) => {
+        previousAfter.call(drawable, renderer, scene2, camera, geometry, material, group);
+        for (const flags of saved) {
+          flags.material.colorWrite = flags.colorWrite;
+          flags.material.depthWrite = flags.depthWrite;
+        }
+        saved = [];
+      };
+    }
+    return {
+      setView(mode, camera) {
+        isHiding = mode === "first" && camera !== null;
+        viewCamera = camera;
+      }
+    };
+  };
+
   // src/player/avatar.ts
   var TWO_PI2 = Math.PI * 2;
   var MAX_GAIT = 1.4;
   var CLIP_BLEND = 0.12;
   var CLIP_CASCADE = 5;
   var FALL_SECONDS2 = 0.3;
+  var BUILDER_EYE = [0, 1.815, 0.16];
+  var EYE_OFFSET = [0, -0.068, 0];
+  var EYE_BOB = 0.5;
   var HIP_HEIGHT = 0.95;
   var WALK_ARM = 0.28;
   var WALK_BOB = 0.035;
@@ -8822,7 +9012,11 @@ var GameCharactersThree = (() => {
   var REST_ARM_Z = 0.18;
   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 SIT = { thigh: -1.5, lean: -0.08, arm: -0.45, armZ: 0.12, elbow: -0.75 };
+  var LIE = { knee: 0.08, armZ: 0.12, elbow: -0.1 };
   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 DOOR_SHOULDER = 1.42;
+  var DOOR_ARM = 0.62;
   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));
@@ -8852,6 +9046,8 @@ var GameCharactersThree = (() => {
     const fallSeconds = options.fallSeconds ?? FALL_SECONDS2;
     const smooth = options.cascade ?? true;
     const clipCascade = options.clipCascade ?? CLIP_CASCADE;
+    const eyeBob = options.eyeBob ?? EYE_BOB;
+    const eyeOffset = options.eyeOffset ?? EYE_OFFSET;
     const root = new THREE.Group();
     const tilt = new THREE.Group();
     tilt.add(body);
@@ -8911,7 +9107,23 @@ var GameCharactersThree = (() => {
       if (hand.th) hand.th.rotation.z = -hand.side * (0.32 + grip * 0.25);
       hand.hg.rotation.x = wristX;
     };
+    const eyeSocket = new THREE.Object3D();
+    eyeSocket.name = "eye";
+    eyeSocket.position.set(BUILDER_EYE[0] + eyeOffset[0], BUILDER_EYE[1] + eyeOffset[1], BUILDER_EYE[2] + eyeOffset[2]);
+    rig.headG.children[0].add(eyeSocket);
+    const headHider = createHeadHider([rig.headG, ...rig.neck ? [rig.neck] : []]);
+    const eyeLocal = new THREE.Vector3();
+    let bob = 0;
+    let hipWithoutBob = null;
     const legRestX = rig.legs.map((leg) => leg.g.position.x);
+    const legLengths = (() => {
+      const thigh = rig.legs[0].g;
+      const shin = rig.legs[0].kn;
+      root.updateMatrixWorld(true);
+      const hipY = thigh.getWorldPosition(new THREE.Vector3()).y;
+      const kneeY = shin.getWorldPosition(new THREE.Vector3()).y;
+      return { hipBelowTrunk: HIP_HEIGHT - hipY, thigh: hipY - kneeY, shin: kneeY - new THREE.Box3().setFromObject(shin).min.y };
+    })();
     const legSide = (index) => index === 0 ? 1 : -1;
     let cycles = 0;
     let time = 0;
@@ -8970,10 +9182,29 @@ var GameCharactersThree = (() => {
         ...strain ? { legL: -0.5, legR: 0.4, kneeL: 0.55, kneeR: 0.08, drop: -0.05 } : {}
       };
     };
+    const doorPose = (door) => {
+      const { phase, progress } = door;
+      const on = phase === "reach" ? progress : phase === "release" ? 1 - progress : 1;
+      const swing = phase === "swing" ? progress : phase === "release" ? 1 : 0;
+      const shake = phase === "rattle" ? Math.sin(time * 55) * 0.06 * (1 - progress) : 0;
+      const drop = clamp((DOOR_SHOULDER - door.height) / DOOR_ARM, -0.9, 1);
+      const low = clamp((0.75 - door.height) / 0.5, 0, 1);
+      const raise = -Math.acos(clamp(drop, -1, 1)) * on - 0.35 * low * on;
+      const elbow = door.pull ? -0.35 - 0.75 * swing : -0.95 + 0.75 * swing;
+      return {
+        armR: raise + shake,
+        armRz: REST_ARM_Z * (1 - on) + 0.05 * on,
+        elbR: -0.12 + (elbow + 0.12) * on,
+        armLz: -REST_ARM_Z,
+        elbL: -0.12,
+        lean: ((door.pull ? -0.06 : 0.1) * swing + 0.35 * low) * on,
+        headX: 0.06 * on + 0.2 * low * on
+      };
+    };
     const holdingPose = (gait, itemUse) => {
-      const bob = Math.sin(cycles * TWO_PI2) * 0.05 * gait;
+      const bob2 = Math.sin(cycles * TWO_PI2) * 0.05 * gait;
       if (!itemUse) {
-        return { armL: -0.45 + bob, armLz: 0.22, elbL: -1.05 };
+        return { armL: -0.45 + bob2, armLz: 0.22, elbL: -1.05 };
       }
       const { id, position, rotation } = itemUse;
       if (id === "drink" || id === "sip" || id === "chug") {
@@ -8986,7 +9217,7 @@ var GameCharactersThree = (() => {
           headX: -0.26 * tilt3
         };
       }
-      if (id === "open" || id === "close") {
+      if (id === "open" || id === "close" || itemUse.gripL !== void 0) {
         const reach = clamp((0.22 - position[0]) / 0.12, 0, 1);
         return {
           armL: -0.45 - 0.35 * reach,
@@ -9085,6 +9316,31 @@ var GameCharactersThree = (() => {
         drop: Math.abs(Math.sin(ph)) * WALK_BOB * gait
       };
     };
+    const sitPose = (hip) => {
+      const knee = hip - legLengths.hipBelowTrunk - legLengths.thigh * Math.cos(SIT.thigh);
+      const shinFromVertical = Math.acos(clamp(knee / legLengths.shin, 0, 1));
+      const bend = -SIT.thigh - shinFromVertical;
+      return {
+        legL: SIT.thigh,
+        legR: SIT.thigh,
+        kneeL: bend,
+        kneeR: bend,
+        lean: SIT.lean,
+        drop: hip - HIP_HEIGHT,
+        armR: SIT.arm,
+        armL: SIT.arm,
+        armRz: SIT.armZ,
+        armLz: -SIT.armZ,
+        elbR: SIT.elbow,
+        elbL: SIT.elbow
+      };
+    };
+    const liePose = () => ({ legL: 0, legR: 0, kneeL: LIE.knee, kneeR: LIE.knee, lean: 0, drop: 0, armR: 0, armL: 0, armRz: LIE.armZ, armLz: -LIE.armZ, elbR: LIE.elbow, elbL: LIE.elbow });
+    const layBody = (hip) => {
+      tilt.rotation.set(-Math.PI / 2, 0, 0, "XYZ");
+      const pivot = new THREE.Vector3(0, HIP_HEIGHT, 0).applyEuler(tilt.rotation);
+      tilt.position.set(0, hip, 0).sub(pivot);
+    };
     const placeBody = (progress) => {
       const fk = progress * progress * (3 - 2 * progress);
       const flip = fract(cycles * 1.7) >= 0.5 ? 1 : 0;
@@ -9145,13 +9401,27 @@ var GameCharactersThree = (() => {
         profile.bob = (running ? RUN_BOB : WALK_BOB) * gait;
         time = cycles / (walkCadence(Math.max(speed, 0)) * (running ? 1.3 : 1));
         animator.animate(body, time, { speed });
+        bob = rig.fig.position.y - rig.dropBase;
         fall = fallSeconds <= 0 ? down ? 1 : 0 : clamp(fall + (down ? dt : -dt) / fallSeconds, 0, 1);
         resetLegYaw();
-        if (down) animator.setPose(rig, downPose());
-        else {
-          if (running) animator.setPose(rig, runningPose(gait, Boolean(state.armed || state.holding || state.itemUse)));
-          if (state.crouch) animator.setPose(rig, crouchPose(gait));
+        const seat = down ? null : state.seat ?? null;
+        if (down) {
+          animator.setPose(rig, downPose());
+          bob = rig.fig.position.y - rig.dropBase;
+        } else if (seat) {
+          animator.setPose(rig, seat.pose === "lie" ? liePose() : sitPose(seat.hip));
+          bob = 0;
+        } else {
+          if (running) {
+            animator.setPose(rig, runningPose(gait, Boolean(state.armed || state.holding || state.itemUse)));
+            bob = rig.fig.position.y - rig.dropBase;
+          }
+          if (state.crouch) {
+            animator.setPose(rig, crouchPose(gait));
+            bob = rig.fig.position.y - rig.dropBase - CROUCH.drop;
+          }
           if (state.push) animator.setPose(rig, pushingPose(state.push));
+          else if (state.door) animator.setPose(rig, doorPose(state.door));
           else if (state.armed) animator.setPose(rig, armed(state.pitch ?? 0, gait, state.hip ?? 0));
           else if (state.holding || state.itemUse) animator.setPose(rig, holdingPose(gait, state.itemUse));
           else if (!running) {
@@ -9163,20 +9433,33 @@ var GameCharactersThree = (() => {
             });
           }
         }
-        placeBody(fall);
-        stepClip(dt, down, Boolean(state.crouch));
-        if (smooth) animator.cascade(rig, run && !run.clip.loop ? dt * clipCascade : dt);
+        if (seat?.pose === "lie") layBody(seat.hip);
+        else placeBody(fall);
+        stepClip(dt, down, Boolean(state.crouch || seat));
+        const cascadeDt = run && !run.clip.loop ? dt * clipCascade : dt;
+        const targetWithoutBob = rig.fig.position.y - bob;
+        if (smooth) animator.cascade(rig, cascadeDt);
+        hipWithoutBob = smooth && hipWithoutBob !== null ? stepCascade(hipWithoutBob, targetWithoutBob, cascadeDt, "hip") : targetWithoutBob;
+        bob = rig.fig.position.y - hipWithoutBob;
         const blow = run?.clip.events?.find((event) => (event.type === "impact" || event.type === "grip") && event.data?.kind)?.data?.kind;
         const ph = cycles * TWO_PI2;
         hands.forEach((hand) => {
           const isRight = hand.side < 0;
           const holdRight = isRight && (!!state.holding || !!state.itemUse);
-          const holdLeft = !isRight && (state.itemUse?.id === "open" || state.itemUse?.id === "close");
-          const grip = blow === "punch" ? 1.4 : blow === "shove" ? 0.15 : state.armed || holdRight || holdLeft ? 1.22 : running ? 0.85 : 0.12;
+          const holdLeft = !isRight && (state.itemUse?.id === "open" || state.itemUse?.id === "close" || state.itemUse?.gripL !== void 0);
+          const grip = !isRight && state.itemUse?.gripL !== void 0 ? 1.22 * state.itemUse.gripL : blow === "punch" ? 1.4 : blow === "shove" ? 0.15 : state.armed || holdRight || holdLeft ? 1.22 : running ? 0.85 : 0.12;
           const wristSwing = holdRight || state.armed || running ? 0 : -Math.min(1, gait) * Math.sin(ph - 0.6) * 0.12 * hand.side;
           setHandGrip(hand, grip, wristSwing);
         });
+        root.updateMatrixWorld(true);
+        root.worldToLocal(eyeSocket.getWorldPosition(eyeLocal));
+        eyeLocal.y -= (1 - eyeBob) * bob;
+      },
+      eye(out = new THREE.Vector3()) {
+        root.updateWorldMatrix(true, false);
+        return root.localToWorld(out.copy(eyeLocal));
       },
+      setView: (mode, camera) => headHider.setView(mode, camera),
       play(clip, playOptions = {}) {
         const found = typeof clip === "string" ? clips.get(clip) : clip;
         if (!found) throw new Error(`Unknown pose clip: ${String(clip)}`);
@@ -9188,10 +9471,11 @@ var GameCharactersThree = (() => {
         if (run) run.target = 0;
       },
       hand: (side) => sockets[side],
-      reach(targets) {
+      shoulder: (side) => armOf[side].g,
+      reach(targets, view) {
         if (run || fall > 0) return;
         root.updateMatrixWorld(true);
-        armReach.apply(targets);
+        armReach.apply(targets, view);
       },
       on(_type, listener) {
         listeners.add(listener);
@@ -9614,6 +9898,233 @@ var GameCharactersThree = (() => {
   var FIRST_PERSON_CLIPS = first_person_clips_default.clips;
   var NAME_POOLS = { "pt-BR": names_default["pt-BR"] };
 
+  // src/player/room-avatar.ts
+  var impactOf = (clip) => clip.events?.find((event) => event.type === "impact")?.t ?? null;
+  var isPunch = (clip) => clip.events?.some((event) => event.type === "impact" && event.data?.kind === "punch") ?? false;
+  var GUARD_SPEED = 0.3;
+  var toRoomAvatar = (avatar, options = {}) => {
+    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;
+    };
+    const guard = options.guardClip === false ? void 0 : strikes.get(options.guardClip ?? "fight_guard");
+    const guardHold = options.guardHold ?? 1.2;
+    const punchBlend = options.punchBlend ?? 0.05;
+    let strikeLeft = 0;
+    let guardLeft = 0;
+    let guarding = false;
+    const stepGuard = (dt, state) => {
+      if (!guard) return;
+      const free = state.speed < GUARD_SPEED && !state.down && !state.armed && !state.holding && !state.push && !state.door && !state.itemUse && !state.running;
+      if (strikeLeft > 0) {
+        strikeLeft -= dt;
+        if (strikeLeft <= 0 && guardLeft > 0 && free) {
+          avatar.play(guard);
+          guarding = true;
+        }
+        return;
+      }
+      guardLeft = Math.max(0, guardLeft - dt);
+      if (guarding && (guardLeft <= 0 || !free || avatar.playing !== guard.id)) {
+        if (avatar.playing === guard.id) avatar.stop();
+        guarding = false;
+      }
+    };
+    return {
+      root: avatar.root,
+      avatar,
+      eye: (out) => avatar.eye(out),
+      setView: (mode, camera) => avatar.setView(mode, camera),
+      update: (dt, state) => {
+        stepGuard(dt, state);
+        avatar.update(dt, {
+          speed: state.speed,
+          running: state.running,
+          crouch: state.crouch,
+          down: state.down,
+          armed: state.armed,
+          pitch: -state.pitch,
+          ...state.holding !== void 0 ? { holding: state.holding } : {},
+          ...state.itemUse !== void 0 ? { itemUse: state.itemUse } : {},
+          ...state.push !== void 0 ? { push: state.push } : {},
+          ...state.seat !== void 0 ? { seat: state.seat } : {},
+          ...state.door !== void 0 ? { door: state.door } : {}
+        });
+      },
+      hand: (side) => avatar.hand(side),
+      shoulder: (side) => avatar.shoulder(side),
+      reach: (targets, view) => avatar.reach(targets, view),
+      strike: (clipId, strikeOptions) => {
+        const clip = strikes.get(clipId);
+        if (!clip) return null;
+        const left = strikeOptions?.leg === "left" || strikeOptions?.hand === "left";
+        const punch = guard !== void 0 && isPunch(clip);
+        avatar.play(left ? leftOf(clip) : clip, punch ? { blend: punchBlend } : void 0);
+        strikeLeft = punch ? clip.duration : 0;
+        guardLeft = punch ? guardHold : 0;
+        guarding = false;
+        return impactOf(clip);
+      }
+    };
+  };
+
+  // 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_CLIPS;
+    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,
+      ground: { surface: "concrete_slab" },
+      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;
+        };
+      }
+    };
+  }
+
   // src/presets/first-person-arms.json
   var first_person_arms_default = {
     source: {
@@ -9623,7 +10134,9 @@ var GameCharactersThree = (() => {
       shoulder: [0.16, -0.36, 0.18],
       upper: 0.32,
       fore: 0.3,
-      reachShift: 0.35,
+      reachShift: 0.42,
+      reachBend: [1.35, 0.95],
+      elbowView: [[0.96, -0.26, -0.06], null],
       wrist: 0.07,
       elbowPole: [0.45, -1, 0.2],
       shoulderLeft: [-0.07, -0.46, 0.18],
@@ -9650,22 +10163,14 @@ var GameCharactersThree = (() => {
   };
 
   // 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 PALM = { radius: 0.048, scale: [0.6, 1.05, 1], down: 0.035 };
+  var CURL = { closed: 1.25, near: 0.9, far: 1.1 };
+  var THUMB = { open: 0.32, closed: 0.25 };
   var createHandMesh = (THREE, skin, wristSkin = skin) => {
     const root = new THREE.Group();
     root.name = "first-person-hand";
     const geometries = [];
-    const box2 = (parent, sx, sy, sz, x, y, z, material = skin) => {
-      const geometry = new THREE.BoxGeometry(sx, sy, sz);
+    const add = (parent, geometry, material, x = 0, y = 0, z = 0) => {
       geometries.push(geometry);
       const mesh2 = new THREE.Mesh(geometry, material);
       mesh2.position.set(x, y, z);
@@ -9673,64 +10178,26 @@ var GameCharactersThree = (() => {
       parent.add(mesh2);
       return mesh2;
     };
-    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);
+    const group = new THREE.Group();
+    group.quaternion.setFromRotationMatrix(new THREE.Matrix4().makeBasis(new THREE.Vector3(0, -1, 0), new THREE.Vector3(-1, 0, 0), new THREE.Vector3(0, 0, -1)));
+    group.position.set(-PALM.down, 0, 0);
+    root.add(group);
+    add(group, new THREE.SphereGeometry(PALM.radius, 14, 10), skin, 0, -PALM.down, 0).scale.set(...PALM.scale);
+    const built = buildHand({ THREE, add, hg: group, handM: skin, s: -1, detailed: true });
+    const wristGeometry = new THREE.CylinderGeometry(0.03, 0.033, 0.05, 10);
     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;
-        box2(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);
-    box2(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);
-    box2(thumbFar, THUMB.far, FINGER_THICK, THUMB.width * 0.9, THUMB.far / 2, 0, 0);
-    thumbNear.add(thumbFar);
-    root.add(thumbNear);
+    add(root, wristGeometry, wristSkin, -PALM.down - 0.03, 0, 0);
     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 curlFinger = (finger, k) => {
+      built.fingers[finger * 2].rotation.z = k * CURL.closed * CURL.near;
+      built.fingers[finger * 2 + 1].rotation.z = k * CURL.closed * CURL.far;
     };
+    const applyIndex = () => curlFinger(0, indexCurl === void 0 ? lastGrip : Math.min(1, Math.max(0, indexCurl)));
     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;
+      lastGrip = Math.min(1, Math.max(0, grip));
+      for (let finger = 1; finger < 4; finger++) curlFinger(finger, lastGrip);
+      if (built.th) built.th.rotation.z = THUMB.open + lastGrip * THUMB.closed;
       applyIndex();
     };
     const setIndex = (value) => {
@@ -9752,6 +10219,8 @@ var GameCharactersThree = (() => {
   var DEFAULT_BLEND = 0.18;
   var ELBOW_SEGMENTS = 8;
   var REACH_SLACK = 0.97;
+  var ELBOW_VIEW_MARGIN = 0.86;
+  var ELBOW_VIEW_PASSES = 4;
   var CONTACT_PROBE = 1.4;
   var CONTACT_MIN = 0.12;
   var CONTACT_MARGIN = 5e-3;
@@ -9900,6 +10369,11 @@ var GameCharactersThree = (() => {
     const shoulderOf = (sign2, out) => sign2 === -1 && rig.shoulderLeft ? out.set(...rig.shoulderLeft) : out.set(rig.shoulder[0] * sign2, rig.shoulder[1], rig.shoulder[2]);
     const poleOf = (sign2) => sign2 === -1 && rig.elbowPoleLeft ? new THREE.Vector3(...rig.elbowPoleLeft) : new THREE.Vector3(rig.elbowPole[0] * sign2, rig.elbowPole[1], rig.elbowPole[2]);
     const kneePole = new THREE.Vector3(...rig.kneePole);
+    const reachOf = (sign2) => {
+      const bend = rig.reachBend?.[sign2 === 1 ? 0 : 1];
+      if (bend === void 0) return (rig.upper + rig.fore) * REACH_SLACK;
+      return Math.sqrt(rig.upper * rig.upper + rig.fore * rig.fore + 2 * rig.upper * rig.fore * Math.cos(bend));
+    };
     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"));
@@ -9989,15 +10463,45 @@ var GameCharactersThree = (() => {
       out.scale = base.scale;
       return out;
     };
-    const drawArm = (arm, pose) => {
+    const elbowAt = new THREE.Vector3();
+    const viewOf = (camera) => {
+      const lens = camera;
+      if (!lens.isPerspectiveCamera) return null;
+      const tanV = Math.tan(lens.fov * Math.PI / 360);
+      return { tanV, tanH: tanV * lens.aspect };
+    };
+    const placeElbowInView = (sign2, view) => {
+      const way = rig.elbowView?.[sign2 === 1 ? 0 : 1];
+      if (!way) return false;
+      elbowAt.set(way[0], way[1], way[2]).setLength(rig.fore).add(wristAt);
+      for (let pass = 0; pass < ELBOW_VIEW_PASSES; pass++) {
+        const depth = Math.max(0.05, -elbowAt.z);
+        const high = view.tanV * ELBOW_VIEW_MARGIN * depth;
+        const wide = view.tanH * ELBOW_VIEW_MARGIN * depth;
+        elbowAt.y = Math.max(elbowAt.y, -high);
+        elbowAt.x = Math.min(wide, Math.max(-wide, elbowAt.x));
+        elbowAt.sub(wristAt).setLength(rig.fore).add(wristAt);
+      }
+      shoulder.sub(elbowAt).setLength(rig.upper).add(elbowAt);
+      return true;
+    };
+    const drawArm = (arm, pose, view) => {
       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 (view && placeElbowInView(arm.sign, view)) {
+        solveTwoBone(shoulder, wristAt, rig.upper, rig.fore, towards.copy(elbowAt).sub(shoulder).add(elbowAt).sub(wristAt), bone);
+        finishArm(arm, pose, scale);
+        return;
+      }
+      const excess = shoulder.distanceTo(wristAt) - reachOf(arm.sign);
       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);
+      finishArm(arm, pose, scale);
+    };
+    const finishArm = (arm, pose, scale) => {
       palmAt.copy(bone.end).addScaledVector(fingers, rig.wrist * scale);
       arm.drawn.p.copy(palmAt);
       arm.anchor.position.copy(palmAt);
@@ -10109,7 +10613,7 @@ var GameCharactersThree = (() => {
             dropped.p.y -= AWAY_DROP * ease2(arm.away);
             pose = dropped;
           }
-          drawArm(arm, pose);
+          drawArm(arm, pose, mode === "target" && targets?.elbows !== "body" ? viewOf(state.camera) : null);
           const shown = arm.away < AWAY_HIDDEN;
           for (const part of [arm.anchor, arm.upper, arm.fore, arm.cuff, arm.elbow]) part.visible = shown;
         }
@@ -10151,237 +10655,6 @@ var GameCharactersThree = (() => {
       }
     };
   }
-
-  // src/player/room-avatar.ts
-  var impactOf = (clip) => clip.events?.find((event) => event.type === "impact")?.t ?? null;
-  var isPunch = (clip) => clip.events?.some((event) => event.type === "impact" && event.data?.kind === "punch") ?? false;
-  var GUARD_SPEED = 0.3;
-  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,
-      hideWhenIdle: true,
-      ...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;
-    };
-    const guard = options.guardClip === false ? void 0 : strikes.get(options.guardClip ?? "fight_guard");
-    const guardHold = options.guardHold ?? 1.2;
-    const punchBlend = options.punchBlend ?? 0.05;
-    let strikeLeft = 0;
-    let guardLeft = 0;
-    let guarding = false;
-    const stepGuard = (dt, state) => {
-      if (!guard) return;
-      const free = state.speed < GUARD_SPEED && !state.down && !state.armed && !state.holding && !state.push && !state.itemUse && !state.running;
-      if (strikeLeft > 0) {
-        strikeLeft -= dt;
-        if (strikeLeft <= 0 && guardLeft > 0 && free) {
-          avatar.play(guard);
-          guarding = true;
-        }
-        return;
-      }
-      guardLeft = Math.max(0, guardLeft - dt);
-      if (guarding && (guardLeft <= 0 || !free || avatar.playing !== guard.id)) {
-        if (avatar.playing === guard.id) avatar.stop();
-        guarding = false;
-      }
-    };
-    return {
-      root: avatar.root,
-      avatar,
-      arms,
-      ...arms ? { firstPerson: { root: arms.root, update: (dt, state) => arms.update(dt, state) } } : {},
-      update: (dt, state) => {
-        stepGuard(dt, state);
-        avatar.update(dt, {
-          speed: state.speed,
-          running: state.running,
-          crouch: state.crouch,
-          down: state.down,
-          armed: state.armed,
-          pitch: -state.pitch,
-          ...state.holding !== void 0 ? { holding: state.holding } : {},
-          ...state.itemUse !== void 0 ? { itemUse: state.itemUse } : {},
-          ...state.push !== void 0 ? { push: state.push } : {}
-        });
-      },
-      hand: (side) => avatar.hand(side),
-      reach: (targets) => avatar.reach(targets),
-      strike: (clipId, strikeOptions) => {
-        const clip = strikes.get(clipId);
-        if (!clip) return null;
-        const left = strikeOptions?.leg === "left" || strikeOptions?.hand === "left";
-        const punch = guard !== void 0 && isPunch(clip);
-        avatar.play(left ? leftOf(clip) : clip, punch ? { blend: punchBlend } : void 0);
-        strikeLeft = punch ? clip.duration : 0;
-        guardLeft = punch ? guardHold : 0;
-        guarding = false;
-        arms?.play(clipId, strikeOptions?.leg === "left" ? { leg: "left" } : strikeOptions?.hand === "left" ? { hand: "left" } : void 0);
-        return impactOf(clip);
-      }
-    };
-  };
-
-  // 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_CLIPS;
-    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,
-      ground: { surface: "concrete_slab" },
-      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;
-        };
-      }
-    };
-  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map