@adatechnology/game-animals-three 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1160 @@
+// src/index.ts
+import { GAIT_PHASES } from "@adatechnology/game-animals";
+import { collectReferencedNodes, createNodeSkin } from "@adatechnology/game-props3d";
+
+// src/animate-bird.ts
+var { PI } = Math;
+var animateBird = (rig, params) => {
+  const { time: t, delta: dt, clip } = params;
+  const species = rig.species;
+  const spec = species.body;
+  const isVulture = species.id === "vulture";
+  const isChicken = species.id === "chicken";
+  const isLapwing = species.id === "southern_lapwing";
+  const flying = clip === "run" && !isChicken;
+  const hz = clip === "run" && !flying ? species.runHz : clip === "walk" ? species.walkHz : 0;
+  rig.phase += dt * (flying ? isVulture ? 1.1 : 4.5 : hz) * 2 * PI;
+  const targetHeight = flying ? rig.size * 1.2 : 0;
+  rig.trunk.position.y += (targetHeight - rig.trunk.position.y) * Math.min(1, dt * 3);
+  rig.legs.forEach((leg, index) => {
+    if (flying) {
+      leg.hip.rotation.x = 1.2;
+      leg.knee.rotation.x = -1.6;
+    } else if (clip === "idle") {
+      leg.hip.rotation.x = 0;
+      leg.knee.rotation.x = 0;
+    } else {
+      const phase = rig.phase + index * PI;
+      leg.hip.rotation.x = -Math.sin(phase) * 0.45;
+      leg.knee.rotation.x = -Math.max(0, Math.cos(phase)) * 0.7;
+    }
+    leg.foot.rotation.x = -(leg.hip.rotation.x + leg.knee.rotation.x);
+  });
+  rig.wings.forEach((wing) => {
+    const { side, shoulder, elbow } = wing;
+    if (flying) {
+      const flap = isVulture ? 0.25 + Math.sin(rig.phase) * 0.18 : Math.sin(rig.phase) * 0.9;
+      shoulder.rotation.y += (0 - shoulder.rotation.y) * Math.min(1, dt * 6);
+      shoulder.rotation.z = side * flap;
+      elbow.rotation.z = side * (isVulture ? 0.08 : Math.sin(rig.phase - 0.6) * 0.4);
+      elbow.rotation.y = 0;
+      shoulder.scale.x += (1 - shoulder.scale.x) * Math.min(1, dt * 6);
+    } else {
+      const alert = isLapwing && clip === "idle" ? Math.max(0, Math.sin(t * 1.3)) * 0.9 : 0;
+      const flutter = isChicken && clip === "run" ? Math.abs(Math.sin(rig.phase * 1.5)) * 0.8 : 0;
+      shoulder.rotation.y += (side * PI / 2 * 0.97 - alert * side * 0.9 - shoulder.rotation.y) * Math.min(1, dt * 6);
+      shoulder.rotation.z = side * (-0.06 + flutter + alert * 0.6);
+      elbow.rotation.z = side * 0.04;
+      elbow.rotation.y = 0;
+      shoulder.scale.x += ((alert > 0.1 ? 1 : 0.58) - shoulder.scale.x) * Math.min(1, dt * 6);
+    }
+  });
+  const peck = isChicken && clip === "idle" ? Math.max(0, Math.sin(t * 1.6)) ** 8 * 1.2 : 0;
+  if (rig.neck) {
+    rig.neck.rotation.x = rig.neckAngle + (clip === "walk" && !isVulture ? Math.max(0, Math.sin(rig.phase * 2)) * 0.35 : 0) + peck + (flying ? 0.6 : 0);
+    rig.neck.rotation.y = clip === "idle" ? Math.sin(t * 0.9) * 0.5 : 0;
+  }
+  if (rig.jaw) rig.jaw.rotation.x = isLapwing && clip === "idle" ? Math.max(0, Math.sin(t * 1.3)) * Math.abs(Math.sin(t * 14)) * 0.5 : 0;
+  if (rig.tailRoot) rig.tailRoot.rotation.x = (spec.tailA || 0) + (flying ? 0.6 : 0);
+};
+
+// src/animate-quadruped.ts
+var { PI: PI2 } = Math;
+var animateQuadruped = (rig, params, gaits) => {
+  const { time: t, delta: dt, clip } = params;
+  const species = rig.species;
+  const spec = species.body;
+  if (rig.dead) {
+    rig.root.rotation.z += (PI2 / 2 * 0.97 - rig.root.rotation.z) * Math.min(1, dt * 3);
+    rig.root.position.y += (spec.R * (spec.sx || 1) * 0.85 - rig.root.position.y) * Math.min(1, dt * 3);
+    rig.legs.forEach((leg) => {
+      leg.hip.rotation.x = leg.angle1 + (leg.isFront ? -0.5 : 0.4);
+      leg.knee.rotation.x = 0.05;
+      leg.foot.rotation.x = 0;
+    });
+    if (rig.neck) rig.neck.rotation.x = rig.neckAngle + 0.35;
+    if (rig.jaw) rig.jaw.rotation.x = 0.25;
+    return;
+  }
+  const hz = (clip === "run" ? species.runHz : clip === "walk" ? species.walkHz : 0) * (rig.infected ? 1.2 : 1);
+  rig.phase += dt * hz * 2 * PI2;
+  const gait = clip === "run" ? species.gallop ? gaits.gallop : gaits.trot : gaits.walk;
+  const amplitude = clip === "run" ? 0.62 : 0.34;
+  const flex = clip === "run" ? 1.15 : 0.75;
+  rig.legs.forEach((leg, index) => {
+    if (clip === "idle") {
+      leg.hip.rotation.x = leg.angle1;
+      leg.knee.rotation.x = leg.angle2;
+    } else {
+      const phase = rig.phase + gait[index];
+      const limit = rig.infected && index === 1 ? 0.35 : 1;
+      leg.hip.rotation.x = leg.angle1 - Math.sin(phase) * amplitude * limit;
+      leg.knee.rotation.x = leg.angle2 + Math.max(0, Math.cos(phase)) * flex * limit;
+    }
+    leg.foot.rotation.x = -(leg.hip.rotation.x + leg.knee.rotation.x) * 0.85;
+  });
+  const bob = clip === "idle" ? 0 : Math.abs(Math.sin(rig.phase)) * (clip === "run" ? 0.05 : 0.018) * rig.size;
+  rig.trunk.position.y = bob * 0.6;
+  const bodyGroup = rig.bodyGroup;
+  if (bodyGroup) {
+    bodyGroup.rotation.x = clip === "run" && species.gallop ? Math.sin(rig.phase + PI2 * 0.4) * 0.07 : 0;
+    bodyGroup.scale.y = 1 + (clip === "idle" ? Math.sin(t * 2.2) * 0.012 : 0);
+  }
+  const low = rig.infected ? 0.35 : 0;
+  if (rig.neck) {
+    rig.neck.rotation.x = rig.neckAngle + low + (clip === "idle" ? Math.sin(t * 0.7) * 0.08 : Math.sin(rig.phase * 2) * 0.04);
+    rig.neck.rotation.y = clip === "idle" ? Math.sin(t * 0.45) * 0.35 : 0;
+  }
+  if (rig.head) rig.head.rotation.z = rig.infected ? Math.sin(t * 11) * Math.sin(t * 1.7) * 0.12 : 0;
+  if (rig.jaw) rig.jaw.rotation.x = rig.infected ? 0.25 + Math.max(0, Math.sin(t * 6)) * 0.25 : clip === "run" ? 0.12 : 0;
+  const wagging = species.id === "dog" && !rig.infected;
+  rig.tail.forEach((segment, index) => {
+    segment.rotation.z = Math.sin(t * (wagging ? 9 : 2.2) - index * 0.6) * (wagging ? 0.35 : 0.12);
+  });
+};
+
+// src/animate-snake.ts
+var { PI: PI3 } = Math;
+var bodyPath = (THREE, rig, params, spacing) => {
+  const { time: t, clip } = params;
+  const points = [];
+  for (let index = 0; index < rig.segmentCount; index++) {
+    let x;
+    let z;
+    let y = 0;
+    if (clip === "walk") {
+      z = 0.6 - index * spacing;
+      x = Math.sin(rig.phase * 2.2 - index * 0.42) * 0.08 * Math.min(1, index / 6 + 0.3);
+    } else {
+      const strike = clip === "run" ? Math.max(0, Math.sin(t * 2.2)) ** 6 : 0;
+      if (index < 9) {
+        const k = index / 9;
+        z = 0.08 + (1 - k) * 0.12 + strike * (1 - k) * 0.35;
+        y = (1 - k) * 0.13 * (1 - strike * 0.6);
+        x = Math.sin(k * PI3 * 1.6) * 0.05 * (1 - strike);
+      } else {
+        const angle = (index - 9) * 0.36;
+        const radius = 0.16 - (index - 9) * 45e-4;
+        x = Math.cos(angle) * radius;
+        z = Math.sin(angle) * radius - 0.05;
+        y = (index - 9) * 12e-4;
+      }
+    }
+    points.push(new THREE.Vector3(x, y, z));
+  }
+  return points;
+};
+var animateSnake = (THREE, rig, params) => {
+  const { time: t, delta: dt, clip } = params;
+  const spacing = rig.segmentLength * (params.split ? 1.5 : 1);
+  if (clip === "walk") rig.phase += dt * 2.4;
+  const points = bodyPath(THREE, rig, params, spacing);
+  const at = (index) => points[index];
+  for (let index = 0; index < rig.segmentCount; index++) {
+    const group = rig.segments[index].group;
+    group.position.copy(at(index));
+    const direction = index === 0 ? at(0).clone().sub(at(1)) : at(index - 1).clone().sub(at(index));
+    group.rotation.set(0, Math.atan2(direction.x, direction.z), 0);
+    group.rotateX(-Math.atan2(direction.y, Math.hypot(direction.x, direction.z)));
+  }
+  const head = rig.head;
+  const headDirection = at(0).clone().sub(at(1)).normalize();
+  head.position.copy(at(0)).addScaledVector(headDirection, 0.02);
+  head.rotation.set(0, Math.atan2(headDirection.x, headDirection.z), 0);
+  head.rotateX(-Math.atan2(headDirection.y, Math.hypot(headDirection.x, headDirection.z)) * 0.5);
+  const jaw = rig.jaw;
+  jaw.rotation.x = clip === "run" ? Math.max(0, Math.sin(t * 2.2)) ** 6 * 0.9 : 0;
+  const tongue = rig.tongue;
+  tongue.visible = Math.sin(t * 5) > 0.3;
+  tongue.scale.z = 1 + Math.sin(t * 20) * 0.3;
+};
+
+// src/bird.ts
+import { birdSize } from "@adatechnology/game-animals";
+
+// src/context.ts
+var createStream = (seed) => {
+  let state = seed;
+  return () => {
+    state |= 0;
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+};
+var addMesh = (THREE, parent, geometry, material, x, y, z, rx, ry, rz) => {
+  const mesh = new THREE.Mesh(geometry, material);
+  mesh.position.set(x || 0, y || 0, z || 0);
+  if (rx || ry || rz) mesh.rotation.set(rx || 0, ry || 0, rz || 0);
+  mesh.castShadow = true;
+  mesh.receiveShadow = true;
+  parent.add(mesh);
+  return mesh;
+};
+var createRigTools = (THREE, rig) => {
+  const tools = {
+    material(color, extras) {
+      const material = new THREE.MeshStandardMaterial(Object.assign({ color, roughness: 0.8, metalness: 0, flatShading: false }, extras || {}));
+      material.userData.base = material.color.clone();
+      rig.materials.push(material);
+      return material;
+    },
+    ball(parent, radius, material, x, y, z, sx, sy, sz) {
+      const mesh = addMesh(THREE, parent, new THREE.SphereGeometry(radius, 16, 12), material, x, y, z);
+      if (sx) mesh.scale.set(sx, sy, sz);
+      return mesh;
+    },
+    limb: (parent, radius1, radius2, length, material) => addMesh(THREE, parent, new THREE.CylinderGeometry(radius2, radius1, length, 14, 1).translate(0, -length / 2, 0), material),
+    joint(parent, radius, material, x, y, z) {
+      const joint = tools.ball(parent, radius, material, x, y, z);
+      joint.userData.joint = 1;
+      rig.joints.push(joint);
+      return joint;
+    },
+    pivot(parent, x, y, z, offset) {
+      const group = new THREE.Group();
+      group.position.set(x, y, z);
+      parent.add(group);
+      rig.pivots.push({ group, rest: group.position.clone(), offset: offset || new THREE.Vector3() });
+      return group;
+    },
+    eyes(head, radius, x, y, z) {
+      const eyeMaterial = tools.material(1118481, { roughness: 0.25 });
+      rig.eyeMaterial = eyeMaterial;
+      for (const side of [-1, 1]) rig.eyes.push(tools.ball(head, radius, eyeMaterial, side * x, y, z));
+    }
+  };
+  return tools;
+};
+var createRig = (THREE, species, options) => {
+  const rig = {
+    species,
+    root: new THREE.Group(),
+    trunk: new THREE.Group(),
+    materials: [],
+    joints: [],
+    pivots: [],
+    legs: [],
+    tail: [],
+    ears: [],
+    infectionParts: [],
+    eyes: [],
+    wings: [],
+    segments: [],
+    phase: options.phase,
+    size: 1,
+    segmentLength: 0,
+    segmentCount: 0,
+    home: new THREE.Vector3(),
+    infected: false,
+    dead: false,
+    neckAngle: 0,
+    headAngle: 0,
+    triangles: 0
+  };
+  rig.root.add(rig.trunk);
+  return rig;
+};
+
+// src/bird.ts
+var buildWings = (THREE, rig, spec, parts) => {
+  const tools = createRigTools(THREE, rig);
+  const { bodyGroup, main, dark } = parts;
+  for (const side of [-1, 1]) {
+    const shoulder = tools.pivot(bodyGroup, side * spec.r * spec.s[0] * 1.02, spec.r * 0.22, spec.r * 0.3, new THREE.Vector3(side * 0.12, 0.03, 0).multiplyScalar(rig.size));
+    tools.joint(shoulder, spec.r * 0.14, main, 0, 0, 0);
+    tools.ball(shoulder, 0.5, spec.wingM ? tools.material(spec.wingM) : dark, side * spec.wi * 0.5, 0, -spec.wc * 0.3, spec.wi * 1.05, spec.r * 0.16, spec.wc);
+    const elbow = tools.pivot(shoulder, side * spec.wi, 0, 0, new THREE.Vector3(side * 0.06, 0, 0).multiplyScalar(rig.size));
+    tools.joint(elbow, spec.r * 0.1, main, 0, 0, 0);
+    tools.ball(elbow, 0.5, dark, side * spec.wo * 0.45, 0, -spec.wc * 0.32, spec.wo * 1.05, spec.r * 0.12, spec.wc * 0.75);
+    if (spec.fingers) {
+      for (let finger = 0; finger < 4; finger++) {
+        addMesh(THREE, elbow, new THREE.BoxGeometry(spec.wo * 0.35, spec.r * 0.03, spec.wc * 0.12), dark, side * (spec.wo + spec.wo * 0.12), 0, -spec.wc * 0.05 - finger * spec.wc * 0.18, 0, side * (0.05 + finger * 0.12), 0);
+      }
+    }
+    if (spec.spur) addMesh(THREE, elbow, new THREE.ConeGeometry(spec.r * 0.06, spec.r * 0.25, 5), tools.material(12595242), 0, 0, spec.wc * 0.2, Math.PI / 2, 0, 0);
+    rig.wings.push({ shoulder, elbow, side });
+  }
+};
+var buildLegs = (THREE, rig, spec, parts) => {
+  const tools = createRigTools(THREE, rig);
+  const { bodyGroup, main, leg } = parts;
+  for (const side of [-1, 1]) {
+    const hip = tools.pivot(bodyGroup, side * spec.r * 0.38, -spec.r * 0.55, spec.r * 0.05, new THREE.Vector3(side * 0.06, -0.05, 0).multiplyScalar(rig.size));
+    tools.joint(hip, spec.r * 0.18, main, 0, 0, 0);
+    tools.limb(hip, spec.r * 0.16, spec.r * 0.09, spec.shank, spec.featherLeg ? main : leg);
+    const ankle = tools.pivot(hip, 0, -spec.shank, 0, new THREE.Vector3(0, -0.04, 0).multiplyScalar(rig.size));
+    tools.joint(ankle, spec.r * 0.06, leg, 0, 0, 0);
+    tools.limb(ankle, spec.r * 0.055, spec.r * 0.05, spec.tars, leg);
+    const foot = tools.pivot(ankle, 0, -spec.tars, 0);
+    for (const angle of [-0.45, 0, 0.45]) addMesh(THREE, foot, new THREE.BoxGeometry(spec.r * 0.05, spec.r * 0.04, spec.r * 0.55).translate(0, 0, spec.r * 0.25), leg, 0, -spec.r * 0.02, 0, 0, angle, 0);
+    addMesh(THREE, foot, new THREE.BoxGeometry(spec.r * 0.05, spec.r * 0.04, spec.r * 0.25).translate(0, 0, -spec.r * 0.12), leg, 0, -spec.r * 0.02, 0);
+    rig.legs.push({ hip, knee: ankle, foot, isFront: false, angle1: 0.35, angle2: -0.5, side });
+  }
+};
+var buildBird = (THREE, rig, options) => {
+  const spec = rig.species.body;
+  const tools = createRigTools(THREE, rig);
+  const colors = spec.c;
+  const main = tools.material(colors.main);
+  const dark = tools.material(colors.dark);
+  const leg = tools.material(colors.leg);
+  const beak = tools.material(colors.beak, { roughness: 0.5 });
+  const belly = tools.material(colors.belly || colors.main);
+  rig.main = main;
+  const hipY = spec.tars + spec.shank * 0.9;
+  rig.size = birdSize(spec);
+  const bodyGroup = tools.pivot(rig.trunk, 0, hipY + spec.r * 0.55, 0);
+  rig.bodyGroup = bodyGroup;
+  bodyGroup.rotation.x = spec.pitch || 0;
+  tools.ball(bodyGroup, spec.r, main, 0, 0, 0, spec.s[0], spec.s[1], spec.s[2]);
+  tools.ball(bodyGroup, spec.r * 0.9, belly, 0, -spec.r * 0.22, spec.r * 0.15, spec.s[0] * 0.9, spec.s[1] * 0.8, spec.s[2] * 0.85);
+  const tail = tools.pivot(bodyGroup, 0, spec.r * 0.15, -spec.r * spec.s[2] * 0.85, new THREE.Vector3(0, 0, -0.08).multiplyScalar(rig.size));
+  tail.rotation.x = spec.tailA || -0.3;
+  rig.tailRoot = tail;
+  addMesh(THREE, tail, new THREE.BoxGeometry(spec.tailW, spec.r * 0.08, spec.tailL).translate(0, 0, -spec.tailL / 2), spec.tailM ? tools.material(spec.tailM) : dark);
+  buildWings(THREE, rig, spec, { bodyGroup, main, dark });
+  const neck = tools.pivot(bodyGroup, 0, spec.r * 0.45, spec.r * spec.s[2] * 0.75, new THREE.Vector3(0, 0.05, 0.08).multiplyScalar(rig.size));
+  neck.rotation.x = spec.neckA;
+  rig.neck = neck;
+  rig.neckAngle = spec.neckA;
+  tools.joint(neck, spec.nr * 1.1, spec.neckM ? tools.material(spec.neckM) : main, 0, 0, 0);
+  addMesh(THREE, neck, new THREE.CylinderGeometry(spec.nr * 0.85, spec.nr, spec.nl, 12).translate(0, spec.nl / 2, 0), spec.neckM ? tools.material(spec.neckM) : main);
+  const head = tools.pivot(neck, 0, spec.nl, 0, new THREE.Vector3(0, 0.05, 0.05).multiplyScalar(rig.size));
+  head.rotation.x = -spec.neckA + (spec.headA || 0);
+  rig.head = head;
+  rig.headAngle = head.rotation.x;
+  const headMaterial = spec.headM ? tools.material(spec.headM) : main;
+  tools.ball(head, spec.hr, headMaterial, 0, 0, 0, spec.hs ? spec.hs[0] : 1, spec.hs ? spec.hs[1] : 1, spec.hs ? spec.hs[2] : 1.1);
+  addMesh(THREE, head, new THREE.ConeGeometry(spec.br, spec.bl, 8).rotateX(Math.PI / 2).translate(0, 0, spec.bl / 2), beak, 0, -spec.hr * 0.1, spec.hr * 0.85, spec.hook || 0, 0, 0);
+  const jaw = tools.pivot(head, 0, -spec.hr * 0.25, spec.hr * 0.8);
+  rig.jaw = jaw;
+  addMesh(THREE, jaw, new THREE.ConeGeometry(spec.br * 0.7, spec.bl * 0.85, 8).rotateX(Math.PI / 2).translate(0, 0, spec.bl * 0.42), beak).scale.set(1, 0.5, 1);
+  tools.eyes(head, spec.hr * 0.17, spec.hr * 0.68, spec.hr * 0.2, spec.hr * 0.35);
+  if (spec.eyeC && rig.eyeMaterial) {
+    rig.eyeMaterial.color.set(spec.eyeC);
+    rig.eyeMaterial.userData.base = rig.eyeMaterial.color.clone();
+  }
+  options.extra?.({ THREE, rig, tools }, { bodyGroup, head, neck, main, dark });
+  buildLegs(THREE, rig, spec, { bodyGroup, main, leg });
+  return rig;
+};
+
+// src/extras.ts
+var cow = ({ THREE, tools }, k) => {
+  tools.ball(k.bodyGroup, 0.2, k.main, 0, k.Rb * 1.1, k.L * 0.33, 0.95, 1.1, 1.1);
+  tools.ball(k.neck, 0.13, k.main, 0, 0.12, 0.08, 0.55, 1.4, 1.05);
+  for (const side of [-1, 1]) addMesh(THREE, k.head, new THREE.ConeGeometry(0.025, 0.13, 8), tools.material(13616808), side * 0.12, k.hd.r * 1.05, k.hd.r * 0.05, 0, 0, side * -0.9);
+};
+var horse = ({ THREE, rig, tools }, k) => {
+  for (let index = 0; index < 9; index++) addMesh(THREE, k.neck, new THREE.BoxGeometry(0.035, 0.16, 0.08), k.dark, 0, 0.06 + index * 0.065, -0.12 + index * 4e-3, -0.25, 0, 0);
+  addMesh(THREE, k.head, new THREE.BoxGeometry(0.03, 0.12, 0.06), k.dark, 0, k.hd.r * 1.05, k.hd.r * 0.3, 0.6, 0, 0);
+  const last = rig.tail[rig.tail.length - 1];
+  tools.ball(last, 0.08, k.dark, 0, -0.42, 0, 0.7, 4.5, 0.7);
+};
+var wildBoar = ({ THREE, tools }, k) => {
+  for (let index = 0; index < 12; index++) addMesh(THREE, k.bodyGroup, new THREE.BoxGeometry(0.03, 0.1, 0.06), k.dark, 0, k.Rb * 1.12 - index * 4e-3, k.L * 0.38 - index * 0.06, -0.2, 0, 0);
+  for (const side of [-1, 1])
+    addMesh(THREE, k.head, new THREE.ConeGeometry(0.012, 0.09, 6), tools.material(15261900), side * 0.07, k.hd.r * -0.25 + 0.03, k.hd.r * 0.25 + k.hd.r * k.hd.s[2] * 0.55 + 0.13, -0.6, 0, side * 0.5);
+};
+var chicken = ({ tools }, k) => {
+  const red = tools.material(12593182);
+  for (let index = 0; index < 4; index++) tools.ball(k.head, 0.014, red, 0, 0.045, -0.012 + index * 0.014, 0.5, 1, 0.8);
+  tools.ball(k.head, 0.012, red, 0, -0.04, 0.04, 0.5, 1.3, 0.7);
+};
+var southernLapwing = ({ THREE, tools }, k) => {
+  const black = tools.material(1447446);
+  tools.ball(k.bodyGroup, 0.05, black, 0, 0.03, 0.08, 1.1, 0.9, 0.6);
+  addMesh(THREE, k.head, new THREE.BoxGeometry(6e-3, 6e-3, 0.06).translate(0, 0, -0.03), black, 0, 0.025, -0.01, 0.5, 0, 0);
+  tools.ball(k.head, 0.026, black, 0, -5e-3, 0.02, 1.05, 0.7, 0.9);
+};
+var QUADRUPED_EXTRAS = { cow, horse, wild_boar: wildBoar };
+var BIRD_EXTRAS = { chicken, southern_lapwing: southernLapwing };
+
+// src/quadruped.ts
+import { quadrupedLayout } from "@adatechnology/game-animals";
+
+// src/textures.ts
+var canvasTexture = (THREE, document, width, height, draw) => {
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  draw(canvas.getContext("2d"), width, height);
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.colorSpace = THREE.SRGBColorSpace;
+  return texture;
+};
+var spotsTexture = (THREE, document, base, spot) => canvasTexture(THREE, document, 256, 256, (painter, width, height) => {
+  painter.fillStyle = base;
+  painter.fillRect(0, 0, width, height);
+  const next = createStream(11);
+  for (let index = 0; index < 70; index++) {
+    const x = next() * width;
+    const y = next() * height;
+    const radius = 5 + next() * 7;
+    painter.strokeStyle = spot;
+    painter.lineWidth = 3;
+    painter.beginPath();
+    painter.arc(x, y, radius, 0, 7);
+    painter.stroke();
+    painter.fillStyle = "rgba(120,70,20,.45)";
+    painter.beginPath();
+    painter.arc(x, y, radius * 0.6, 0, 7);
+    painter.fill();
+  }
+  for (let index = 0; index < 60; index++) {
+    painter.fillStyle = spot;
+    painter.beginPath();
+    painter.arc(next() * width, next() * height, 1.5 + next() * 2.5, 0, 7);
+    painter.fill();
+  }
+});
+var stripesTexture = (THREE, document, base, stripe) => canvasTexture(THREE, document, 128, 128, (painter, width) => {
+  painter.fillStyle = base;
+  painter.fillRect(0, 0, width, 128);
+  painter.fillStyle = stripe;
+  for (let index = 0; index < 9; index++) painter.fillRect(0, index * 14 + index % 2 * 3, width, 4);
+});
+var createCoatTexture = (THREE, document, marker) => marker.kind === "stripes" ? stripesTexture(THREE, document, marker.base, marker.stripe) : spotsTexture(THREE, document, marker.base, marker.spot);
+
+// src/profile.ts
+var profileGeometry = (THREE, length, profile, segments) => {
+  const points = profile.map((radius, index) => new THREE.Vector2(index / (profile.length - 1), radius));
+  const curve = new THREE.SplineCurve(points);
+  const outline = [];
+  outline.push(new THREE.Vector2(1e-3, -length / 2 - 0));
+  for (let step = 0; step <= 30; step++) {
+    const point = curve.getPoint(step / 30);
+    outline.push(new THREE.Vector2(Math.max(1e-3, point.y), -length / 2 + point.x * length));
+  }
+  outline.push(new THREE.Vector2(1e-3, length / 2));
+  return new THREE.LatheGeometry(outline, segments || 22).rotateX(Math.PI / 2);
+};
+
+// src/quadruped.ts
+var RIB_COUNT = 4;
+var LEG_DEFINITIONS = [
+  [1, 1, "F"],
+  [-1, 1, "F"],
+  [1, -1, "H"],
+  [-1, -1, "H"]
+];
+var buildBodyAndLegs = (THREE, rig, spec, main, belly, dark) => {
+  const tools = createRigTools(THREE, rig);
+  const { L, R: radius } = spec;
+  const leg = spec.leg;
+  const layout = quadrupedLayout(spec);
+  const { frontHipHeight, hindHipHeight, footHeight, bodyHeight, span } = layout;
+  const frontAngle1 = leg.fa1 ?? 0.06;
+  const frontAngle2 = leg.fa2 ?? -0.08;
+  const hindAngle1 = leg.ha1 ?? -0.32;
+  const hindAngle2 = leg.ha2 ?? 0.58;
+  rig.size = layout.size;
+  const bodyGroup = tools.pivot(rig.trunk, 0, bodyHeight, 0);
+  rig.bodyGroup = bodyGroup;
+  const body = addMesh(THREE, bodyGroup, profileGeometry(THREE, L, spec.prof.map((value) => value * radius)), main);
+  body.scale.set(spec.sx || 1, spec.sy || 1, 1);
+  body.rotation.x = Math.atan2(hindHipHeight - frontHipHeight, span) * 0.6;
+  rig.body = body;
+  const belt = addMesh(THREE, bodyGroup, profileGeometry(THREE, L * 0.8, spec.prof.map((value) => value * 0.8 * radius)), belly);
+  belt.scale.set((spec.sx || 1) * 0.92, (spec.sy || 1) * 0.85, 1);
+  belt.position.y = -radius * 0.2;
+  LEG_DEFINITIONS.forEach(([sx, sz, kind]) => {
+    const front = kind === "F";
+    const upper = front ? leg.fu : leg.hu;
+    const lower = front ? leg.fl : leg.hl;
+    const height = front ? frontHipHeight : hindHipHeight;
+    const hip = tools.pivot(rig.trunk, sx * radius * (spec.sx || 1) * 0.55, height, sz * span / 2, new THREE.Vector3(sx * 0.18, -0.06, sz * 0.12).multiplyScalar(rig.size));
+    tools.ball(hip, leg.r * (front ? 1.9 : 2.3), main, 0, -upper * 0.18, front ? 0 : -leg.r * 0.3, 0.75, 1.25, 1);
+    tools.joint(hip, leg.r * 1.15, main, 0, 0, 0);
+    tools.limb(hip, leg.r * 1.25, leg.r * 0.95, upper, main);
+    const knee = tools.pivot(hip, 0, -upper, 0, new THREE.Vector3(0, -0.07 * rig.size, 0));
+    tools.joint(knee, leg.r * 0.95, main, 0, 0, 0);
+    tools.limb(knee, leg.r * 0.92, leg.r * 0.68, lower, main);
+    const foot = tools.pivot(knee, 0, -lower, 0, new THREE.Vector3(0, -0.05 * rig.size, 0));
+    if (leg.hoof) {
+      tools.joint(foot, leg.r * 0.72, dark, 0, 0, 0);
+      addMesh(THREE, foot, new THREE.CylinderGeometry(leg.r * 0.8, leg.r * 1.05, footHeight, 12).translate(0, -footHeight / 2, 0), dark);
+    } else {
+      tools.joint(foot, leg.r * 0.66, main, 0, 0, 0);
+      tools.ball(foot, leg.r * 0.95, leg.dark ? dark : main, 0, -footHeight * 0.55, leg.r * 0.5, 1, 0.62, 1.45);
+    }
+    rig.legs.push({ hip, knee, foot, isFront: front, angle1: front ? frontAngle1 : hindAngle1, angle2: front ? frontAngle2 : hindAngle2, side: sx });
+  });
+  return { bodyGroup, bodyHeight };
+};
+var buildHead = (THREE, rig, spec, parts) => {
+  const tools = createRigTools(THREE, rig);
+  const { bodyGroup, main, belly, nose } = parts;
+  const { L, R: radius } = spec;
+  const neckSpec = spec.neck;
+  const headSpec = spec.head;
+  const neck = tools.pivot(bodyGroup, 0, radius * (spec.sy || 1) * (neckSpec.y ?? 0.35), L / 2 * (neckSpec.z ?? 0.78), new THREE.Vector3(0, 0.05, 0.12).multiplyScalar(rig.size));
+  neck.rotation.x = neckSpec.ang;
+  rig.neck = neck;
+  rig.neckAngle = neckSpec.ang;
+  tools.joint(neck, neckSpec.r * 1.05, main, 0, 0, 0);
+  addMesh(THREE, neck, new THREE.CylinderGeometry(neckSpec.r2 || neckSpec.r * 0.85, neckSpec.r, neckSpec.len, 14).translate(0, neckSpec.len / 2, 0), main);
+  const head = tools.pivot(neck, 0, neckSpec.len, 0, new THREE.Vector3(0, 0.06, 0.08).multiplyScalar(rig.size));
+  head.rotation.x = -neckSpec.ang + (headSpec.down || 0);
+  rig.head = head;
+  rig.headAngle = head.rotation.x;
+  tools.joint(head, neckSpec.r2 || neckSpec.r * 0.85, main, 0, 0, 0);
+  tools.ball(head, headSpec.r, main, 0, headSpec.r * 0.25, headSpec.r * 0.25, headSpec.s[0], headSpec.s[1], headSpec.s[2]);
+  const snoutZ = headSpec.r * 0.25 + headSpec.r * headSpec.s[2] * 0.55;
+  const snout = addMesh(THREE, head, new THREE.CylinderGeometry(headSpec.sr2, headSpec.sr1, headSpec.sl, 14).rotateX(Math.PI / 2), headSpec.muzzle ? tools.material(headSpec.muzzle) : main, 0, headSpec.r * (headSpec.sy ?? 0), snoutZ + headSpec.sl / 2);
+  snout.scale.set(1, headSpec.sq || 1, 1);
+  tools.ball(head, headSpec.sr2 * 1.02, nose, 0, headSpec.r * (headSpec.sy ?? 0) + headSpec.sr2 * 0.1, snoutZ + headSpec.sl, 1, 0.85 * (headSpec.sq || 1), 0.45);
+  const jaw = tools.pivot(head, 0, headSpec.r * (headSpec.sy ?? 0) - headSpec.sr1 * 0.55 * (headSpec.sq || 1), snoutZ - headSpec.sr1 * 0.2, new THREE.Vector3(0, -0.04, 0.04).multiplyScalar(rig.size));
+  rig.jaw = jaw;
+  addMesh(THREE, jaw, new THREE.CylinderGeometry(headSpec.sr2 * 0.7, headSpec.sr1 * 0.75, headSpec.sl * 0.92, 12).rotateX(Math.PI / 2).translate(0, 0, headSpec.sl * 0.46), belly).scale.set(1, 0.45, 1);
+  const blood = tools.ball(jaw, headSpec.sr2 * 0.9, rig.woundMaterial || (rig.woundMaterial = new THREE.MeshStandardMaterial({ color: 6950924, roughness: 0.3 })), 0, 0, headSpec.sl * 0.9, 1.1, 0.6, 0.6);
+  tools.eyes(head, headSpec.r * 0.13, headSpec.r * headSpec.s[0] * 0.52, headSpec.r * 0.5, headSpec.r * 0.25 + headSpec.r * headSpec.s[2] * 0.55);
+  const ears = spec.ears;
+  for (const side of [-1, 1]) {
+    const earGroup = tools.pivot(head, side * headSpec.r * headSpec.s[0] * 0.55, headSpec.r * (0.25 + headSpec.s[1] * 0.75), headSpec.r * 0.1, new THREE.Vector3(side * 0.04, 0.04, 0).multiplyScalar(rig.size));
+    rig.ears.push(earGroup);
+    if (ears.t === "cone") addMesh(THREE, earGroup, new THREE.ConeGeometry(ears.s * 0.45, ears.s, 8).translate(0, ears.s / 2, 0), main, 0, 0, 0, ears.fwd || 0, 0, side * -(ears.tilt ?? 0.3));
+    else if (ears.t === "round") tools.ball(earGroup, ears.s, main, 0, ears.s * 0.4, 0, 1, 1, 0.35);
+    else if (ears.t === "flop") {
+      const ear = tools.ball(earGroup, ears.s, main, side * ears.s * 0.9, -ears.s * 0.1, 0, 1.5, 0.45, 0.7);
+      ear.rotation.z = side * -0.25;
+    }
+  }
+  return { neck, head, blood, neckSpec, headSpec };
+};
+var buildTail = (THREE, rig, spec, parts) => {
+  const tools = createRigTools(THREE, rig);
+  const tailSpec = spec.tail;
+  if (!tailSpec || !tailSpec.n) return;
+  const { bodyGroup, main, dark } = parts;
+  const { L, R: radius } = spec;
+  let parent = tools.pivot(bodyGroup, 0, radius * (spec.sy || 1) * (tailSpec.y ?? 0.3), -L / 2 * 0.95, new THREE.Vector3(0, 0.02, -0.12).multiplyScalar(rig.size));
+  parent.rotation.x = tailSpec.ang;
+  rig.tailRoot = parent;
+  const segmentLength = tailSpec.len / tailSpec.n;
+  for (let index = 0; index < tailSpec.n; index++) {
+    const radius1 = tailSpec.r * (1 - index / tailSpec.n * 0.6);
+    const radius2 = tailSpec.r * (1 - (index + 1) / tailSpec.n * 0.6);
+    tools.limb(parent, radius1, radius2, segmentLength, tailSpec.dark && index === tailSpec.n - 1 ? dark : main);
+    tools.joint(parent, radius1, main, 0, 0, 0);
+    rig.tail.push(parent);
+    if (index < tailSpec.n - 1) {
+      const next = tools.pivot(parent, 0, -segmentLength, 0);
+      next.rotation.x = tailSpec.curl || 0;
+      parent = next;
+    } else if (tailSpec.tuft) tools.ball(parent, tailSpec.r * 2.2, dark, 0, -segmentLength - tailSpec.r, 0, 1, 1.8, 1);
+  }
+  if (tailSpec.bushy) tools.ball(rig.tail[0], tailSpec.r * 2.2, dark, 0, -tailSpec.len * 0.55, 0, 1, tailSpec.len * 2.2 / tailSpec.r / 6, 1);
+};
+var buildInfectionParts = (THREE, rig, spec, parts) => {
+  const tools = createRigTools(THREE, rig);
+  const { bodyGroup, neck, blood, neckSpec } = parts;
+  const { L, R: radius } = spec;
+  const sideX = radius * (spec.sx || 1);
+  const sideY = radius * (spec.sy || 1);
+  const list = [blood];
+  const wound = (parent, size, x, y, z, sx, sy, sz) => tools.ball(parent, size, rig.woundMaterial || (rig.woundMaterial = new THREE.MeshStandardMaterial({ color: 5902862, roughness: 0.45 })), x, y, z, sx || 1, sy || 1, sz || 1);
+  list.push(wound(bodyGroup, radius * 0.28, sideX * 0.92, sideY * 0.15, L * 0.05, 0.35, 1, 1.3));
+  list.push(wound(bodyGroup, radius * 0.2, -sideX * 0.9, sideY * 0.3, -L * 0.2, 0.35, 1, 1.1));
+  list.push(wound(neck, neckSpec.r * 0.5, neckSpec.r * 0.85, neckSpec.len * 0.5, 0, 0.4, 1, 1));
+  const bone = tools.material(14274488, { roughness: 0.6 });
+  for (let index = 0; index < RIB_COUNT; index++) {
+    const rib = addMesh(THREE, bodyGroup, new THREE.TorusGeometry(radius * 0.95, radius * 0.035, 6, 16, Math.PI * 0.42), bone, sideX * 0.12, sideY * 0.05, L * 0.12 - index * L * 0.07, 0, Math.PI / 2, -0.3);
+    rib.scale.set(1, 1.02 * (spec.sy || 1), spec.sx || 1);
+    list.push(rib);
+  }
+  rig.infectionParts.push(...list);
+  list.forEach((part) => part.visible = false);
+};
+var buildQuadruped = (THREE, rig, options) => {
+  const spec = rig.species.body;
+  const tools = createRigTools(THREE, rig);
+  const colors = spec.c;
+  const texture = spec.texture ? createCoatTexture(THREE, options.document, spec.texture) : void 0;
+  const main = tools.material(texture ? 16777215 : colors.main, texture ? { map: texture } : void 0);
+  const belly = tools.material(colors.belly);
+  const dark = tools.material(colors.dark);
+  const nose = tools.material(colors.nose || colors.dark, { roughness: 0.4 });
+  rig.main = main;
+  rig.dark = dark;
+  const { bodyGroup, bodyHeight } = buildBodyAndLegs(THREE, rig, spec, main, belly, dark);
+  const { neck, head, blood, neckSpec, headSpec } = buildHead(THREE, rig, spec, { bodyGroup, main, belly, nose });
+  buildTail(THREE, rig, spec, { bodyGroup, main, dark });
+  options.extra?.({ THREE, rig, tools }, { bodyGroup, head, neck, main, belly, dark, L: spec.L, Rb: spec.R, bodyY: bodyHeight, hd: headSpec, nk: neckSpec });
+  if (rig.species.outcome === "turns") buildInfectionParts(THREE, rig, spec, { bodyGroup, neck, blood, neckSpec });
+  else blood.visible = false;
+  return rig;
+};
+
+// src/snake.ts
+var SEGMENT_COUNT = 34;
+var SEGMENT_LENGTH = 0.042;
+var buildSnake = (THREE, rig) => {
+  const tools = createRigTools(THREE, rig);
+  rig.size = 0.5;
+  rig.segmentLength = SEGMENT_LENGTH;
+  rig.segmentCount = SEGMENT_COUNT;
+  const primary = tools.material(8022602);
+  const secondary = tools.material(3812898);
+  const belly = tools.material(12101768);
+  rig.main = primary;
+  for (let index = 0; index < SEGMENT_COUNT; index++) {
+    const t = index / (SEGMENT_COUNT - 1);
+    const radius = 0.012 + 0.03 * Math.sin(Math.min(1, t * 1.15) * Math.PI) * (t < 0.1 ? 0.75 + t * 2.5 : 1) + (t < 0.05 ? 0.012 : 0);
+    const material = index % 4 === 1 || index % 4 === 2 ? secondary : primary;
+    const group = new THREE.Group();
+    rig.trunk.add(group);
+    const sphere = tools.ball(group, radius, material, 0, radius, 0, 1, 0.78, 1.5);
+    sphere.userData.joint = index % 3 === 0 ? 1 : 0;
+    if (index % 3 === 0) rig.joints.push(sphere);
+    rig.segments.push({ group, radius });
+  }
+  const head = new THREE.Group();
+  rig.trunk.add(head);
+  rig.head = head;
+  tools.ball(head, 0.032, primary, 0, 0.03, 0.025, 1.25, 0.6, 1.45);
+  tools.ball(head, 0.024, secondary, 0, 0.04, 0, 1.3, 0.4, 0.9);
+  tools.ball(head, 0.02, primary, 0, 0.028, 0.06, 0.85, 0.55, 1.1);
+  const jaw = new THREE.Group();
+  jaw.position.set(0, 0.018, 0);
+  head.add(jaw);
+  rig.jaw = jaw;
+  tools.ball(jaw, 0.026, belly, 0, 0, 0.035, 1.1, 0.35, 1.5);
+  tools.eyes(head, 6e-3, 0.03, 0.04, 0.045);
+  rig.tongue = addMesh(THREE, head, new THREE.BoxGeometry(4e-3, 2e-3, 0.05), tools.material(11542560), 0, 0.024, 0.1);
+  return rig;
+};
+
+// src/visual-state.ts
+var INFECTED_TINT = 8227430;
+var POOL_COLOR = 3803142;
+var applyVisualState = (THREE, rig, state) => {
+  rig.infected = state === "infected";
+  rig.dead = state === "dead";
+  const tint = new THREE.Color(INFECTED_TINT);
+  rig.materials.forEach((material) => {
+    if (material === rig.eyeMaterial || material === rig.woundMaterial) return;
+    material.color.copy(material.userData.base);
+    if (rig.infected) material.color.lerp(tint, 0.45).multiplyScalar(0.72);
+  });
+  const eye = rig.eyeMaterial;
+  if (eye) {
+    if (rig.infected) {
+      eye.color.set(14473392);
+      eye.emissive = new THREE.Color(9078368);
+      eye.emissiveIntensity = 0.8;
+    } else {
+      eye.color.copy(eye.userData.base);
+      eye.emissive = new THREE.Color(0);
+    }
+  }
+  rig.infectionParts.forEach((part) => part.visible = rig.infected);
+  const firstEar = rig.ears[0];
+  if (firstEar) firstEar.visible = !rig.infected;
+  if (!rig.dead) {
+    rig.root.rotation.z = 0;
+    rig.root.position.y = 0;
+  }
+  if (rig.pool) {
+    rig.pool.visible = rig.dead;
+    return;
+  }
+  if (!rig.dead) return;
+  const pool = new THREE.Mesh(new THREE.CircleGeometry(1, 22).rotateX(-Math.PI / 2), new THREE.MeshStandardMaterial({ color: POOL_COLOR, roughness: 0.25 }));
+  pool.position.set(rig.home.x, 5e-3, rig.home.z + 0.1);
+  pool.receiveShadow = true;
+  pool.scale.setScalar(rig.size * 0.45);
+  rig.root.parent?.add(pool);
+  rig.pool = pool;
+};
+
+// src/views.ts
+var setJointView = (rig, on, jointMaterial) => {
+  rig.materials.forEach((material) => {
+    if (material === rig.eyeMaterial) return;
+    material.transparent = on;
+    material.opacity = on ? 0.28 : 1;
+    material.depthWrite = !on;
+    material.needsUpdate = true;
+  });
+  rig.joints.forEach((joint) => {
+    var _a;
+    if (on) (_a = joint.userData).restMaterial ?? (_a.restMaterial = joint.material);
+    joint.material = on ? jointMaterial : joint.userData.restMaterial;
+    joint.renderOrder = on ? 2 : 0;
+  });
+};
+var setSplit = (rig, on) => {
+  rig.pivots.forEach((pivot) => {
+    pivot.group.userData.target = on ? pivot.rest.clone().add(pivot.offset) : pivot.rest.clone();
+  });
+};
+var updateSplit = (rig, delta) => {
+  rig.pivots.forEach((pivot) => {
+    const target = pivot.group.userData.target;
+    if (target) pivot.group.position.lerp(target, Math.min(1, delta * 5));
+  });
+};
+
+// src/line-up.ts
+import { lineUpLength } from "@adatechnology/game-animals";
+var lineUpAnimals = (rigs, options = {}) => {
+  const start = options.start ?? -19;
+  const gap = options.gap ?? 0.85;
+  let cursor = start;
+  for (const rig of rigs) {
+    const length = lineUpLength(rig.species.body);
+    cursor += length / 2;
+    rig.root.position.set(cursor, 0, 0);
+    rig.home = rig.root.position.clone();
+    rig.root.rotation.y = rig.species.body.kind === "snake" ? options.snakeYaw ?? 2.2 : options.yaw ?? 1.1;
+    cursor += length / 2 + gap;
+  }
+  const offset = -(cursor - gap + start) / 2;
+  for (const rig of rigs) {
+    rig.root.position.x += offset;
+    rig.home.x += offset;
+  }
+};
+
+// src/test-area/module.ts
+import { lineUpLength as lineUpLength2, visualStateOf as visualStateOf2 } from "@adatechnology/game-animals";
+
+// src/test-area/scenarios.ts
+import { visualStateOf } from "@adatechnology/game-animals";
+var SKIN_COUNT = 40;
+var createScenarios = (deps) => {
+  const scenario = (id, run) => ({ id, name: deps.text[id] ?? id, run });
+  const rate = () => 0.5;
+  return [
+    scenario("visual_states", ({ expect }) => {
+      const animals = deps.ensure();
+      for (const species of deps.species()) {
+        const rig = animals.build(species);
+        animals.setVisualState(rig, "infected");
+        expect(rig.infected && !rig.dead, `${species.id}: infected`);
+        animals.setVisualState(rig, "dead");
+        expect(rig.dead && !rig.infected, `${species.id}: dead`);
+        animals.setVisualState(rig, "alive");
+        expect(!rig.dead && !rig.infected, `${species.id}: alive again`);
+      }
+    }),
+    scenario("gait_moves_legs", ({ expect }) => {
+      const animals = deps.ensure();
+      const species = deps.species().find((entry) => entry.body.kind === "quadruped");
+      if (!species) return expect(false, "no quadruped among the species");
+      const rig = animals.build(species);
+      animals.animate(rig, { time: 0, delta: 0, clip: "walk" });
+      const before = rig.legs.map((leg) => leg.hip.rotation.x);
+      animals.animate(rig, { time: 0.4, delta: 0.4, clip: "walk" });
+      expect(rig.legs.some((leg, index) => leg.hip.rotation.x !== before[index]), `${species.id}: a walk step swings a hip`);
+    }),
+    scenario("outbreak_rule", ({ expect }) => {
+      const turns = deps.species().find((entry) => entry.outcome === "turns");
+      const immune = deps.species().find((entry) => entry.outcome === "immune");
+      const on = deps.rebuildOutbreak(true);
+      if (!on || !turns) return expect(false, "no outbreak rule or no species that turns");
+      expect(on.bite(turns.id, rate, 0) !== void 0, `a bite on ${turns.id} starts a fate with the rule on`);
+      if (immune) expect(on.bite(immune.id, rate, 0) === void 0, `${immune.id} shrugs the bite off`);
+      const off = deps.rebuildOutbreak(false);
+      expect(off?.bite(turns.id, rate, 0) === void 0, "with the rule off a bite does nothing");
+      deps.rebuildOutbreak(true);
+    }),
+    scenario("carcass_lure", ({ expect }) => {
+      const outbreak = deps.rebuildOutbreak(true);
+      const dies = deps.species().find((entry) => entry.outbreak?.carcass);
+      if (!outbreak || !dies) return expect(false, "no outbreak rule or no species that leaves a carcass");
+      const carcass = outbreak.carcass(dies.id, [0, 0, 0], 0);
+      expect(carcass !== void 0, `${dies.id} leaves a carcass`);
+      if (!carcass) return;
+      expect(outbreak.lures(carcass, carcass.lureRadiusMetres - 1, 1), "a zombie inside the radius is drawn");
+      expect(!outbreak.lures(carcass, carcass.lureRadiusMetres + 1, 1), "a zombie outside it is not");
+    }),
+    scenario("bite_to_turn_timer", ({ expect }) => {
+      const outbreak = deps.rebuildOutbreak(true);
+      const turns = deps.species().find((entry) => entry.outcome === "turns");
+      if (!outbreak || !turns) return expect(false, "no outbreak rule or no species that turns");
+      const fate = outbreak.bite(turns.id, rate, 0);
+      if (!fate) return expect(false, "the bite took");
+      expect(outbreak.stateOf(fate, 0) === "incubating", "it incubates at first");
+      expect(outbreak.stateOf(fate, fate.dueAt + 1) === "turned", "it has turned once the time is up (the bench clock runs it accelerated)");
+      expect(visualStateOf(turns.outcome, true) === "infected", "and shows the infected look");
+    }),
+    scenario("skins_40", ({ expect }) => {
+      const result = deps.skins();
+      expect(result.count === SKIN_COUNT, `${SKIN_COUNT} animals are in the field`, { count: result.count });
+      expect(result.meshes.drawCalls <= SKIN_COUNT + 16, "the skins are about one draw call each", result.meshes);
+      expect(result.nodes > 0, "each skin keeps the nodes the animation moves", { nodes: result.nodes });
+      deps.clearSkins();
+    })
+  ];
+};
+
+// src/test-area/text.ts
+var TEXT = {
+  en: {
+    group: "Animals",
+    name: "Animals area",
+    controls: { visual_state: "Visual state", gait: "Gait", speed: "Animation speed", outbreak: "Outbreak rule", time_scale: "Bite clock" },
+    hints: {
+      visual_state: "The look of every animal: alive, infected (grey coat, glowing eyes, wounds) or dead (lying down, a pool of blood)",
+      gait: "idle, walk or run; the cycle of each species runs at its own rate",
+      outbreak: "Off: a bite does nothing. On: a species that turns incubates and turns, one that dies dies, the rest shrug it off",
+      time_scale: "Game seconds per real second for the bite timers (60: ten minutes pass in ten seconds)"
+    },
+    options: { visual_state: { alive: "Alive", infected: "Infected", dead: "Dead" }, gait: { idle: "Idle", walk: "Walk", run: "Run" } },
+    actions: { bite_all: "Bite every animal", recover: "Heal every animal", skin_40: "Add 40 animals as node skins", clear_skins: "Remove the skins" },
+    layers: { joints: "Joints", split: "Split view", sound_range: "Sound range", carcass_lure: "Carcass lure radius" },
+    metrics: { animals: "Animals", draw_calls: "Draw calls", triangles: "Triangles", nodes_per_skin: "Nodes per skin", incubating: "Incubating", turned: "Turned", dead: "Dead" },
+    scenarios: {
+      visual_states: "Alive, infected and dead for every species",
+      gait_moves_legs: "The gait moves the legs",
+      outbreak_rule: "Outbreak rule on and off",
+      carcass_lure: "A carcass lures zombies within its radius",
+      bite_to_turn_timer: "Bite, incubation, turn (accelerated)",
+      skins_40: "40 animals as node skins"
+    }
+  },
+  "pt-BR": {
+    group: "Animais",
+    name: "\xC1rea de animais",
+    controls: { visual_state: "Estado visual", gait: "Andar", speed: "Velocidade da anima\xE7\xE3o", outbreak: "Regra de surto", time_scale: "Rel\xF3gio da mordida" },
+    hints: {
+      visual_state: "O aspecto de todos os bichos: vivo, infectado (pelo cinza, olhos brilhando, feridas) ou morto (deitado, po\xE7a de sangue)",
+      gait: "idle, walk ou run; o ciclo de cada esp\xE9cie anda no seu ritmo",
+      outbreak: "Desligada: a mordida n\xE3o faz nada. Ligada: a esp\xE9cie que vira incuba e vira, a que morre morre, as outras n\xE3o sentem",
+      time_scale: "Segundos de jogo por segundo real nos prazos da mordida (60: dez minutos passam em dez segundos)"
+    },
+    options: { visual_state: { alive: "Vivo", infected: "Infectado", dead: "Morto" }, gait: { idle: "Parado", walk: "Andando", run: "Correndo" } },
+    actions: { bite_all: "Morder todos os bichos", recover: "Curar todos os bichos", skin_40: "P\xF4r 40 bichos como pele de n\xF3s", clear_skins: "Tirar as peles" },
+    layers: { joints: "Juntas", split: "Vista aberta", sound_range: "Alcance do som", carcass_lure: "Raio de atra\xE7\xE3o da carca\xE7a" },
+    metrics: { animals: "Bichos", draw_calls: "Chamadas de desenho", triangles: "Tri\xE2ngulos", nodes_per_skin: "N\xF3s por pele", incubating: "Incubando", turned: "Viraram", dead: "Morreram" },
+    scenarios: {
+      visual_states: "Vivo, infectado e morto em cada esp\xE9cie",
+      gait_moves_legs: "O andar mexe as pernas",
+      outbreak_rule: "Regra de surto ligada e desligada",
+      carcass_lure: "A carca\xE7a atrai zumbis dentro do raio",
+      bite_to_turn_timer: "Mordida, incuba\xE7\xE3o, vira (acelerado)",
+      skins_40: "40 bichos como pele de n\xF3s"
+    }
+  }
+};
+
+// src/test-area/module.ts
+var ANIMALS_AREA_ID = "animals_area";
+var ANIMAL_ITEM_PREFIX = "animal_";
+var SKIN_COUNT2 = 40;
+var SKIN_FIELD = { x0: -18, z0: -10, columns: 8, gap: 4.5 };
+var DEFAULT_TIME_SCALE = 60;
+function createAnimalsTestModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const text = TEXT[locale] ?? TEXT["pt-BR"];
+  const species = options.species ?? [];
+  const settings = { visual: "alive", gait: "walk", speed: 1, outbreak: true, timeScale: DEFAULT_TIME_SCALE };
+  let three = null;
+  let animals = null;
+  let host = null;
+  let outbreak = null;
+  let time = 0;
+  let clock = 0;
+  let skinGroup = null;
+  let skins = [];
+  let rings = [];
+  const placed = /* @__PURE__ */ new Map();
+  const random = () => 0.5;
+  const drawSeed = options.seed ?? 7;
+  const bitten = () => ({ turned: [...placed.values()].filter((p) => p.counted === "turned").length, dead: [...placed.values()].filter((p) => p.counted === "dead").length });
+  const ensure = (THREE) => {
+    three = THREE;
+    animals ?? (animals = createAnimalsThree(THREE, { seed: drawSeed, ...options.document ? { document: options.document } : {} }));
+    return animals;
+  };
+  const rebuildOutbreak = () => {
+    outbreak = options.createOutbreak ? options.createOutbreak({ species, enabled: settings.outbreak, timeScale: settings.timeScale }) : null;
+  };
+  rebuildOutbreak();
+  const item = (animal) => ({
+    id: `${ANIMAL_ITEM_PREFIX}${animal.id}`,
+    name: animal.name[locale] ?? animal.id,
+    movable: false,
+    build: (THREE) => {
+      const rig = ensure(THREE).build(animal);
+      placed.set(rig.root.uuid, { id: rig.root.uuid, rig });
+      if (settings.visual !== "alive") animals?.setVisualState(rig, settings.visual);
+      return rig.root;
+    }
+  });
+  const statusOf = (entry) => {
+    if (!entry.fate || !outbreak) return;
+    const state = outbreak.stateOf(entry.fate, clock);
+    if (state === "incubating") return;
+    entry.counted = state === "turned" ? "turned" : "dead";
+    animals?.setVisualState(entry.rig, visualStateOf2(entry.rig.species.outcome, true, state === "dead"));
+  };
+  const clearRings = () => {
+    for (const ring of rings) ring.parent?.remove(ring);
+    rings = [];
+  };
+  const refreshLayers = () => {
+    if (!host?.bench || !animals || !three) return;
+    clearRings();
+    for (const entry of placed.values()) {
+      animals.setJointView(entry.rig, host.bench.layer("joints"));
+      animals.setSplit(entry.rig, host.bench.layer("split"));
+    }
+    const ring = (radius, color, parent) => {
+      const mesh = new three.Mesh(new three.RingGeometry(radius - 0.15, radius, 96).rotateX(-Math.PI / 2), new three.MeshBasicMaterial({ color, transparent: true, opacity: 0.55, depthWrite: false }));
+      mesh.position.y = 0.03;
+      parent.add(mesh);
+      rings.push(mesh);
+    };
+    for (const entry of placed.values()) {
+      if (!entry.rig.root.parent) continue;
+      const radius = entry.rig.species.soundRangeMetres;
+      if (host.bench.layer("sound_range") && radius) ring(radius, 4500223, entry.rig.root);
+      const lure = entry.rig.species.outbreak?.carcass?.lureRadiusMetres;
+      if (host.bench.layer("carcass_lure") && lure) ring(lure, 16733491, entry.rig.root);
+    }
+  };
+  const addSkins = () => {
+    if (!animals || !three || !host) return;
+    skinGroup ?? (skinGroup = new three.Group());
+    if (!skinGroup.parent) host.scene.add(skinGroup);
+    for (let index = skins.length; index < SKIN_COUNT2; index++) {
+      const animal = species[index % Math.max(1, species.length)];
+      const rig = animals.build(animal);
+      const skin = animals.createSkin(rig);
+      rig.root.position.set(SKIN_FIELD.x0 + index % SKIN_FIELD.columns * SKIN_FIELD.gap, 0, SKIN_FIELD.z0 - Math.floor(index / SKIN_FIELD.columns) * SKIN_FIELD.gap);
+      rig.root.traverse((object) => {
+        if (object.isMesh) object.visible = false;
+      });
+      skinGroup.add(rig.root, skin.mesh);
+      skins.push({ rig, skin });
+    }
+  };
+  const clearSkins = () => {
+    skinGroup?.parent?.remove(skinGroup);
+    skinGroup = null;
+    skins = [];
+  };
+  const applyVisual = () => {
+    for (const entry of placed.values()) {
+      if (entry.fate) continue;
+      animals?.setVisualState(entry.rig, settings.visual);
+    }
+  };
+  const onChange = (change) => {
+    if (change.kind === "layer") return refreshLayers();
+    if (change.kind === "action") {
+      if (change.id === "bite_all") {
+        for (const entry of placed.values()) {
+          entry.fate = outbreak?.bite(entry.rig.species.id, random, clock);
+          if (entry.fate) animals?.setVisualState(entry.rig, visualStateOf2(entry.rig.species.outcome, true));
+        }
+      } else if (change.id === "recover") {
+        for (const entry of placed.values()) {
+          delete entry.fate;
+          delete entry.counted;
+          animals?.setVisualState(entry.rig, settings.visual);
+        }
+      } else if (change.id === "skin_40") addSkins();
+      else if (change.id === "clear_skins") clearSkins();
+      return;
+    }
+    switch (change.id) {
+      case "visual_state":
+        settings.visual = String(change.value);
+        applyVisual();
+        break;
+      case "gait":
+        settings.gait = String(change.value);
+        break;
+      case "speed":
+        settings.speed = Number(change.value);
+        break;
+      case "outbreak":
+        settings.outbreak = Boolean(change.value);
+        if (outbreak) outbreak.enabled = settings.outbreak;
+        break;
+      case "time_scale":
+        settings.timeScale = Number(change.value);
+        rebuildOutbreak();
+        break;
+      default:
+        break;
+    }
+  };
+  const frame = (dt) => {
+    time += dt * settings.speed;
+    clock += dt;
+    for (const [id, entry] of placed) {
+      if (!entry.rig.root.parent) {
+        placed.delete(id);
+        continue;
+      }
+      statusOf(entry);
+      animals?.animate(entry.rig, { time, delta: dt * settings.speed, clip: settings.gait, split: host?.bench?.layer("split") ?? false });
+      animals?.updateSplit(entry.rig, dt);
+    }
+    for (const { rig, skin } of skins) {
+      animals?.animate(rig, { time, delta: dt * settings.speed, clip: settings.gait });
+      rig.root.updateMatrixWorld(true);
+      skin.update();
+    }
+  };
+  const countMeshes = (only) => {
+    let drawCalls = 0;
+    let triangles = 0;
+    const count = (root) => root.traverse((object) => {
+      const mesh = object;
+      if (!mesh.isMesh || !mesh.visible) return;
+      drawCalls += 1;
+      const geometry = mesh.geometry;
+      triangles += geometry.index ? geometry.index.count / 3 : geometry.attributes.position.count / 3;
+    });
+    if (only !== "skins") for (const entry of placed.values()) count(entry.rig.root);
+    for (const { skin } of skins) count(skin.mesh);
+    return { drawCalls, triangles: Math.round(triangles) };
+  };
+  const deps = {
+    text: text.scenarios,
+    species: () => species,
+    ensure: () => ensure(three ?? host?.THREE),
+    outbreak: () => outbreak,
+    rebuildOutbreak: (enabled) => {
+      settings.outbreak = enabled;
+      rebuildOutbreak();
+      return outbreak;
+    },
+    skins: () => {
+      ensure(three ?? host?.THREE);
+      addSkins();
+      return { count: skins.length, meshes: countMeshes("skins"), nodes: skins[0]?.skin.nodes.length ?? 0, rich: skins[0]?.rig.triangles ?? 0 };
+    },
+    clearSkins
+  };
+  return {
+    id: ANIMALS_AREA_ID,
+    name: text.name,
+    group: text.group,
+    get placed() {
+      return placed;
+    },
+    items: () => species.map(item),
+    area: () => {
+      const gap = 0.85;
+      let cursor = 0;
+      const spots = species.map((animal) => {
+        const length = lineUpLength2(animal.body);
+        const x = cursor + length / 2;
+        cursor += length + gap;
+        return { animal, x };
+      });
+      const offset = -(cursor - gap) / 2;
+      return {
+        placements: spots.map(({ animal, x }) => ({ item: `${ANIMAL_ITEM_PREFIX}${animal.id}`, position: [x + offset, 0, 0], rotationY: animal.body.kind === "snake" ? 2.2 : 1.1 })),
+        view: { eye: [0, 4, Math.max(10, (cursor - gap) * 0.55)], target: [0, 0.6, 0] }
+      };
+    },
+    controls: () => [
+      { kind: "choice", id: "visual_state", name: text.controls.visual_state, hint: text.hints.visual_state, options: ["alive", "infected", "dead"].map((id) => ({ id, name: text.options.visual_state[id] })), default: "alive" },
+      { kind: "choice", id: "gait", name: text.controls.gait, hint: text.hints.gait, options: ["idle", "walk", "run"].map((id) => ({ id, name: text.options.gait[id] })), default: "walk" },
+      { kind: "number", id: "speed", name: text.controls.speed, min: 0, max: 4, step: 0.25, default: 1 },
+      { kind: "boolean", id: "outbreak", name: text.controls.outbreak, hint: text.hints.outbreak, default: true },
+      { kind: "number", id: "time_scale", name: text.controls.time_scale, hint: text.hints.time_scale, min: 1, max: 600, step: 1, default: DEFAULT_TIME_SCALE },
+      { kind: "action", id: "bite_all", name: text.actions.bite_all },
+      { kind: "action", id: "recover", name: text.actions.recover },
+      { kind: "action", id: "skin_40", name: text.actions.skin_40 },
+      { kind: "action", id: "clear_skins", name: text.actions.clear_skins }
+    ],
+    layers: () => ["joints", "split", "sound_range", "carcass_lure"].map((id) => ({ id, name: text.layers[id], default: false })),
+    metrics: () => [
+      { id: "animals", name: text.metrics.animals, read: () => placed.size + skins.length },
+      { id: "draw_calls", name: text.metrics.draw_calls, read: () => countMeshes().drawCalls },
+      { id: "triangles", name: text.metrics.triangles, read: () => countMeshes().triangles },
+      { id: "nodes_per_skin", name: text.metrics.nodes_per_skin, read: () => skins[0]?.skin.nodes.length ?? 0 },
+      { id: "incubating", name: text.metrics.incubating, read: () => [...placed.values()].filter((p) => p.fate && !p.counted).length },
+      { id: "turned", name: text.metrics.turned, read: () => bitten().turned },
+      { id: "dead", name: text.metrics.dead, read: () => bitten().dead }
+    ],
+    scenarios: () => createScenarios(deps),
+    attach(lent) {
+      host = lent;
+      ensure(lent.THREE);
+      const stopChange = lent.bench?.onChange(onChange);
+      const stopFrame = lent.onFrame(frame);
+      return () => {
+        stopChange?.();
+        stopFrame();
+        clearRings();
+        clearSkins();
+        host = null;
+      };
+    }
+  };
+}
+
+// src/index.ts
+var countTriangles = (root) => {
+  let triangles = 0;
+  root.traverse((object) => {
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    const geometry = mesh.geometry;
+    triangles += geometry.index ? geometry.index.count / 3 : geometry.attributes.position.count / 3;
+  });
+  return Math.round(triangles);
+};
+var createAnimalsThree = (THREE, options = {}) => {
+  const random = options.random ?? createStream(options.seed ?? 7);
+  const documentOf = () => {
+    const found = options.document ?? globalThis.document;
+    if (!found) throw new Error("game-animals-three: a species with a coat texture needs `options.document` (no global document found)");
+    return found;
+  };
+  const jointMaterial = new THREE.MeshStandardMaterial({ color: 14722376, emissive: 14722376, emissiveIntensity: 0.8, roughness: 0.4 });
+  const gaits = GAIT_PHASES;
+  return {
+    jointMaterial,
+    build(species, buildOptions = {}) {
+      const rig = createRig(THREE, species, { phase: buildOptions.phase ?? random() * 6 });
+      if (species.body.kind === "snake") buildSnake(THREE, rig);
+      else if (species.body.kind === "bird") buildBird(THREE, rig, { extra: BIRD_EXTRAS[species.id] });
+      else buildQuadruped(THREE, rig, { document: species.body.texture ? documentOf() : void 0, extra: QUADRUPED_EXTRAS[species.id] });
+      rig.triangles = countTriangles(rig.root);
+      rig.root.traverse((object) => {
+        if (object.isMesh) object.userData.speciesId = species.id;
+      });
+      return rig;
+    },
+    animate(rig, params) {
+      const kind = rig.species.body.kind;
+      if (kind === "snake") animateSnake(THREE, rig, params);
+      else if (kind === "bird") animateBird(rig, params);
+      else animateQuadruped(rig, params, gaits);
+    },
+    setVisualState: (rig, state) => applyVisualState(THREE, rig, state),
+    setJointView: (rig, on) => setJointView(rig, on, jointMaterial),
+    setSplit,
+    updateSplit,
+    createSkin: (rig) => createNodeSkin(THREE, rig.root, { nodes: collectReferencedNodes(rig, ["species"]) })
+  };
+};
+export {
+  ANIMALS_AREA_ID,
+  ANIMAL_ITEM_PREFIX,
+  BIRD_EXTRAS,
+  QUADRUPED_EXTRAS,
+  applyVisualState,
+  createAnimalsTestModule,
+  createAnimalsThree,
+  createCoatTexture,
+  lineUpAnimals,
+  profileGeometry,
+  setJointView,
+  setSplit,
+  updateSplit
+};
+//# sourceMappingURL=index.js.map