@adatechnology/game-characters 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,2421 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/data/body.json
+var body_default = {
+  guide: {
+    heightMetres: 1.8,
+    shoulderWidthMetres: 0.61,
+    shoulderWidthWomanMetres: 0.57,
+    shoulderHeightMetres: 1.475,
+    headToHeight: 0.1667
+  },
+  teamGame: {
+    source: "G 65336 J (shoulders +-0.24 m)",
+    joints: {
+      quadril: [
+        0,
+        0.95,
+        0
+      ],
+      pescoco: [
+        0,
+        1.52,
+        0
+      ],
+      ombroE: [
+        -0.24,
+        1.44,
+        0
+      ],
+      ombroD: [
+        0.24,
+        1.44,
+        0
+      ],
+      cotoveloE: [
+        -0.27,
+        1.13,
+        0
+      ],
+      cotoveloD: [
+        0.27,
+        1.13,
+        0
+      ],
+      coxaE: [
+        -0.1,
+        0.92,
+        0
+      ],
+      coxaD: [
+        0.1,
+        0.92,
+        0
+      ],
+      joelhoE: [
+        -0.1,
+        0.5,
+        0
+      ],
+      joelhoD: [
+        0.1,
+        0.5,
+        0
+      ]
+    },
+    heightMetres: 1.8
+  },
+  lodDistancesMetres: [
+    18,
+    55
+  ],
+  triangleBudget: {
+    lod0: 2500,
+    lod1: 800,
+    lod2: 250
+  }
+};
+
+// src/body/body-spec.ts
+var JOINT_IDS = ["hip", "spine", "neck", "head", "jaw", "shoulderL", "shoulderR", "elbowL", "elbowR", "wristL", "wristR", "hipL", "hipR", "kneeL", "kneeR", "ankleL", "ankleR"];
+var SEGMENT_RADIUS = {
+  head: 0.1,
+  jaw: 0.05,
+  neck: 0.06,
+  torso: 0.17,
+  pelvis: 0.16,
+  upperArm: 0.085,
+  forearm: 0.065,
+  hand: 0.05,
+  thigh: 0.1,
+  shin: 0.08,
+  foot: 0.05
+};
+var { guide } = body_default;
+var shoulderX = guide.shoulderWidthMetres / 2;
+var shoulderY = guide.shoulderHeightMetres;
+var GUIDE = {
+  id: "guide",
+  heightMetres: guide.heightMetres,
+  joints: {
+    hip: [0, 0.92, 0],
+    spine: [0, 1.05, 0],
+    neck: [0, 1.56, 0],
+    head: [0, 1.64, 0],
+    jaw: [0, 1.66, 0.06],
+    shoulderL: [shoulderX, shoulderY, 0],
+    shoulderR: [-shoulderX, shoulderY, 0],
+    elbowL: [shoulderX, shoulderY - 0.31, 0],
+    elbowR: [-shoulderX, shoulderY - 0.31, 0],
+    wristL: [shoulderX, shoulderY - 0.61, 0],
+    wristR: [-shoulderX, shoulderY - 0.61, 0],
+    hipL: [0.105, 0.9, 0],
+    hipR: [-0.105, 0.9, 0],
+    kneeL: [0.105, 0.48, 0],
+    kneeR: [-0.105, 0.48, 0],
+    ankleL: [0.105, 0.1, 0],
+    ankleR: [-0.105, 0.1, 0]
+  },
+  segmentRadius: SEGMENT_RADIUS
+};
+var J = body_default.teamGame.joints;
+var below = (point, drop) => [point[0], point[1] - drop, point[2]];
+var TEAM_GAME = {
+  id: "team-game",
+  heightMetres: body_default.teamGame.heightMetres,
+  joints: {
+    hip: J.quadril,
+    spine: J.quadril,
+    neck: J.pescoco,
+    head: J.pescoco,
+    jaw: [0, J.pescoco[1] + 0.08, 0.06],
+    shoulderL: J.ombroE,
+    shoulderR: J.ombroD,
+    elbowL: J.cotoveloE,
+    elbowR: J.cotoveloD,
+    wristL: below(J.cotoveloE, 0.3),
+    wristR: below(J.cotoveloD, 0.3),
+    hipL: J.coxaE,
+    hipR: J.coxaD,
+    kneeL: J.joelhoE,
+    kneeR: J.joelhoD,
+    ankleL: below(J.joelhoE, 0.42),
+    ankleR: below(J.joelhoD, 0.42)
+  },
+  segmentRadius: SEGMENT_RADIUS
+};
+var createBodySpec = (patch = {}, base = GUIDE) => ({
+  id: patch.id ?? base.id,
+  heightMetres: patch.heightMetres ?? base.heightMetres,
+  joints: { ...base.joints, ...patch.joints },
+  segmentRadius: { ...base.segmentRadius, ...patch.segmentRadius }
+});
+
+// src/corpses.ts
+var createCorpseLedger = (options) => {
+  const entries = [];
+  return {
+    entries,
+    get count() {
+      return entries.length;
+    },
+    add(data) {
+      if (entries.length < options.max) {
+        entries.push({ age: 0, data });
+        return void 0;
+      }
+      let oldest = 0;
+      for (let index = 1; index < entries.length; index++) if (entries[index].age > entries[oldest].age) oldest = index;
+      const replaced = entries[oldest].data;
+      entries[oldest] = { age: 0, data };
+      return replaced;
+    },
+    update(dt) {
+      const removed = [];
+      for (let index = 0; index < entries.length; index++) {
+        const entry = entries[index];
+        entry.age += dt;
+        if (entry.age <= options.seconds) continue;
+        removed.push(entry.data);
+        entries[index] = entries[entries.length - 1];
+        entries.pop();
+        index--;
+      }
+      return removed;
+    },
+    clear() {
+      entries.length = 0;
+    }
+  };
+};
+
+// src/body/body-state.ts
+import { MISSING_BITS } from "@adatechnology/game-contracts";
+
+// src/presets/team-game.json
+var team_game_default = {
+  id: "team-game",
+  segments: {
+    head: 40,
+    arm: 60,
+    leg: 80
+  },
+  calibers: {
+    "7_62x51": {
+      gameKey: "308",
+      name: "7,62\xD751 (.308)",
+      points: 75,
+      penetration: 4,
+      effectiveRangeMetres: 600,
+      noiseMetres: 130,
+      skullRange: 1,
+      class: "rifle"
+    },
+    "9x19": {
+      gameKey: "9x19",
+      name: "9\xD719 mm",
+      points: 35,
+      penetration: 1.2,
+      effectiveRangeMetres: 35,
+      noiseMetres: 60,
+      skullRange: 1,
+      class: "pistol"
+    },
+    "12ga_00buck": {
+      gameKey: "12ga",
+      name: "12 ga 00",
+      points: 12,
+      pellets: 9,
+      penetration: 0.5,
+      effectiveRangeMetres: 15,
+      noiseMetres: 90,
+      skullRange: 8,
+      class: "pistol"
+    },
+    "7_62x39": {
+      gameKey: "762x39",
+      name: "7,62\xD739 mm",
+      points: 55,
+      penetration: 3,
+      effectiveRangeMetres: 250,
+      noiseMetres: 110,
+      skullRange: 1,
+      class: "rifle"
+    }
+  },
+  regionCost: {
+    head: 0.7,
+    torso: 1,
+    bruteTorso: 2,
+    limb: 0.5
+  },
+  damageKeptPerBody: 0.75,
+  falloff: {
+    fullAtRange: 1,
+    atTwiceRange: 0.5
+  },
+  helmetAbsorbs: "pistol",
+  regions: [
+    "head",
+    "torso",
+    "armL",
+    "armR",
+    "legL",
+    "legR"
+  ]
+};
+
+// src/body/regions.ts
+var LIMB_REGIONS = ["head", "armL", "armR", "legL", "legR"];
+var REGION_HIT_POINTS = {
+  head: team_game_default.segments.head,
+  armL: team_game_default.segments.arm,
+  armR: team_game_default.segments.arm,
+  legL: team_game_default.segments.leg,
+  legR: team_game_default.segments.leg
+};
+var REGION_SEGMENTS = {
+  head: ["head", "jaw", "neck"],
+  torso: ["torso", "pelvis"],
+  armL: ["upperArmL", "forearmL", "handL"],
+  armR: ["upperArmR", "forearmR", "handR"],
+  legL: ["thighL", "shinL", "footL"],
+  legR: ["thighR", "shinR", "footR"]
+};
+var BODY_REGIONS = ["head", "torso", "armL", "armR", "legL", "legR"];
+var isBodyRegion = (value) => BODY_REGIONS.includes(value);
+
+// src/data/segments.json
+var segments_default = {
+  segments: [
+    {
+      id: "head",
+      region: "head",
+      hitPoints: 40,
+      multiplier: 3,
+      bleed: 40
+    },
+    {
+      id: "jaw",
+      region: "head",
+      hitPoints: 12,
+      multiplier: 2,
+      bleed: 8
+    },
+    {
+      id: "neck",
+      region: "head",
+      hitPoints: 25,
+      multiplier: 2,
+      bleed: 46
+    },
+    {
+      id: "torso",
+      region: "torso",
+      hitPoints: 150,
+      multiplier: 1,
+      bleed: 10
+    },
+    {
+      id: "pelvis",
+      region: "torso",
+      hitPoints: 90,
+      multiplier: 1,
+      bleed: 12
+    },
+    {
+      id: "upperArm",
+      region: "arm",
+      hitPoints: 45,
+      multiplier: 0.6,
+      bleed: 15
+    },
+    {
+      id: "forearm",
+      region: "arm",
+      hitPoints: 30,
+      multiplier: 0.6,
+      bleed: 8
+    },
+    {
+      id: "hand",
+      region: "arm",
+      hitPoints: 12,
+      multiplier: 0.6,
+      bleed: 3
+    },
+    {
+      id: "thigh",
+      region: "leg",
+      hitPoints: 55,
+      multiplier: 0.7,
+      bleed: 19
+    },
+    {
+      id: "shin",
+      region: "leg",
+      hitPoints: 40,
+      multiplier: 0.7,
+      bleed: 9
+    },
+    {
+      id: "foot",
+      region: "leg",
+      hitPoints: 15,
+      multiplier: 0.7,
+      bleed: 3
+    }
+  ],
+  regions: {
+    head: {
+      hitPoints: 40,
+      segmentSum: 77,
+      scale: 0.5195
+    },
+    arm: {
+      hitPoints: 60,
+      segmentSum: 87,
+      scale: 0.6897
+    },
+    leg: {
+      hitPoints: 80,
+      segmentSum: 110,
+      scale: 0.7273
+    }
+  },
+  arsenalWeapons: {
+    pistola: {
+      n: "Pistola 9\xD719",
+      dmg: 35,
+      pel: 1
+    },
+    fuzil: {
+      n: "Fuzil 7,62\xD739",
+      dmg: 55,
+      pel: 1
+    },
+    escopeta: {
+      n: "Escopeta 12 ga",
+      dmg: 12,
+      pel: 9
+    },
+    cinquenta: {
+      n: ".50 BMG",
+      dmg: 180,
+      pel: 1
+    },
+    granada: {
+      n: "Granada",
+      dmg: 300,
+      pel: 0
+    }
+  },
+  elenco: {
+    segments: {
+      head: {
+        hp: 40,
+        radius: 0.07
+      },
+      torso: {
+        hp: 120
+      },
+      pelvis: {
+        hp: 90
+      },
+      upperArm: {
+        hp: 60,
+        radius: 0.085
+      },
+      forearm: {
+        hp: 45,
+        radius: 0.065
+      },
+      hand: {
+        hp: 25,
+        radius: 0.05
+      },
+      thigh: {
+        hp: 80,
+        radius: 0.1
+      },
+      shin: {
+        hp: 55,
+        radius: 0.08
+      }
+    },
+    below: {
+      upperArm: [
+        "forearm",
+        "hand"
+      ],
+      forearm: [
+        "hand"
+      ],
+      thigh: [
+        "shin"
+      ]
+    },
+    falls: {
+      upperArm: "o bra\xE7o inteiro",
+      forearm: "o antebra\xE7o com a m\xE3o",
+      hand: "a m\xE3o",
+      thigh: "a perna inteira",
+      shin: "a canela com o p\xE9",
+      head: "a cabe\xE7a"
+    },
+    cutWeapons: [
+      {
+        id: "faca",
+        n: "Faca",
+        dmg: 22,
+        cut: 0.7
+      },
+      {
+        id: "facao",
+        n: "Fac\xE3o",
+        dmg: 55,
+        cut: 1
+      },
+      {
+        id: "machado",
+        n: "Machado",
+        dmg: 85,
+        cut: 1
+      },
+      {
+        id: "p9",
+        n: "Pistola 9 mm",
+        dmg: 30,
+        cut: 0.15
+      },
+      {
+        id: "e12",
+        n: "Espingarda 12",
+        dmg: 95,
+        cut: 0.75
+      },
+      {
+        id: "f762",
+        n: "Fuzil 7,62",
+        dmg: 65,
+        cut: 0.45
+      }
+    ]
+  },
+  severity: {
+    severAtCut: 0.5,
+    severAtDamageFraction: 0.9,
+    destroyAtDamageMultiple: 2,
+    limpAtHpFraction: 0.5,
+    splitAtDamage: 150,
+    headKillDamage: 20,
+    jawChance: 0.3,
+    jawDamage: 25,
+    headBitDamage: 60,
+    headBitShotgunMetres: 5
+  },
+  defaultCut: {
+    slash: 0.85,
+    blunt: 0,
+    explosive: 1,
+    ballistic: {
+      pistol: 0.15,
+      buckshot: 0.75,
+      rifle: 0.45
+    }
+  },
+  deathRule: {
+    default: "vitality-or-head",
+    options: [
+      "vitality-or-head",
+      "head-only"
+    ]
+  }
+};
+
+// src/body/segment-tree.ts
+var limb = (kind, side, joint, parent, slots) => {
+  const isArm2 = kind === "upperArm" || kind === "forearm" || kind === "hand";
+  const region = isArm2 ? side === "L" ? "armL" : "armR" : side === "L" ? "legL" : "legR";
+  return { id: `${kind}${side}`, kind, side, joint, region, slots, ...parent ? { parent } : {} };
+};
+var sideOf = (side) => [
+  limb("upperArm", side, `shoulder${side}`, "torso", ["arms"]),
+  limb("forearm", side, `elbow${side}`, `upperArm${side}`, ["arms"]),
+  limb("hand", side, `wrist${side}`, `forearm${side}`, ["hands"]),
+  limb("thigh", side, `hip${side}`, "pelvis", ["legs"]),
+  limb("shin", side, `knee${side}`, `thigh${side}`, ["legs"]),
+  limb("foot", side, `ankle${side}`, `shin${side}`, ["feet"])
+];
+var SEGMENT_TREE = [
+  { id: "pelvis", kind: "pelvis", joint: "hip", region: "torso", slots: ["torso"] },
+  { id: "torso", kind: "torso", joint: "spine", parent: "pelvis", region: "torso", slots: ["torso"] },
+  { id: "neck", kind: "neck", joint: "neck", parent: "torso", region: "head", slots: [] },
+  { id: "head", kind: "head", joint: "head", parent: "neck", region: "head", slots: ["head", "eyes"] },
+  { id: "jaw", kind: "jaw", joint: "jaw", parent: "head", region: "head", slots: [] },
+  ...sideOf("L"),
+  ...sideOf("R")
+];
+var SEGMENT_IDS = SEGMENT_TREE.map((node) => node.id);
+var NODES = new Map(SEGMENT_TREE.map((node) => [node.id, node]));
+var segmentNode = (id) => {
+  const node = NODES.get(id);
+  if (!node) throw new Error(`game-characters: unknown segment "${id}"`);
+  return node;
+};
+var isSegmentId = (value) => NODES.has(value);
+var segmentsBelow = (id) => {
+  const out = [];
+  const visit = (parent) => {
+    for (const node of SEGMENT_TREE) {
+      if (node.parent !== parent) continue;
+      out.push(node.id);
+      visit(node.id);
+    }
+  };
+  visit(id);
+  return out;
+};
+var SEGMENT_NUMBERS = Object.fromEntries(
+  segments_default.segments.map((entry) => [entry.id, { hitPoints: entry.hitPoints, multiplier: entry.multiplier, bleed: entry.bleed }])
+);
+
+// src/body/body-state.ts
+var createBodyState = ({ vitality, detail, crawling, hitPointsOf }) => ({
+  segments: SEGMENT_TREE.map((node) => {
+    const max = hitPointsOf(node.kind);
+    return { id: node.id, kind: node.kind, region: node.region, hp: max, max, status: "ok", attached: true, ...node.side ? { side: node.side } : {} };
+  }),
+  regions: { ...REGION_HIT_POINTS },
+  vitality,
+  maxVitality: vitality,
+  alive: true,
+  missing: 0,
+  limping: [],
+  crawl: crawling ?? false,
+  stunSeconds: 0,
+  pieces: [],
+  consumed: /* @__PURE__ */ new Set(),
+  detail
+});
+var segmentOf = (body, id) => {
+  const segment = body.segments.find((candidate) => candidate.id === id);
+  if (!segment) throw new Error(`game-characters: unknown segment "${id}"`);
+  return segment;
+};
+var LIMB_MASK = [
+  { ids: ["upperArmL", "forearmL"], lost: MISSING_BITS.armL, broken: MISSING_BITS.armLBroken },
+  { ids: ["upperArmR", "forearmR"], lost: MISSING_BITS.armR, broken: MISSING_BITS.armRBroken },
+  { ids: ["thighL", "shinL"], lost: MISSING_BITS.legL, broken: MISSING_BITS.legLBroken },
+  { ids: ["thighR", "shinR"], lost: MISSING_BITS.legR, broken: MISSING_BITS.legRBroken }
+];
+var missingFromSegments = (body) => {
+  let mask = 0;
+  if (!segmentOf(body, "head").attached) mask |= MISSING_BITS.head;
+  else if (!segmentOf(body, "jaw").attached) mask |= MISSING_BITS.jaw;
+  for (const limb2 of LIMB_MASK) {
+    const parts = limb2.ids.map((id) => segmentOf(body, id));
+    if (parts.some((part) => !part.attached)) mask |= limb2.lost;
+    else if (parts.some((part) => part.status === "broken")) mask |= limb2.broken;
+  }
+  return mask;
+};
+var regionsFromSegments = (body) => {
+  for (const region of LIMB_REGIONS) {
+    const parts = REGION_SEGMENTS[region].map((id) => segmentOf(body, id));
+    const left = parts.reduce((sum, part) => sum + (part.attached ? Math.max(0, part.hp) : 0), 0);
+    const total = parts.reduce((sum, part) => sum + part.max, 0);
+    body.regions[region] = REGION_HIT_POINTS[region] * left / total;
+  }
+  body.missing |= missingFromSegments(body);
+};
+var segmentsFromRegions = (body) => {
+  for (const region of LIMB_REGIONS) {
+    const share = Math.max(0, body.regions[region]) / REGION_HIT_POINTS[region];
+    for (const id of REGION_SEGMENTS[region]) {
+      const part = segmentOf(body, id);
+      if (part.attached) part.hp = Math.min(part.hp, part.max * share);
+    }
+  }
+};
+
+// src/body/describe.ts
+var BODY_MATERIAL = "flesh";
+var MASS_SHARE = {
+  head: 0.07,
+  jaw: 0.01,
+  neck: 0.02,
+  torso: 0.34,
+  pelvis: 0.14,
+  upperArm: 0.028,
+  forearm: 0.016,
+  hand: 6e-3,
+  thigh: 0.1,
+  shin: 0.045,
+  foot: 0.015
+};
+var ADULT_MASS_KG = 70;
+var LEAF_KINDS = /* @__PURE__ */ new Set(["head", "jaw", "hand", "foot"]);
+var firstChild = (node) => SEGMENT_TREE.find((candidate) => candidate.parent === node.id);
+var cylinderBetween = (from, to, radius) => {
+  const axis = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
+  const length = Math.max(1e-3, Math.hypot(axis[0], axis[1], axis[2]));
+  const [x, y, z] = [axis[0] / length, axis[1] / length, axis[2] / length];
+  return {
+    shape: { kind: "cylinder", radius, height: length },
+    position: [(from[0] + to[0]) / 2, (from[1] + to[1]) / 2, (from[2] + to[2]) / 2],
+    rotation: [Math.atan2(z, y), 0, -Math.asin(Math.max(-1, Math.min(1, x)))]
+  };
+};
+var partOf = (node, rig, body, massKg) => {
+  const joint = rig.joints[node.joint];
+  const radius = body.segmentRadius[node.kind] * (rig.height / body.heightMetres);
+  const mass = massKg * MASS_SHARE[node.kind];
+  const child = firstChild(node);
+  if (LEAF_KINDS.has(node.kind) || !child) {
+    const lift = node.kind === "head" ? radius : node.kind === "jaw" ? 0 : -radius;
+    return { id: node.id, material: BODY_MATERIAL, shape: { kind: "sphere", radius }, position: [joint[0], joint[1] + lift, joint[2]], mass, tags: ["body", node.kind] };
+  }
+  const placed = cylinderBetween(joint, rig.joints[child.joint], radius);
+  return { id: node.id, material: BODY_MATERIAL, ...placed, mass, tags: ["body", node.kind] };
+};
+var describeBody = ({ rig, body, build, name }) => {
+  const massKg = ADULT_MASS_KG * (rig.height / body.heightMetres) ** 3 * build;
+  const parts = SEGMENT_TREE.map((node) => partOf(node, rig, body, massKg));
+  const joints = SEGMENT_TREE.filter((node) => node.parent).map((node) => ({ id: `${node.parent}~${node.id}`, a: node.parent, b: node.id, kind: "fused", tools: [] }));
+  return { ...name ? { name } : {}, parts, joints, tags: ["character"] };
+};
+
+// src/body/object-state.ts
+var PART_STATUS = { ok: "intact", wounded: "damaged", broken: "damaged", severed: "collapsed", destroyed: "broken" };
+var BODY_TEMPERATURE_C = 37;
+var toObjectState = ({ id, name, position, rotation, body, spec }) => {
+  const groups = [body.segments.filter((segment) => segment.attached).map((segment) => segment.id)];
+  for (const piece of body.pieces) {
+    const left = piece.filter((part) => body.segments.find((segment) => segment.id === part)?.status !== "destroyed");
+    if (left.length > 0) groups.push(left);
+  }
+  const groupOf = (part) => groups.findIndex((group) => group.includes(part));
+  const parts = body.segments.map((segment) => {
+    const mass = spec.parts.find((part) => part.id === segment.id)?.mass ?? 0;
+    return {
+      id: segment.id,
+      material: "flesh",
+      status: PART_STATUS[segment.status],
+      hp: Math.max(0, segment.hp),
+      maxHp: segment.max,
+      mass,
+      temperature: BODY_TEMPERATURE_C,
+      burning: false,
+      fuel: 0,
+      char: 0,
+      melt: 0,
+      dents: [],
+      holes: [],
+      cracks: [],
+      group: groupOf(segment.id)
+    };
+  });
+  const joints = (spec.joints ?? []).map((joint) => {
+    const child = body.segments.find((segment) => segment.id === joint.b);
+    const parent = body.segments.find((segment) => segment.id === joint.a);
+    const open = child !== void 0 && parent !== void 0 && parent.attached !== child.attached;
+    return { id: joint.id ?? `${joint.a}~${joint.b}`, a: joint.a, b: joint.b, kind: joint.kind, hp: open ? 0 : 1, maxHp: 1, progress: 0, open, ...open ? { openedBy: "break" } : {} };
+  });
+  return {
+    id,
+    ...name ? { name } : {},
+    position: [...position],
+    rotation: [...rotation],
+    parts,
+    joints,
+    groups,
+    destroyed: false,
+    body: { alive: body.alive, vitality: body.vitality, missing: body.detail === "segments" ? body.missing | missingFromSegments(body) : body.missing, limp: body.limping.length > 0, crawl: body.crawl }
+  };
+};
+
+// src/body/rig.ts
+var GAME_BONES = {
+  torso: 0,
+  head: 1,
+  upperArmL: 2,
+  upperArmR: 3,
+  thighL: 4,
+  thighR: 5,
+  eyes: 6,
+  forearmL: 7,
+  forearmR: 8,
+  shinL: 9,
+  shinR: 10,
+  jaw: 11
+};
+var JOINT_PARENTS = {
+  hip: void 0,
+  spine: "hip",
+  neck: "spine",
+  head: "neck",
+  jaw: "head",
+  shoulderL: "spine",
+  shoulderR: "spine",
+  elbowL: "shoulderL",
+  elbowR: "shoulderR",
+  wristL: "elbowL",
+  wristR: "elbowR",
+  hipL: "hip",
+  hipR: "hip",
+  kneeL: "hipL",
+  kneeR: "hipR",
+  ankleL: "kneeL",
+  ankleR: "kneeR"
+};
+var createRig = ({ body, height, build }) => {
+  const scale = height / body.heightMetres;
+  const joints = Object.fromEntries(
+    JOINT_IDS.map((id) => {
+      const [x, y, z] = body.joints[id];
+      return [id, [x * scale * build, y * scale, z * scale]];
+    })
+  );
+  return { joints, parents: JOINT_PARENTS, gameBones: GAME_BONES, height };
+};
+
+// src/character.ts
+var DEFAULT_VITALITY = 100;
+var DEFAULT_STUN_SECONDS = 0.45;
+var NO_MULTIPLIERS = { head: 1, torso: 1, arms: 1, legs: 1 };
+var resolveSpec = (spec, body, counter) => ({
+  ...spec,
+  id: spec.id ?? `${spec.kind}_${counter}`,
+  height: spec.height ?? body.heightMetres,
+  build: spec.build ?? 1,
+  vitality: spec.vitality ?? DEFAULT_VITALITY,
+  multipliers: { ...NO_MULTIPLIERS, ...spec.multipliers },
+  limbFactor: spec.limbFactor ?? 1,
+  bloodFactor: spec.bloodFactor ?? 1,
+  bodyCount: spec.bodyCount ?? 1,
+  stunSeconds: spec.stunSeconds ?? DEFAULT_STUN_SECONDS,
+  protection: spec.protection ?? [],
+  detail: spec.detail ?? "segments"
+});
+var createCharacterCore = ({ spec, bodySpec, hitPointsOf }) => {
+  const rig = createRig({ body: bodySpec, height: spec.height, build: spec.build });
+  const parts = describeBody({ rig, body: bodySpec, build: spec.build, name: spec.kind });
+  const fresh = () => createBodyState({ vitality: spec.vitality, detail: spec.detail, crawling: spec.crawling ?? false, hitPointsOf: hitPointsOf ?? ((kind) => SEGMENT_NUMBERS[kind].hitPoints) });
+  const body = fresh();
+  return { spec, rig, body, position: [0, 0, 0], rotation: [0, 0, 0, 1], describe: () => parts, resetBody: () => void Object.assign(body, fresh()) };
+};
+var characterView = (core) => ({
+  id: core.spec.id,
+  spec: core.spec,
+  rig: core.rig,
+  get segments() {
+    return core.body.segments;
+  },
+  get detail() {
+    return core.body.detail;
+  },
+  regionHitPoints: () => ({ ...core.body.regions }),
+  setDetail(detail) {
+    if (detail === core.body.detail) return;
+    if (detail === "regions") regionsFromSegments(core.body);
+    else segmentsFromRegions(core.body);
+    core.body.detail = detail;
+  },
+  setTransform(position, rotation) {
+    core.position = [...position];
+    if (rotation) core.rotation = [...rotation];
+  },
+  describe: core.describe,
+  state: () => toObjectState({ id: core.spec.id, name: core.spec.kind, position: core.position, rotation: core.rotation, body: core.body, spec: core.describe() }),
+  reset: core.resetBody
+});
+
+// src/body/transform.ts
+var rotate = (q, v) => {
+  const [x, y, z, w] = q;
+  const tx = 2 * (y * v[2] - z * v[1]);
+  const ty = 2 * (z * v[0] - x * v[2]);
+  const tz = 2 * (x * v[1] - y * v[0]);
+  return [v[0] + w * tx + (y * tz - z * ty), v[1] + w * ty + (z * tx - x * tz), v[2] + w * tz + (x * ty - y * tx)];
+};
+var conjugate = (q) => [-q[0], -q[1], -q[2], q[3]];
+var toWorld = ({ position, rotation }, local) => {
+  const turned = rotate(rotation, local);
+  return [turned[0] + position[0], turned[1] + position[1], turned[2] + position[2]];
+};
+var toLocal = ({ position, rotation }, world) => rotate(conjugate(rotation), [world[0] - position[0], world[1] - position[1], world[2] - position[2]]);
+var distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+
+// src/damage/bleeding.ts
+var BLOOD_LITERS_PER_DROP = 27e-5;
+var bleedRateAt = (bleeder) => bleeder.age >= bleeder.duration ? 0 : bleeder.rate * (1 - bleeder.age / bleeder.duration);
+var stepBleeding = ({ bleeders, dt, emit, pointOf }) => {
+  for (const bleeder of bleeders) {
+    if (bleeder.age >= bleeder.duration) continue;
+    bleeder.age += dt;
+    const second = Math.floor(bleeder.age);
+    if (second <= bleeder.reported) continue;
+    bleeder.reported = second;
+    const rate = bleedRateAt(bleeder);
+    if (rate > 0) emit({ type: "leak", part: bleeder.part, fluid: "blood", point: pointOf(bleeder.part), direction: [0, -1, 0], rate: rate * BLOOD_LITERS_PER_DROP, pressurized: bleeder.spurt });
+  }
+};
+
+// src/damage/body-ops.ts
+var killAllowed = (rule, cause) => rule === "vitality-or-head" || cause === "head" || cause === "explosion";
+var createBodyOps = ({ body, spec, rules, random, time, source, pointOf, bleeders }) => {
+  const events = [];
+  const emit = (event) => void events.push({ ...event, object: spec.id, time, ...source !== void 0 ? { source } : {} });
+  const change = (kind, part, extra) => emit({ type: "body", change: kind, ...part ? { part } : {}, ...extra });
+  const detachBelow = (segment, below2) => {
+    const fallen = segmentsBelow(segment.id).filter((id) => segmentOf(body, id).attached);
+    segment.attached = false;
+    for (const id of fallen) {
+      const part = segmentOf(body, id);
+      part.attached = false;
+      if (below2 === "zero") Object.assign(part, { hp: 0, status: "severed" });
+    }
+    return fallen;
+  };
+  const ops = {
+    body,
+    spec,
+    rules,
+    random,
+    events,
+    emit,
+    pointOf,
+    change,
+    damage: (segment, amount, damageType) => emit({ type: "damage", part: segment.id, amount, hp: Math.max(0, segment.hp), damageType }),
+    wound(segment) {
+      if (segment.status === "ok") segment.status = "wounded";
+      change("wound", segment.id);
+    },
+    breakBone(segment) {
+      segment.status = "broken";
+      change("broken", segment.id);
+    },
+    sever(segment, below2 = "detach") {
+      if (!segment.attached) return;
+      const fallen = detachBelow(segment, below2);
+      segment.status = "severed";
+      body.pieces.push([segment.id, ...fallen]);
+      const parent = segmentNode(segment.id).parent;
+      change("severed", segment.id, { below: fallen });
+      if (parent) emit({ type: "detach", joint: `${parent}~${segment.id}`, parts: [parent, segment.id], by: "break", groups: [[segment.id, ...fallen]] });
+    },
+    destroy(segment) {
+      if (!segment.attached) return;
+      const fallen = detachBelow(segment, "detach");
+      segment.status = "destroyed";
+      if (fallen.length > 0) body.pieces.push(fallen);
+      change("destroyed", segment.id, { below: fallen });
+      emit({ type: "fracture", part: segment.id, style: "tear", fragments: [], point: pointOf(segment.id) });
+    },
+    kill(cause) {
+      if (!body.alive || !killAllowed(rules.deathRule, cause)) return;
+      body.alive = false;
+      change("killed", void 0, { cause });
+    },
+    limp(side) {
+      if (body.limping.includes(side)) return;
+      body.limping.push(side);
+      change("limp");
+    },
+    crawl() {
+      if (body.crawl) return;
+      body.crawl = true;
+      change("crawl");
+    },
+    stun() {
+      body.stunSeconds = spec.stunSeconds;
+      change("stunned");
+    },
+    bleed({ segment, rate, duration, spurt, point, direction }) {
+      const scaled = rate * spec.bloodFactor;
+      bleeders.push({ part: segment.id, rate: scaled, duration, spurt, age: 0, reported: 0 });
+      emit({ type: "leak", part: segment.id, fluid: "blood", point: point ?? pointOf(segment.id), direction: direction ?? [0, -1, 0], rate: scaled * BLOOD_LITERS_PER_DROP, pressurized: spurt });
+    }
+  };
+  return ops;
+};
+
+// src/presets/physical.json
+var physical_default = {
+  id: "physical",
+  tissuePerCentimetre: {
+    flesh: 0.25,
+    bone: 1
+  },
+  torsoPath: {
+    fleshCentimetres: 22,
+    boneCentimetres: 2
+  },
+  regionFactor: {
+    head: 0.7,
+    limb: 0.5,
+    torso: 1
+  },
+  bruteTorsoFactor: 2,
+  energyKept: "P / (P + R)",
+  points: {
+    coefficient: 3.5,
+    exponent: 0.37
+  },
+  tolerance: {
+    bodies: 0,
+    energyKept: 0.05
+  },
+  calibration: [
+    {
+      caliber: "9x19",
+      force: 7.67,
+      bodies: 2,
+      energyKeptFirstBody: 0.51,
+      expectedBodies: 2,
+      bestiaryEnergyKept: 0.5
+    },
+    {
+      caliber: "5_56x45",
+      force: 16.56,
+      bodies: 3,
+      energyKeptFirstBody: 0.69,
+      expectedBodies: 3,
+      bestiaryEnergyKept: 0.65
+    },
+    {
+      caliber: "7_62x51",
+      force: 26.67,
+      bodies: 4,
+      energyKeptFirstBody: 0.78,
+      expectedBodies: 4,
+      bestiaryEnergyKept: 0.75
+    },
+    {
+      caliber: "7_62x39",
+      force: 18.52,
+      bodies: 3,
+      energyKeptFirstBody: 0.71,
+      expectedBodies: 3
+    },
+    {
+      caliber: "12ga_00buck",
+      force: 4.35,
+      bodies: 1,
+      energyKeptFirstBody: 0.37,
+      expectedBodies: 1
+    }
+  ],
+  torsoResistance: 7.5
+};
+
+// src/damage/defaults.ts
+var { severity } = segments_default;
+var DEFAULT_DAMAGE_RULES = {
+  deathRule: "vitality-or-head",
+  segmentRule: "kit",
+  severity: { ...severity, stunAtPoints: 35, limbVitalityShare: 0.3, regionLimbVitalityShare: 0.5 },
+  blast: { minimumPoints: 8, headDestroyPoints: 40, bigPoints: 120 },
+  defaultCut: segments_default.defaultCut,
+  points: physical_default.points,
+  spread: 0,
+  segments: SEGMENT_NUMBERS,
+  burnPointsPerSecond: 3
+};
+var ARSENAL_RULES = { ...DEFAULT_DAMAGE_RULES, segmentRule: "arsenal" };
+var ELENCO_HIT_POINTS = segments_default.elenco.segments;
+var ELENCO_RULES = {
+  ...DEFAULT_DAMAGE_RULES,
+  segmentRule: "elenco",
+  spread: 0.15,
+  segments: Object.fromEntries(
+    Object.entries(SEGMENT_NUMBERS).map(([kind, numbers]) => [kind, { ...numbers, multiplier: 1, hitPoints: ELENCO_HIT_POINTS[kind]?.hp ?? numbers.hitPoints }])
+  )
+};
+var DAMAGE_PRESETS = { kit: DEFAULT_DAMAGE_RULES, arsenal: ARSENAL_RULES, elenco: ELENCO_RULES };
+var PROTECTION_PRESETS = [
+  { id: "vest_police", slots: ["torso"], ballistic: { resistance: 14, blunt: 0.3, pass: 0.8 } },
+  { id: "vest_military", slots: ["torso"], ballistic: { resistance: 28, blunt: 0.5 } },
+  { id: "helmet_combat", slots: ["head"], ballistic: { resistance: 9, blunt: 0, pass: 1, consumable: true } },
+  { id: "turnout_gear", slots: ["torso", "arms", "legs"], fire: 0.25, limbs: 0.8 }
+];
+var CLASS_OF = { pistol: "pistol", rifle: "rifle" };
+var TEAM_GAME_CALIBERS = Object.entries(team_game_default.calibers).map(([id, entry]) => ({
+  id,
+  points: entry.points,
+  penetration: entry.penetration,
+  class: CLASS_OF[entry.class] ?? "pistol",
+  skullRange: entry.skullRange,
+  pellets: "pellets" in entry ? entry.pellets : 1,
+  effectiveRangeMetres: entry.effectiveRangeMetres
+}));
+var TEAM_GAME_CALIBER_KEYS = Object.fromEntries(Object.entries(team_game_default.calibers).map(([id, entry]) => [entry.gameKey, id]));
+var TEAM_GAME_RULES = { regionCost: team_game_default.regionCost, damageKeptPerBody: team_game_default.damageKeptPerBody, falloff: team_game_default.falloff };
+var PHYSICAL_RULES = physical_default;
+
+// src/damage/penetration.ts
+var PHYSICAL_PENETRATION = {
+  id: "physical",
+  stops: (layer, projectile) => projectile.force <= (layer.ballistic?.resistance ?? 0),
+  piercesSkull: (projectile, headResistance) => projectile.force > headResistance
+};
+var TEAM_GAME_PENETRATION = {
+  id: "team-game",
+  stops: (_layer, projectile) => projectile.class === "pistol",
+  piercesSkull: (projectile) => projectile.skullRange === 1 || projectile.distance <= projectile.skullRange
+};
+var PENETRATION_MODELS = { physical: PHYSICAL_PENETRATION, "team-game": TEAM_GAME_PENETRATION };
+var { tissuePerCentimetre, torsoPath, regionFactor } = PHYSICAL_RULES;
+var TORSO_RESISTANCE = torsoPath.fleshCentimetres * tissuePerCentimetre.flesh + torsoPath.boneCentimetres * tissuePerCentimetre.bone;
+var HEAD_KINDS = /* @__PURE__ */ new Set(["head", "jaw", "neck"]);
+var TORSO_KINDS = /* @__PURE__ */ new Set(["torso", "pelvis"]);
+var segmentResistance = ({ kind, bodyCount, protection }) => {
+  if (TORSO_KINDS.has(kind)) return TORSO_RESISTANCE * regionFactor.torso * bodyCount + protection;
+  if (HEAD_KINDS.has(kind)) return TORSO_RESISTANCE * regionFactor.head + protection;
+  return TORSO_RESISTANCE * regionFactor.limb + protection;
+};
+var energyKept = (force, resistance) => force > 0 ? force / (force + resistance) : 0;
+var teamGameCost = (region, bodyCount) => {
+  const cost = TEAM_GAME_RULES.regionCost;
+  if (region === "head") return cost.head;
+  if (region === "torso") return bodyCount > 1 ? cost.bruteTorso : cost.torso;
+  return cost.limb;
+};
+var teamGameFalloff = (distance2, range) => {
+  const floor = TEAM_GAME_RULES.falloff.atTwiceRange;
+  return distance2 <= range * TEAM_GAME_RULES.falloff.fullAtRange ? 1 : Math.max(floor, 1 - (distance2 - range) / range * (1 - floor));
+};
+
+// src/damage/rules/blow.ts
+var NO_HEADSHOT = { headshot: false };
+var HEADSHOT = { headshot: true };
+var ARM_KINDS = /* @__PURE__ */ new Set(["upperArm", "forearm", "hand"]);
+var LEG_KINDS = /* @__PURE__ */ new Set(["thigh", "shin", "foot"]);
+var isArm = (kind) => ARM_KINDS.has(kind);
+var isLeg = (kind) => LEG_KINDS.has(kind);
+var isLimb = (kind) => isArm(kind) || isLeg(kind);
+var typeMultiplier = (spec, kind) => {
+  if (isArm(kind)) return spec.multipliers.arms;
+  if (isLeg(kind)) return spec.multipliers.legs;
+  if (kind === "torso" || kind === "pelvis") return spec.multipliers.torso;
+  return spec.multipliers.head;
+};
+var segmentDamage = (ops, blow, points) => {
+  const { kind } = blow.segment;
+  return points * ops.rules.segments[kind].multiplier * typeMultiplier(ops.spec, kind) * (isLimb(kind) ? blow.limbFactor : 1);
+};
+var bleedStump = (ops, segment) => {
+  const bleed = ops.rules.segments[segment.kind].bleed;
+  const parent = segmentNode(segment.id).parent;
+  const stump = parent ? ops.body.segments.find((candidate) => candidate.id === parent) ?? segment : segment;
+  ops.bleed({ segment: stump, rate: bleed * (segment.kind === "neck" || segment.kind === "head" ? 1.5 : 1), duration: 45, spurt: true });
+};
+var bleedPiece = (ops, segment) => ops.bleed({ segment, rate: ops.rules.segments[segment.kind].bleed * 0.35, duration: 15, spurt: true });
+var bleedWound = (ops, segment, point) => ops.bleed({ segment, rate: ops.rules.segments[segment.kind].bleed * 0.3, duration: 10, spurt: false, point });
+var severWithBleeding = (ops, segment) => {
+  if (!segment.attached) return;
+  bleedStump(ops, segment);
+  ops.sever(segment);
+  bleedPiece(ops, segment);
+};
+var destroyWithBleeding = (ops, segment) => {
+  if (!segment.attached) return;
+  bleedStump(ops, segment);
+  ops.destroy(segment);
+};
+
+// src/damage/rules/regions.ts
+import { MISSING_BITS as MISSING_BITS2 } from "@adatechnology/game-contracts";
+
+// src/damage/points.ts
+var createRng = (seed) => {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let mixed = Math.imul(state ^ state >>> 15, state | 1);
+    mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+};
+var pointsFromEnergy = (energy, rules) => energy > 0 ? rules.points.coefficient * energy ** rules.points.exponent : 0;
+var resolvePoints = (hit, caliber, rules) => hit.points ?? caliber?.points ?? pointsFromEnergy(hit.energy ?? 0, rules);
+var spreadPoints = (points, spread, random) => spread > 0 ? points * (1 - spread + random() * 2 * spread) : points;
+var DEFAULT_PROJECTILE_GRAMS = 8;
+var RIFLE_JOULES = 1e3;
+var penetrationForce = (energy, grams, diameterMm) => {
+  const area = Math.PI * diameterMm ** 2 / 4;
+  return area > 0 && energy > 0 ? Math.sqrt(energy * grams / area) : 0;
+};
+var projectileOf = (hit, caliber) => {
+  const pellets = hit.pellets ?? caliber?.pellets ?? 1;
+  const energy = hit.energy ?? 0;
+  const fallback = energy > RIFLE_JOULES ? "rifle" : "pistol";
+  return {
+    force: penetrationForce(energy, hit.mass ?? DEFAULT_PROJECTILE_GRAMS, hit.caliber ?? 9),
+    class: caliber?.class ?? fallback,
+    skullRange: caliber?.skullRange ?? 1,
+    pellets,
+    distance: hit.distance ?? 0
+  };
+};
+var cutOf = (hit, projectile, rules) => {
+  if (hit.cut !== void 0) return hit.cut;
+  const type = hit.type;
+  if (type === "ballistic" && projectile) return rules.defaultCut.ballistic[projectile.pellets > 1 ? "buckshot" : projectile.class];
+  if (type === "slash" || type === "blunt" || type === "explosive") return rules.defaultCut[type];
+  return 0;
+};
+
+// src/damage/rules/regions.ts
+var LIMB_BITS = {
+  armL: { severed: MISSING_BITS2.armL, broken: MISSING_BITS2.armLBroken },
+  armR: { severed: MISSING_BITS2.armR, broken: MISSING_BITS2.armRBroken },
+  legL: { severed: MISSING_BITS2.legL, broken: MISSING_BITS2.legLBroken },
+  legR: { severed: MISSING_BITS2.legR, broken: MISSING_BITS2.legRBroken }
+};
+var rootOf = (ops, region) => segmentOf(ops.body, REGION_SEGMENTS[region][0]);
+var hitHead = (ops, blow, points) => {
+  const { body, rules } = ops;
+  const rule = rules.severity;
+  const multiplier = rules.segments.head.multiplier;
+  const { projectile } = blow;
+  const lethal = projectile ? blow.model.piercesSkull(projectile, blow.headResistance) && points >= rule.headKillDamage : points * multiplier >= body.regions.head;
+  if (lethal) {
+    const shotgunClose = projectile !== void 0 && projectile.pellets > 1 && projectile.distance < rule.headBitShotgunMetres;
+    if (points > rule.headBitDamage || shotgunClose) {
+      body.missing |= MISSING_BITS2.head;
+      ops.destroy(segmentOf(body, "head"));
+    }
+    return HEADSHOT;
+  }
+  body.vitality -= points * multiplier;
+  body.regions.head -= points;
+  ops.damage(segmentOf(body, "head"), points * multiplier, blow.damageType);
+  if (points > rule.jawDamage && ops.random() < rule.jawChance && (body.missing & MISSING_BITS2.jaw) === 0) {
+    body.missing |= MISSING_BITS2.jaw;
+    ops.sever(segmentOf(body, "jaw"));
+  }
+  return NO_HEADSHOT;
+};
+var hitLimb = (ops, blow, region, points) => {
+  const { body, spec, rules } = ops;
+  const leg = region === "legL" || region === "legR";
+  const factor = (leg ? spec.multipliers.legs : spec.multipliers.arms) * spec.limbFactor * blow.protection.limbs;
+  const amount = points * factor;
+  body.regions[region] -= amount;
+  body.vitality -= amount * rules.severity.regionLimbVitalityShare;
+  const root = rootOf(ops, region);
+  ops.damage(root, amount, blow.damageType);
+  const max = REGION_HIT_POINTS[region];
+  if (leg && body.regions[region] <= max * rules.severity.limpAtHpFraction) ops.limp(region === "legL" ? "L" : "R");
+  if (body.regions[region] > 0) return;
+  const severs = blow.cut >= rules.severity.severAtCut || amount > max * rules.severity.severAtDamageFraction;
+  const bit = severs ? LIMB_BITS[region].severed : LIMB_BITS[region].broken;
+  const isNew = (body.missing & bit) === 0;
+  body.missing |= bit;
+  if (leg) ops.crawl();
+  if (!isNew) return;
+  if (severs) ops.sever(root);
+  else ops.breakBone(root);
+};
+var regionRule = (ops, blow) => {
+  const { body, rules } = ops;
+  const points = spreadPoints(blow.points, rules.spread, ops.random);
+  let result = NO_HEADSHOT;
+  if (blow.region === "head") result = hitHead(ops, blow, points);
+  else if (blow.region === "torso") {
+    const amount = points * ops.spec.multipliers.torso * blow.protection.ballistic;
+    body.vitality -= amount;
+    ops.damage(segmentOf(body, "torso"), amount, blow.damageType);
+  } else hitLimb(ops, blow, blow.region, points);
+  if (result.headshot) ops.kill("head");
+  else if (body.vitality <= 0) ops.kill("vitality");
+  if (!body.alive || result.headshot || body.vitality <= 0) return result;
+  if (points >= rules.severity.stunAtPoints) ops.stun();
+  return result;
+};
+
+// src/damage/blast.ts
+var shares = (params, targets, pivot) => targets.map((target) => ({ target, points: params.points * Math.max(0, 1 - distance(params.jointOf(pivot(target)), params.center) / params.radius) })).filter((share) => share.points > params.ops.rules.blast.minimumPoints).sort((a, b) => b.points - a.points);
+var segmentBlast = (params) => {
+  const { ops, rule, blow } = params;
+  const { blast: blast2, segments } = ops.rules;
+  let result = NO_HEADSHOT;
+  for (const { target, points } of shares(params, ops.body.segments.filter((segment) => segment.attached), (segment) => segment.id)) {
+    if (!target.attached) continue;
+    if (target.kind === "head" && points > blast2.headDestroyPoints) {
+      destroyWithBleeding(ops, target);
+      ops.kill("explosion");
+      result = HEADSHOT;
+      continue;
+    }
+    rule(ops, { ...blow, segment: target, points: points / segments[target.kind].multiplier, big: points > blast2.bigPoints, explosive: true });
+  }
+  return result;
+};
+var regionBlast = (params) => {
+  let result = NO_HEADSHOT;
+  const pivot = (region) => segmentNode(REGION_SEGMENTS[region][0]).id;
+  for (const { target, points } of shares(params, BODY_REGIONS, pivot)) {
+    if (regionRule(params.ops, { ...params.blow, region: target, points }).headshot) result = HEADSHOT;
+  }
+  return result;
+};
+
+// src/damage/protection.ts
+var LAYERED_PROTECTION_CAP = 0.9;
+var layeredProtection = ({ layers, attack, conditions }) => {
+  const through = layers.reduce((left, layer) => left * (1 - (layer[attack] ?? 0) * (conditions?.[layer.id] ?? 1)), 1);
+  return Math.min(LAYERED_PROTECTION_CAP, 1 - through);
+};
+var layersOn = (worn, slots, consumed) => worn.filter((layer) => !consumed.has(layer.id) && layer.slots.some((slot) => slots.includes(slot)));
+var protect = ({ layers, projectile, model }) => {
+  let ballistic = 1;
+  let resistance = 0;
+  for (const layer of layers) {
+    const armour = layer.ballistic;
+    if (!armour || !projectile) continue;
+    const stops = model.stops(layer, projectile);
+    if (stops && armour.consumable) return { absorbedBy: layer.id, ballistic: 0, resistance: armour.resistance, limbs: 1, fire: 1 };
+    ballistic *= stops ? armour.blunt : armour.pass ?? armour.blunt;
+    resistance += armour.resistance;
+  }
+  const limbs = layers.reduce((factor, layer) => factor * (layer.limbs ?? 1), 1);
+  const fire = layers.reduce((factor, layer) => factor * (layer.fire ?? 1), 1);
+  return { ballistic, resistance, limbs, fire };
+};
+
+// src/damage/resolve-part.ts
+var radiusOf = (part) => part.shape.kind === "box" ? Math.min(...part.shape.size) / 2 : part.shape.radius;
+var resolveSegment = (body, spec, part, localPoint) => {
+  if (part !== void 0 && isSegmentId(part)) return part;
+  if (part !== void 0 && isBodyRegion(part)) return REGION_SEGMENTS[part][0];
+  let best = "torso";
+  let bestGap = Infinity;
+  for (const candidate of spec.parts) {
+    const segment = body.segments.find((entry) => entry.id === candidate.id);
+    if (!segment?.attached) continue;
+    const gap = distance(candidate.position, localPoint) - radiusOf(candidate);
+    if (gap < bestGap) [best, bestGap] = [segment.id, gap];
+  }
+  return best;
+};
+var regionOfSegment = (body, id) => body.segments.find((segment) => segment.id === id)?.region ?? "torso";
+
+// src/damage/rules/arsenal.ts
+var HEAD_BLOW_POINTS = 30;
+var LIMB_VITALITY_SHARE = 0.3;
+var split = (ops) => {
+  const torso = segmentOf(ops.body, "torso");
+  if (!torso.attached) return;
+  severWithBleeding(ops, torso);
+  ops.change("split", "torso");
+  ops.kill("vitality");
+};
+var loseLimb = (ops, segment, blow) => {
+  if (blow.big || -segment.hp > segment.max) destroyWithBleeding(ops, segment);
+  else severWithBleeding(ops, segment);
+  const { body } = ops;
+  if (segment.kind === "thigh" || segment.kind === "shin") {
+    if (body.alive) ops.crawl();
+  } else if (segment.kind === "foot" && body.alive && !body.crawl && body.limping.length === 0 && segment.side) ops.limp(segment.side);
+};
+var arsenalRule = (ops, blow) => {
+  const { segment } = blow;
+  if (!segment.attached) return NO_HEADSHOT;
+  const amount = segmentDamage(ops, blow, blow.points);
+  if (blow.point) bleedWound(ops, segment, blow.point);
+  segment.hp -= amount;
+  ops.damage(segment, amount, blow.damageType);
+  let result = NO_HEADSHOT;
+  if (segment.kind === "head") {
+    if (blow.points >= HEAD_BLOW_POINTS || segment.hp <= 0) {
+      destroyWithBleeding(ops, segment);
+      ops.kill("head");
+      result = HEADSHOT;
+    } else ops.wound(segment);
+  } else if (segment.kind === "jaw") {
+    if (segment.hp <= 0) severWithBleeding(ops, segment);
+  } else if (segment.kind === "neck") {
+    if (segment.hp <= 0) {
+      severWithBleeding(ops, segment);
+      ops.kill("head");
+    }
+  } else if (segment.kind === "torso" || segment.kind === "pelvis") {
+    ops.body.vitality -= amount;
+    if (blow.points >= ops.rules.severity.splitAtDamage || segment.hp <= 0) split(ops);
+  } else {
+    ops.body.vitality -= amount * LIMB_VITALITY_SHARE;
+    if (segment.hp <= 0) loseLimb(ops, segment, blow);
+  }
+  if (ops.body.alive && ops.body.vitality <= 0) ops.kill("vitality");
+  return result;
+};
+
+// src/damage/rules/elenco.ts
+var HEAD_SEVER_CUT = 0.7;
+var HEAD_SEVER_POINTS = 90;
+var JOINTED = /* @__PURE__ */ new Set(["head", "upperArm", "forearm", "hand", "thigh", "shin", "foot"]);
+var elencoRule = (ops, blow) => {
+  const { segment } = blow;
+  const { body, rules } = ops;
+  if (!segment.attached || !body.alive && segment.kind !== "head") return NO_HEADSHOT;
+  const amount = segmentDamage(ops, blow, spreadPoints(blow.points, rules.spread, ops.random));
+  segment.hp = Math.max(0, segment.hp - amount);
+  ops.damage(segment, amount, blow.damageType);
+  if (segment.hp > 0) {
+    ops.wound(segment);
+    return NO_HEADSHOT;
+  }
+  if (segment.kind === "head") {
+    if (blow.cut >= HEAD_SEVER_CUT || blow.points >= HEAD_SEVER_POINTS) ops.sever(segment, "zero");
+    else ops.breakBone(segment);
+    ops.kill("head");
+    return HEADSHOT;
+  }
+  if (JOINTED.has(segment.kind)) {
+    if (blow.cut >= rules.severity.severAtCut || amount >= segment.max * rules.severity.severAtDamageFraction) {
+      ops.sever(segment, "zero");
+      if (isLeg(segment.kind)) ops.crawl();
+      return NO_HEADSHOT;
+    }
+    ops.breakBone(segment);
+    if (isLeg(segment.kind) && segment.side) {
+      ops.limp(segment.side);
+      if (body.limping.length === 2) ops.crawl();
+    }
+    return NO_HEADSHOT;
+  }
+  ops.breakBone(segment);
+  if (segment.kind === "torso") ops.kill("vitality");
+  else if (segment.kind === "pelvis") ops.crawl();
+  else if (segment.kind === "neck") ops.kill("head");
+  return NO_HEADSHOT;
+};
+
+// src/damage/rules/kit.ts
+var severityOf = (ops, blow, amount, max) => {
+  const rule = ops.rules.severity;
+  if (blow.explosive || amount >= max * rule.destroyAtDamageMultiple) return "destroyed";
+  if (blow.cut >= rule.severAtCut || amount > max * rule.severAtDamageFraction) return "severed";
+  return "broken";
+};
+var lose = (ops, segment, outcome) => {
+  if (outcome === "destroyed") destroyWithBleeding(ops, segment);
+  else if (outcome === "severed") severWithBleeding(ops, segment);
+  else ops.breakBone(segment);
+};
+var hitHead2 = (ops, blow, points, amount, hpBefore) => {
+  const { segment, projectile } = blow;
+  const rule = ops.rules.severity;
+  const lethal = projectile ? blow.model.piercesSkull(projectile, blow.headResistance) && points >= rule.headKillDamage : amount >= hpBefore;
+  if (lethal) {
+    const shotgunClose = projectile !== void 0 && projectile.pellets > 1 && projectile.distance < rule.headBitShotgunMetres;
+    if (blow.explosive || points > rule.headBitDamage || shotgunClose) destroyWithBleeding(ops, segment);
+    else ops.breakBone(segment);
+    ops.kill("head");
+    return HEADSHOT;
+  }
+  ops.body.vitality -= amount;
+  ops.wound(segment);
+  if (points > rule.jawDamage && ops.random() < rule.jawChance) severWithBleeding(ops, segmentOf(ops.body, "jaw"));
+  return NO_HEADSHOT;
+};
+var hitTorso = (ops, points, amount, segment) => {
+  ops.body.vitality -= amount;
+  if (points < ops.rules.severity.splitAtDamage && segment.hp > 0) return ops.wound(segment);
+  const torso = segmentOf(ops.body, "torso");
+  if (!torso.attached) return;
+  severWithBleeding(ops, torso);
+  ops.change("split", "torso");
+  if (ops.rules.deathRule === "head-only") ops.crawl();
+  else ops.kill("vitality");
+};
+var hitLimb2 = (ops, blow, amount, hpBefore) => {
+  const { segment } = blow;
+  const rule = ops.rules.severity;
+  ops.body.vitality -= amount * rule.limbVitalityShare;
+  if (isLeg(segment.kind) && segment.side && segment.hp <= segment.max * rule.limpAtHpFraction) ops.limp(segment.side);
+  if (segment.hp > 0 || hpBefore <= 0) return ops.wound(segment);
+  const outcome = severityOf(ops, blow, amount, segment.max);
+  lose(ops, segment, outcome);
+  if (segment.kind === "thigh" || segment.kind === "shin") ops.crawl();
+};
+var kitRule = (ops, blow) => {
+  const { segment } = blow;
+  if (!segment.attached) return NO_HEADSHOT;
+  const points = spreadPoints(blow.points, ops.rules.spread, ops.random);
+  const amount = segmentDamage(ops, blow, points);
+  if (blow.point && !blow.explosive) bleedWound(ops, segment, blow.point);
+  const hpBefore = segment.hp;
+  segment.hp -= amount;
+  ops.damage(segment, amount, blow.damageType);
+  let result = NO_HEADSHOT;
+  if (segment.kind === "head") result = hitHead2(ops, blow, points, amount, hpBefore);
+  else if (segment.kind === "torso" || segment.kind === "pelvis") hitTorso(ops, points, amount, segment);
+  else if (segment.kind === "jaw" || segment.kind === "neck") {
+    if (segment.hp <= 0 && hpBefore > 0) {
+      lose(ops, segment, severityOf(ops, blow, amount, segment.max));
+      if (segment.kind === "neck" && !segment.attached) ops.kill("head");
+    } else ops.wound(segment);
+  } else hitLimb2(ops, blow, amount, hpBefore);
+  if (ops.body.vitality <= 0) ops.kill("vitality");
+  if (ops.body.alive && points >= ops.rules.severity.stunAtPoints) ops.stun();
+  return result;
+};
+
+// src/damage/pipeline.ts
+var SEGMENT_RULES = { kit: kitRule, arsenal: arsenalRule, elenco: elencoRule };
+var HEAD_RESISTANCE = segmentResistance({ kind: "head", bodyCount: 1, protection: 0 });
+var NO_PROTECTION = { ballistic: 1, resistance: 0, limbs: 1, fire: 1 };
+var ABSORBED_SPARKS = 8;
+var METRES_PER_MM = 1e-3;
+var report = (ops, fields, result = { headshot: false }) => ({
+  through: false,
+  exitEnergy: 0,
+  ...fields,
+  killed: !ops.body.alive,
+  headshot: result.headshot
+});
+var burn = ({ ops, hit, setup, worn }) => {
+  const torso = segmentOf(ops.body, "torso");
+  const fire = protect({ layers: layersOn(worn, segmentNode("torso").slots, ops.body.consumed), model: setup.model }).fire;
+  const points = setup.rules.burnPointsPerSecond * (hit.duration ?? 0) * fire;
+  ops.body.vitality -= points;
+  ops.damage(torso, points, hit.type);
+  if (ops.body.vitality <= 0) ops.kill("vitality");
+  return report(ops, { part: "torso", points });
+};
+var blast = ({ ops, hit, setup, localPoint, jointOf }) => {
+  const points = hit.points ?? pointsFromEnergy(hit.energy ?? 0, setup.rules);
+  const base = { ops, center: localPoint, points, radius: hit.radius ?? 1, jointOf };
+  const common = { cut: hit.cut ?? setup.rules.defaultCut.explosive, damageType: hit.type, model: setup.model, headResistance: HEAD_RESISTANCE };
+  const rule = SEGMENT_RULES[setup.rules.segmentRule] ?? kitRule;
+  const result = ops.body.detail === "regions" ? regionBlast({ ...base, blow: { ...common, protection: NO_PROTECTION } }) : segmentBlast({ ...base, rule, blow: { ...common, limbFactor: ops.spec.limbFactor } });
+  return report(ops, { points }, result);
+};
+var DEFAULT_PATH_METRES = 0.2;
+var pathThrough = (spec, id) => {
+  const shape = spec.parts.find((part) => part.id === id)?.shape;
+  return shape && shape.kind !== "box" ? 2 * shape.radius : DEFAULT_PATH_METRES;
+};
+var exitOf = (hit, depth) => {
+  const [x, y, z] = hit.direction ?? [0, 0, -1];
+  return [hit.point[0] + x * depth, hit.point[1] + y * depth, hit.point[2] + z * depth];
+};
+var direct = ({ ops, hit, setup, worn, localPoint, describe }) => {
+  const { body, spec, rules } = ops;
+  const caliber = hit.caliberId === void 0 ? void 0 : setup.calibers.get(hit.caliberId);
+  const projectile = hit.type === "ballistic" ? projectileOf(hit, caliber) : void 0;
+  const id = resolveSegment(body, describe(), hit.part, localPoint);
+  const region = regionOfSegment(body, id);
+  const slots = segmentNode(body.detail === "regions" ? REGION_SEGMENTS[region][0] : id).slots;
+  const protection = protect({ layers: layersOn(worn, slots, body.consumed), model: setup.model, ...projectile ? { projectile } : {} });
+  if (protection.absorbedBy) {
+    body.consumed.add(protection.absorbedBy);
+    ops.emit({ type: "debris", part: id, kind: "sparks", point: hit.point, normal: [0, 1, 0], count: ABSORBED_SPARKS, speed: 3 });
+    return report(ops, { part: id, points: 0, absorbedBy: protection.absorbedBy });
+  }
+  const rawPoints = resolvePoints(hit, caliber, rules);
+  const points = rawPoints * protection.ballistic;
+  const cut = cutOf(hit, projectile, rules);
+  const segment = segmentOf(body, id);
+  const resistance = segmentResistance({ kind: segment.kind, bodyCount: spec.bodyCount, protection: protection.resistance });
+  const through = setup.model.id === "physical" && projectile !== void 0 && projectile.force > resistance;
+  const exitEnergy = through && projectile ? (hit.energy ?? 0) * energyKept(projectile.force, resistance) : 0;
+  if (projectile) {
+    const depth = pathThrough(describe(), id);
+    ops.emit({ type: "hole", part: id, hole: { point: localPoint, normal: [0, 0, 1], diameter: (hit.caliber ?? 9) * METRES_PER_MM, through }, worldPoint: hit.point, ...through ? { exitPoint: exitOf(hit, depth) } : {} });
+  }
+  const common = { points, cut, damageType: hit.type, model: setup.model, headResistance: HEAD_RESISTANCE, ...projectile ? { projectile } : {} };
+  const result = body.detail === "regions" ? regionRule(ops, { ...common, points: rawPoints, region, protection }) : (SEGMENT_RULES[rules.segmentRule] ?? kitRule)(ops, {
+    ...common,
+    segment,
+    explosive: false,
+    big: points > rules.blast.bigPoints,
+    limbFactor: spec.limbFactor * protection.limbs,
+    ...hit.woundAtPoint === false ? {} : { point: hit.point }
+  });
+  return report(ops, { part: id, points, through, exitEnergy }, result);
+};
+var applyBlow = (params) => {
+  if (params.hit.type === "fire" || params.hit.type === "heat") return burn(params);
+  if (params.hit.type === "explosive") return blast(params);
+  return direct(params);
+};
+
+// src/damage/damage-character.ts
+var createDamageCharacter = (core, setup) => {
+  const view = characterView(core);
+  const worn = core.spec.protection.map((id) => setup.protection.get(id)).filter((layer) => layer !== void 0);
+  let bleeders = [];
+  let hitCounter = 0;
+  let clock = 0;
+  let lastHit;
+  const transform = () => ({ position: core.position, rotation: core.rotation });
+  const jointOf = (id) => core.rig.joints[segmentNode(id).joint];
+  const pointOf = (id) => toWorld(transform(), jointOf(id));
+  const opsFor = (random, source) => createBodyOps({ body: core.body, spec: core.spec, rules: setup.rules, random, time: clock, pointOf, bleeders, ...source !== void 0 ? { source } : {} });
+  const character = {
+    ...view,
+    get segments() {
+      return core.body.segments;
+    },
+    get detail() {
+      return core.body.detail;
+    },
+    get alive() {
+      return core.body.alive;
+    },
+    get limping() {
+      return [...core.body.limping];
+    },
+    get stunSeconds() {
+      return core.body.stunSeconds;
+    },
+    get lastHit() {
+      return lastHit;
+    },
+    name: core.spec.kind,
+    hit(raw) {
+      const hit = raw;
+      hitCounter += 1;
+      const random = core.spec.random ?? createRng((core.spec.seed ^ hitCounter) >>> 0);
+      const ops = opsFor(random, hit.source);
+      lastHit = applyBlow({ ops, hit, setup, worn, localPoint: toLocal(transform(), hit.point), jointOf, describe: core.describe });
+      return ops.events;
+    },
+    update(dt) {
+      clock += dt;
+      core.body.stunSeconds = Math.max(0, core.body.stunSeconds - dt);
+      const ops = opsFor(() => 0);
+      stepBleeding({ bleeders, dt, emit: ops.emit, pointOf });
+      return ops.events;
+    },
+    bleeders: () => bleeders.map((bleeder) => ({ ...bleeder })),
+    intactProtection: () => core.spec.protection.filter((id) => !core.body.consumed.has(id)),
+    resistanceOf(part) {
+      const id = resolveSegment(core.body, core.describe(), part, [0, 0, 0]);
+      const layers = layersOn(worn, segmentNode(id).slots, core.body.consumed);
+      const protection = layers.reduce((sum, layer) => sum + (layer.ballistic?.resistance ?? 0), 0);
+      return segmentResistance({ kind: segmentNode(id).kind, bodyCount: core.spec.bodyCount, protection });
+    },
+    protectionAgainst: (attack, part) => layeredProtection({ layers: layersOn(worn, segmentNode(part).slots, core.body.consumed), attack }),
+    reset() {
+      core.resetBody();
+      bleeders = [];
+      hitCounter = 0;
+      lastHit = void 0;
+    },
+    serialize() {
+      const { consumed, ...rest } = core.body;
+      return { body: { ...structuredClone(rest), consumed: [...consumed] }, bleeders: structuredClone(bleeders), hitCounter, clock };
+    },
+    load(data) {
+      const saved = data;
+      Object.assign(core.body, structuredClone(saved.body), { consumed: new Set(saved.body.consumed) });
+      bleeders = structuredClone(saved.bleeders);
+      hitCounter = saved.hitCounter;
+      clock = saved.clock;
+    }
+  };
+  return character;
+};
+
+// src/damage/line.ts
+var RESTART_METRES = 0.3;
+var regionOfPart = (part) => isSegmentId(part) ? segmentNode(part).region : isBodyRegion(part) ? part : "torso";
+var lineHit = (index, target, fields) => ({
+  index,
+  ...fields,
+  killed: !target.character.alive,
+  headshot: target.character.lastHit?.headshot ?? false
+});
+var teamGameLine = ({ shot, targets, calibers }) => {
+  const caliber = shot.caliberId === void 0 ? void 0 : calibers.get(shot.caliberId);
+  if (caliber?.penetration === void 0 || caliber.points === void 0) throw new Error(`game-characters: the team-game line needs a calibre with points and penetration ("${shot.caliberId}")`);
+  let penetration = caliber.penetration;
+  let points = caliber.points;
+  let origin = 0;
+  const hits = [];
+  for (const [index, target] of targets.entries()) {
+    if (!target.character.alive || target.distance - origin <= 0) continue;
+    const distance2 = target.distance - origin;
+    const dealt = points * teamGameFalloff(distance2, caliber.effectiveRangeMetres ?? Infinity);
+    const events = target.character.hit({ type: "ballistic", point: target.point ?? [0, 0, 0], part: target.part, points: dealt, caliberId: caliber.id, distance: distance2, ...shot.source ? { source: shot.source } : {} });
+    hits.push(lineHit(index, target, { points: dealt, energy: shot.energyAt(target.distance), events }));
+    penetration -= teamGameCost(regionOfPart(target.part), target.character.spec.bodyCount);
+    points *= TEAM_GAME_RULES.damageKeptPerBody;
+    if (penetration <= 0) break;
+    if (!target.character.alive) origin = target.distance + RESTART_METRES;
+  }
+  return { hits, stoppedAt: hits.length === 0 ? 0 : (hits[hits.length - 1]?.index ?? -1) + 1 };
+};
+var physicalLine = ({ shot, targets }) => {
+  const first = targets[0];
+  let force = first ? penetrationForce(shot.energyAt(first.distance), shot.mass, shot.caliber) : 0;
+  let kept = 1;
+  const hits = [];
+  for (const [index, target] of targets.entries()) {
+    if (force <= 0) break;
+    if (!target.character.alive) continue;
+    const energy = shot.energyAt(target.distance) * kept;
+    const events = target.character.hit({ type: "ballistic", point: target.point ?? [0, 0, 0], part: target.part, energy, mass: shot.mass, caliber: shot.caliber, distance: target.distance, ...shot.caliberId ? { caliberId: shot.caliberId } : {} });
+    hits.push(lineHit(index, target, { points: target.character.lastHit?.points ?? 0, energy, events }));
+    const resistance = target.character.resistanceOf(target.part);
+    kept *= energyKept(force, resistance);
+    force -= resistance;
+  }
+  return { hits, stoppedAt: hits.length === 0 ? 0 : (hits[hits.length - 1]?.index ?? -1) + 1 };
+};
+var penetrateLine = (params) => params.model === "team-game" ? teamGameLine(params) : physicalLine(params);
+
+// src/registry.ts
+var mergeById = (shipped, extra) => {
+  const entries = /* @__PURE__ */ new Map();
+  for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+  return entries;
+};
+var applyPatches = (entries, patches) => {
+  for (const [id, patch] of Object.entries(patches ?? {})) {
+    const entry = entries.get(id);
+    if (entry) entries.set(id, { ...entry, ...patch, id });
+  }
+};
+var removeIds = (entries, ids) => {
+  for (const id of ids ?? []) entries.delete(id);
+};
+
+// src/kit.ts
+var DEFAULT_CORPSES = { max: 400, seconds: 900 };
+var PERSON_PRESET = { id: "person", kind: "person", age: "adult" };
+var applyPreset = (spec, presets) => {
+  const preset = presets.get(spec.preset ?? spec.kind);
+  if (!preset) return spec;
+  const { id: _presetId, ...defaults } = preset;
+  const multipliers = { ...defaults.multipliers, ...spec.multipliers };
+  return { ...defaults, ...spec, multipliers };
+};
+var resolveDamageRules = (options = {}) => {
+  const { preset, severity: severity2, blast: blast2, segments, ...rest } = options;
+  const base = DAMAGE_PRESETS[preset ?? "kit"];
+  return { ...base, ...rest, severity: { ...base.severity, ...severity2 }, blast: { ...base.blast, ...blast2 }, segments: { ...base.segments, ...segments } };
+};
+var modelOf = (option) => typeof option === "object" ? option : PENETRATION_MODELS[option ?? "physical"];
+var createCharacters = (options = {}) => {
+  const body = createBodySpec(options.body);
+  const packs = options.packs ?? [];
+  const presets = mergeById([PERSON_PRESET], packs.flatMap((pack) => pack.presets ?? []));
+  applyPatches(presets, options.patch);
+  removeIds(presets, options.remove);
+  const damage = resolveDamageRules(options.damage);
+  const penetration = modelOf(options.penetration);
+  const protection = mergeById(PROTECTION_PRESETS, [...packs.flatMap((pack) => pack.protection ?? []), ...options.protection ?? []]);
+  const shippedCalibers = penetration.id === "team-game" ? TEAM_GAME_CALIBERS : [];
+  const calibers = mergeById(shippedCalibers, [...packs.flatMap((pack) => pack.calibers ?? []), ...options.calibers ?? []]);
+  const setup = { rules: damage, model: penetration, protection, calibers };
+  let counter = 0;
+  return {
+    body,
+    presets,
+    corpses: { ...DEFAULT_CORPSES, ...options.corpses },
+    damage,
+    penetration,
+    protection,
+    calibers,
+    create(spec) {
+      counter += 1;
+      const resolved = resolveSpec(applyPreset(spec, presets), body, counter);
+      const core = createCharacterCore({ spec: resolved, bodySpec: body, hitPointsOf: (kind) => damage.segments[kind].hitPoints });
+      return createDamageCharacter(core, setup);
+    },
+    createCorpses: () => createCorpseLedger({ ...DEFAULT_CORPSES, ...options.corpses }),
+    penetrateLine: (shot, targets) => penetrateLine({ model: penetration.id === "team-game" ? "team-game" : "physical", shot, targets, calibers })
+  };
+};
+
+// src/data/gait.json
+var gait_default = {
+  cascade: {
+    hip: 16,
+    spine: 11,
+    shoulder: 9,
+    elbow: 7,
+    leg: 14,
+    knee: 11,
+    head: 6
+  },
+  moves: {
+    idle: {
+      gait: 0,
+      freq: 0,
+      amp: 0,
+      knee: 0,
+      bob: 0,
+      lean: 0,
+      arm: 0,
+      elb: 0.12,
+      crouch: 0,
+      aim: 0,
+      turn: 0,
+      grip: 0.35
+    },
+    walk: {
+      gait: 1,
+      freq: 5.6,
+      amp: 0.42,
+      knee: 0.85,
+      bob: 0.035,
+      lean: 0.05,
+      arm: 0.42,
+      elb: 0.3,
+      crouch: 0,
+      aim: 0,
+      turn: 0,
+      grip: 0.4
+    },
+    run: {
+      gait: 1,
+      freq: 9.2,
+      amp: 0.72,
+      knee: 1.5,
+      bob: 0.06,
+      lean: 0.3,
+      arm: 0.85,
+      elb: 1.35,
+      crouch: 0,
+      aim: 0,
+      turn: 0,
+      grip: 1.1
+    },
+    crouch: {
+      gait: 1,
+      freq: 3.8,
+      amp: 0.3,
+      knee: 0.6,
+      bob: 0.02,
+      lean: 0.42,
+      arm: 0.15,
+      elb: 0.7,
+      crouch: 1,
+      aim: 0,
+      turn: 0,
+      grip: 0.8
+    },
+    aim: {
+      gait: 0,
+      freq: 0,
+      amp: 0,
+      knee: 0,
+      bob: 0,
+      lean: 0.06,
+      arm: 0,
+      elb: 0.2,
+      crouch: 0.25,
+      aim: 1,
+      turn: 0,
+      grip: 1.2
+    },
+    turn: {
+      gait: 0.5,
+      freq: 4.2,
+      amp: 0.14,
+      knee: 0.7,
+      bob: 0.012,
+      lean: 0.03,
+      arm: 0.12,
+      elb: 0.25,
+      crouch: 0,
+      aim: 0,
+      turn: 1,
+      grip: 0.4
+    }
+  },
+  poses: [
+    {
+      index: 0,
+      id: "walk",
+      name: {
+        "pt-BR": "anda"
+      }
+    },
+    {
+      index: 1,
+      id: "crawl",
+      name: {
+        "pt-BR": "rasteja"
+      }
+    },
+    {
+      index: 2,
+      id: "fallen",
+      name: {
+        "pt-BR": "ca\xEDdo"
+      }
+    },
+    {
+      index: 3,
+      id: "attack",
+      name: {
+        "pt-BR": "ataca"
+      }
+    },
+    {
+      index: 4,
+      id: "scream",
+      name: {
+        "pt-BR": "grito"
+      }
+    },
+    {
+      index: 5,
+      id: "crouch",
+      name: {
+        "pt-BR": "agachado"
+      }
+    },
+    {
+      index: 6,
+      id: "leap",
+      name: {
+        "pt-BR": "salto"
+      }
+    },
+    {
+      index: 7,
+      id: "eat",
+      name: {
+        "pt-BR": "comendo"
+      }
+    }
+  ],
+  walk: {
+    cadenceBase: 0.5,
+    cadencePerSpeed: 0.3,
+    stopBelowSpeed: 0.05,
+    maxSine: 0.9,
+    strideFactor: 4,
+    legLengthFactor: 0.9
+  }
+};
+
+// src/gait/stride.ts
+var WALK = gait_default.walk;
+var walkCadence = (speed) => WALK.cadenceBase + WALK.cadencePerSpeed * speed;
+var walkGait = (speed, height = 1) => speed < WALK.stopBelowSpeed ? 0 : 2 * Math.asin(Math.min(WALK.maxSine, speed / (WALK.strideFactor * WALK.legLengthFactor * height * walkCadence(speed))));
+var SWING_SHARE = 0.5;
+var KNEE_PER_GAIT = 0.85;
+var strideFor = ({ speed, height = 1, strideFromSpeed = true }, fallback) => {
+  if (!strideFromSpeed) return fallback;
+  const amplitude = walkGait(speed, height);
+  return { frequency: walkCadence(speed), swing: amplitude * SWING_SHARE, kneeBend: amplitude * KNEE_PER_GAIT };
+};
+
+// src/gait/profile.ts
+var emptySample = () => ({ upper: {}, head: {}, arms: [{}, {}], legs: [{}, {}] });
+var CASCADE = gait_default.cascade;
+var INSTANCE_POSES = ["walk", "crawl", "fallen", "attack", "scream", "crouch", "leap", "eat"];
+var MIN_HEIGHT = -2;
+var MAX_HEIGHT = 8;
+var HEIGHT_STEPS = 1e3;
+var POSE_SLOTS = 16;
+var encodePoseHeight = (pose, height = 0) => INSTANCE_POSES.indexOf(pose) + POSE_SLOTS * Math.round((Math.min(MAX_HEIGHT, Math.max(MIN_HEIGHT, height)) - MIN_HEIGHT) * HEIGHT_STEPS);
+var decodePoseHeight = (encoded) => {
+  const height = Math.floor(encoded / POSE_SLOTS) / HEIGHT_STEPS + MIN_HEIGHT;
+  return { pose: INSTANCE_POSES[encoded - Math.floor(encoded / POSE_SLOTS) * POSE_SLOTS], height };
+};
+
+// src/gait/animate.ts
+var TWO_PI = Math.PI * 2;
+var LEAP_AIR_SHARE = 0.38;
+var LEAP_PHASE_DIVISOR = 6.3;
+var DEFAULT_PROFILE = { f: 1.1, a: 0.28, k: 0.35, drag: true, arm: 0.08 };
+var leap = ({ rest, time, phase, profile }) => {
+  const sample = emptySample();
+  const cycle = (time * profile.f + phase / LEAP_PHASE_DIVISOR) % 1;
+  const air = cycle < LEAP_AIR_SHARE ? Math.sin(cycle / LEAP_AIR_SHARE * Math.PI) : 0;
+  sample.hipY = rest.hipY + air * 0.95;
+  sample.upper.x = rest.lean - air * 0.45;
+  rest.legs.forEach((leg, index) => sample.legs[index] = { hip: leg.hip * (1 - air * 0.7), knee: leg.knee * (1 - air * 0.75) });
+  rest.arms.forEach((arm, index) => sample.arms[index] = { shoulder: arm.shoulder - air * 2.3, elbow: arm.elbow * (1 - air) });
+  return sample;
+};
+var animateProfile = ({ profile = DEFAULT_PROFILE, rest, time, phase, stride }) => {
+  const own = { frequency: profile.f, swing: profile.a ?? 0, kneeBend: profile.k ?? 0 };
+  const { frequency, swing, kneeBend } = stride ? strideFor(stride, own) : own;
+  const angle = time * frequency * TWO_PI + phase;
+  const sine = Math.sin(angle);
+  const cosine = Math.cos(angle);
+  const sample = emptySample();
+  if (profile.leap) return leap({ rest, time, phase, profile });
+  if (profile.listen) {
+    sample.head.y = Math.sin(time * 0.7 + phase) * 0.6;
+    rest.arms.forEach((arm, index) => sample.arms[index] = { shoulder: arm.shoulder + Math.sin(time * 0.9 + index) * 0.08 });
+    return sample;
+  }
+  if (profile.eat) {
+    const wave = Math.sin(time * profile.f * TWO_PI + phase);
+    sample.head.x = rest.headX + Math.max(0, wave) * 0.35;
+    sample.upper.x = rest.lean + Math.max(0, wave) * 0.08;
+    rest.arms.forEach((arm, index) => sample.arms[index] = { elbow: arm.elbow + wave * 0.2 });
+    return sample;
+  }
+  if (profile.crawl) {
+    rest.arms.forEach((arm, index) => {
+      const wave = index ? sine : -sine;
+      sample.arms[index] = { shoulder: arm.shoulder + wave * 0.35, elbow: arm.elbow - Math.max(0, wave) * 0.6 };
+    });
+    sample.upper.z = sine * 0.06;
+    return sample;
+  }
+  if (profile.idle) {
+    const scare = Math.max(0, Math.sin(time * 0.9 + phase));
+    sample.upper.x = rest.lean - scare * 0.18;
+    sample.head.x = rest.headX - scare * 0.25;
+    rest.arms.forEach((arm, index) => sample.arms[index] = { shoulder: arm.shoulder + scare * 0.25 });
+    return sample;
+  }
+  rest.legs.forEach((leg, index) => {
+    if (leg.lost) return;
+    const wave = index ? -sine : sine;
+    if (profile.drag && index === 1) return void (sample.legs[index] = { hip: leg.hip + wave * swing * 0.35, knee: leg.knee });
+    sample.legs[index] = { hip: leg.hip + wave * swing, knee: leg.knee + Math.max(0, index ? cosine : -cosine) * kneeBend };
+  });
+  rest.arms.forEach((arm, index) => sample.arms[index] = { shoulder: arm.shoulder + (index ? sine : -sine) * (profile.arm || 0.1) });
+  sample.hipY = rest.hipY - Math.abs(cosine) * (profile.bob || 0.02);
+  sample.upper.y = sine * 0.06;
+  sample.upper.z = (profile.sway || 0) * sine + (profile.drag ? 0.04 : 0);
+  if (profile.stalk) sample.upper.x = rest.lean + sine * 0.04;
+  if (profile.sniff) sample.head.y = Math.sin(time * 3.1 + phase) * 0.35;
+  return sample;
+};
+
+// src/gait/cascade.ts
+var stepCascade = (current, target, dt, joint, rates = CASCADE) => current + (target - current) * Math.min(1, dt * rates[joint]);
+var lerpPose = (from, to, amount) => {
+  const result = {};
+  for (const name of Object.keys(to)) {
+    const start = from[name];
+    const end = to[name];
+    result[name] = start === void 0 ? end : start + (end - start) * amount;
+  }
+  return result;
+};
+
+// src/gait/moves.ts
+var MOVES = gait_default.moves;
+var MOVE_BLEND_RATE = 4;
+var moveBlendOf = (move) => ({ ...MOVES[move] });
+var blendMoves = (current, target, dt) => {
+  const goal = typeof target === "string" ? MOVES[target] : target;
+  const amount = Math.min(1, dt * MOVE_BLEND_RATE);
+  for (const key of Object.keys(goal)) current[key] += (goal[key] - current[key]) * amount;
+  return current;
+};
+var REANIMATED_STAGE = 4;
+var TREMOR_STAGE = 3;
+var humanPose = (params) => {
+  const { moves, time, phase, cycle, hunch, armRaise, stage, reduced = false, skirt = false } = params;
+  const zombie = stage === REANIMATED_STAGE;
+  const walking = reduced ? 0 : moves.gait;
+  const phased = phase + time;
+  const shift = reduced ? 0 : Math.sin(time * 0.45 + phase) * (1 - walking) * (1 - moves.aim);
+  const upperX = hunch + moves.crouch * 0.15 + (stage >= TREMOR_STAGE && !reduced ? Math.sin(phased * 2.3) * 0.03 : 0);
+  const upperY = walking * Math.sin(cycle - 0.35) * (0.08 + moves.arm * 0.12) - moves.aim * 0.35 + moves.turn * 0.25;
+  const upperZ = -shift * 0.025 + walking * Math.sin(cycle - 0.35) * 0.02 + (zombie ? 0.05 + Math.sin(cycle * 0.5) * 0.06 * walking : 0);
+  const legs = params.legSides.map((side, index) => {
+    const legCycle = cycle + (index ? Math.PI : 0);
+    const amplitude = moves.amp * (zombie && index === 0 ? 0.45 : 1) * (skirt ? 0.75 : 1);
+    return {
+      hip: -walking * Math.sin(legCycle) * amplitude - moves.crouch * 0.95 + (zombie && !walking ? index ? -0.1 : 0.08 : 0),
+      knee: walking * (Math.max(0, Math.cos(legCycle)) * moves.knee * (zombie && index === 0 ? 0.3 : 1) + 0.06) + moves.crouch * 1.55 + (1 - walking) * (0.03 + Math.max(0, shift * (index ? 1 : -1)) * 0.18),
+      hipZ: side * (0.02 + moves.aim * 0.1 + moves.crouch * 0.06)
+    };
+  });
+  const arms = params.arms.map(({ side, hold = false }, index) => {
+    const raise = armRaise * (hold && !zombie ? 0.2 : 1);
+    const swing = cycle - 0.25;
+    const shoulderX2 = (hold ? -0.2 : 0) - raise * (zombie ? 1.12 : 1.3) - side * Math.sin(swing) * moves.arm * walking * (zombie ? 0.3 : 1) + (reduced || walking ? 0 : Math.sin(phased * 1.6 + side) * 0.04) + (zombie && !reduced ? Math.sin(phased * 3 + side * 2) * 0.08 : 0);
+    const aimX = index === 0 ? -1.45 : -1.32;
+    return {
+      shoulder: shoulderX2 * (1 - moves.aim) + aimX * moves.aim,
+      shoulderZ: side * (0.07 + (zombie ? 0.1 : 0)) * (1 - moves.aim) - side * 0.32 * moves.aim,
+      elbow: zombie ? -0.18 : -((moves.elb + (hold ? 0.25 : 0) + walking * Math.max(0, side * Math.sin(swing - 0.3)) * 0.3) * (1 - moves.aim) + (index === 0 ? 0.15 : 0.55) * moves.aim),
+      wrist: reduced ? 0 : -walking * Math.sin(swing - 0.6) * 0.15 * side * (1 - moves.aim),
+      grip: (hold ? 1.25 : moves.grip) * (zombie ? 0.5 : 1)
+    };
+  });
+  const headY = (reduced ? 0 : Math.sin(phased * 0.5) * 0.25 * (1 - walking) * (1 - moves.aim) * (zombie ? 0.3 : 1)) - upperY * 0.75 * (1 - moves.turn) + moves.turn * 0.45 + moves.aim * 0.3;
+  return {
+    chestScaleY: 1 + (reduced ? 0 : Math.sin(phased * (1.6 + moves.freq * 0.12)) * (0.012 + moves.freq * 12e-4)),
+    hip: { x: shift * 0.025 + walking * Math.sin(cycle) * 0.018, y: -walking * moves.bob * Math.abs(Math.sin(cycle)) - moves.crouch * 0.26, zRotation: shift * 0.02 - walking * Math.sin(cycle) * 0.022 },
+    upper: { x: upperX, y: upperY, z: upperZ },
+    head: { x: -hunch * 0.6 - moves.crouch * 0.12 + (zombie ? 0.15 : 0) + walking * Math.sin(cycle * 2 - 0.6) * 0.02, y: headY, z: (zombie ? 0.22 : 0) - upperZ * 0.6 },
+    legs,
+    arms
+  };
+};
+var LIMP = { swing: 0.3, knee: 0.05, lean: 0.07 };
+
+// src/gait/lying.ts
+var CRAWL_TILT_RATE = 4;
+var DEAD_TILT_RATE = 3;
+var crawlPose = (time, phase, sides) => {
+  const cycle = time * 2.2 + phase;
+  const wave = Math.sin(cycle);
+  return {
+    figTilt: 1.38,
+    hipY: 0.2 + Math.abs(wave) * 0.02,
+    hipZRotation: wave * 0.05,
+    upper: { x: 0, y: wave * 0.12 },
+    headX: -0.95,
+    arms: sides.map((side) => ({ shoulder: -2.55 + side * wave * 0.45, shoulderZ: side * 0.25, elbow: -0.35 - Math.max(0, -side * wave) * 0.6 })),
+    legs: [
+      { hip: 0.1, knee: 0 },
+      { hip: 0.12 + wave * 0.08, knee: 0.25 }
+    ]
+  };
+};
+var deadPose = (armSides) => ({
+  figTilt: -1.45,
+  hipY: 0.22,
+  headY: 0.5,
+  arms: armSides.map((side) => ({ shoulder: -0.2, shoulderZ: side * 1.1, elbow: -0.3 })),
+  legs: [-0.15, 0.15].map((hipZ) => ({ hip: 0, hipZ, knee: 0.1 }))
+});
+
+// src/condition/timeline.ts
+var phaseIndexAt = (phases, units) => {
+  let found = 0;
+  phases.forEach((phase, index) => {
+    if (units >= phase.startsAt) found = index;
+  });
+  return found;
+};
+var mixEffects = (from, to, amount) => {
+  const result = {};
+  for (const name of /* @__PURE__ */ new Set([...Object.keys(from ?? {}), ...Object.keys(to ?? {})])) {
+    const start = from?.[name] ?? 0;
+    result[name] = start + ((to?.[name] ?? 0) - start) * amount;
+  }
+  return result;
+};
+var createConditionTimeline = (options) => {
+  const { phases, unitsPerSecond = 1, blend = false } = options;
+  if (phases.length === 0) throw new Error("createConditionTimeline: at least one phase is required");
+  let units = 0;
+  const sample = () => {
+    const index = phaseIndexAt(phases, units);
+    const phase = phases[index];
+    const next = phases[index + 1];
+    const progress = next ? Math.min(1, (units - phase.startsAt) / (next.startsAt - phase.startsAt)) : 1;
+    const effects = blend && next ? mixEffects(phase.effects, next.effects, progress) : { ...phase.effects };
+    return { index, phase, progress, effects, isFinal: !next };
+  };
+  return {
+    get elapsed() {
+      return units;
+    },
+    advance(seconds) {
+      units += seconds * unitsPerSecond;
+      return sample();
+    },
+    seek(target) {
+      units = Math.max(0, target);
+      return sample();
+    },
+    sample,
+    reset() {
+      units = 0;
+    }
+  };
+};
+
+// src/data/appearance.json
+var appearance_default = {
+  variance: {
+    height: {
+      gaussianSpread: 0.09,
+      min: 0.9,
+      max: 1.1
+    },
+    buildBands: [
+      {
+        below: 0.3,
+        base: 0.85,
+        range: 0.1
+      },
+      {
+        below: 0.8,
+        base: 0.95,
+        range: 0.13
+      },
+      {
+        base: 1.08,
+        range: 0.17
+      }
+    ],
+    buildSpeed: {
+      lean: 1.05,
+      heavy: 0.9
+    },
+    buildHealth: {
+      lean: 0.9,
+      heavy: 1.15
+    },
+    speedJitter: {
+      base: 0.92,
+      range: 0.16
+    },
+    wanderJitter: {
+      base: 0.8,
+      range: 0.4
+    },
+    runnerAgeClamp: 1,
+    variantCount: {
+      walker: 4,
+      runner: 3,
+      crawler: 2,
+      brute: 2
+    },
+    variantSeedBase: 7e3
+  },
+  civilianColors: [
+    "6D5A4A",
+    "4D5D6B",
+    "7A3B33",
+    "5B6B4A",
+    "8A7A5A",
+    "3E4A5C",
+    "6A4A6A",
+    "9A8A70",
+    "40403A"
+  ],
+  corpses: {
+    max: 400,
+    lifeSeconds: 900
+  }
+};
+
+// src/appearance/variance.ts
+var { variance } = appearance_default;
+var clamp = (value, low, high) => Math.min(high, Math.max(low, value));
+var drawBodyVariance = (random, scale = {}) => {
+  const spread = (random() + random() + random() - 1.5) * variance.height.gaussianSpread;
+  const height = clamp(1 + spread, variance.height.min, variance.height.max) * (scale.height ?? 1);
+  const band = random();
+  const bands = variance.buildBands;
+  const found = bands.find((candidate) => candidate.below !== void 0 && band < candidate.below) ?? bands[bands.length - 1];
+  const { base, range } = found;
+  const build = (base + random() * range) * (scale.build ?? 1);
+  const buildClass = band < 0.3 ? "lean" : band >= 0.8 ? "heavy" : "average";
+  const speedBuild = buildClass === "lean" ? variance.buildSpeed.lean : buildClass === "heavy" ? variance.buildSpeed.heavy : 1;
+  const healthBuild = buildClass === "lean" ? variance.buildHealth.lean : buildClass === "heavy" ? variance.buildHealth.heavy : 1;
+  return {
+    height,
+    build,
+    buildClass,
+    speedFactor: speedBuild * (variance.speedJitter.base + random() * variance.speedJitter.range),
+    wanderFactor: variance.wanderJitter.base + random() * variance.wanderJitter.range,
+    healthFactor: healthBuild
+  };
+};
+var variantCountFor = (typeId) => variance.variantCount[typeId] ?? 1;
+var variantSeed = (typeIndex, variant) => variance.variantSeedBase + typeIndex * 101 + variant * 13;
+var variantDecay = (variant) => variant % 2 === 0 ? 1 : 2;
+
+// src/appearance/palette.ts
+var palette_exports = {};
+__export(palette_exports, {
+  BAG_COLORS: () => BAG_COLORS,
+  BLOOD_COLORS: () => BLOOD_COLORS,
+  CAP_COLORS: () => CAP_COLORS,
+  DECAY_SKIN: () => DECAY_SKIN,
+  GRAY: () => GRAY,
+  HAIR_COLORS: () => HAIR_COLORS,
+  HAIR_STYLES_FEMALE: () => HAIR_STYLES_FEMALE,
+  HAIR_STYLES_MALE: () => HAIR_STYLES_MALE,
+  OLD_HAIR: () => OLD_HAIR,
+  PANTS_COLORS: () => PANTS_COLORS,
+  RED: () => RED,
+  SHOE_COLORS: () => SHOE_COLORS,
+  SKIN_DECAY_BLEND: () => SKIN_DECAY_BLEND,
+  SKIN_TONES: () => SKIN_TONES,
+  SLEEVES: () => SLEEVES,
+  TOP_COLORS: () => TOP_COLORS,
+  UNIFORM_PANTS: () => UNIFORM_PANTS,
+  UNIFORM_SHIRTS: () => UNIFORM_SHIRTS,
+  UNIFORM_SHOES: () => UNIFORM_SHOES
+});
+var SKIN_TONES = [15845797, 14724224, 13012066, 11039050, 9067066, 6175526];
+var TOP_COLORS = [4878230, 9321275, 6113850, 5208643, 7040888, 4153146, 5917294, 9071162, 12104354, 2894896, 10111530, 3104099, 13216074, 8007242, 14210248, 3820138];
+var PANTS_COLORS = [2896704, 2040360, 4866096, 5922662, 3820138, 6969920, 2767402];
+var SLEEVES = ["short", "short", "long", "tank"];
+var HAIR_STYLES_FEMALE = ["long", "long", "bun", "short", "afro", "bald"];
+var HAIR_STYLES_MALE = ["short", "short", "buzz", "bald", "afro", "long"];
+var CAP_COLORS = [9321275, 2894896, 3820138, 13216074];
+var BAG_COLORS = [3820090, 5909028, 2896704];
+var HAIR_COLORS = [1709072, 2760214, 3877920, 6965802, 11569744, 8006170];
+var SHOE_COLORS = [1908514, 3811866, 12104872, 4856346];
+var DECAY_SKIN = [13482920, 9740420, 8090698, 9206878];
+var UNIFORM_SHIRTS = [4878230, 9321275, 6113850, 5208643, 7040888, 4153146, 5917294, 9071162];
+var UNIFORM_PANTS = 2896704;
+var UNIFORM_SHOES = 1908514;
+var SKIN_DECAY_BLEND = [0.45, 0.65, 0.8, 0.88];
+var GRAY = 4868678;
+var RED = 8000012;
+var BLOOD_COLORS = [10361618, 7214096, 4860440, 1840658];
+var OLD_HAIR = 9078656;
+
+// src/appearance/traits.ts
+var BLOOD_SEED_OFFSET = 99;
+var createBloodStream = (seed) => createRng(seed + BLOOD_SEED_OFFSET);
+var FEMALE_SHARE = 0.42;
+var BEARD_SHARE = 0.25;
+var GLASSES_SHARE = 0.12;
+var CAP_SHARE = 0.12;
+var BAG_SHARE = 0.15;
+var TORN_SHARE = 0.35;
+var APRON_SHARE = 0.05;
+var drawAppearance = (params) => {
+  const { seed, outfit = {}, uniform = false, typeIndex = 0, human = false, life = 1 } = params;
+  const random = createRng(seed);
+  const pick = (options) => options[Math.floor(random() * options.length)];
+  const female = !uniform && (params.allowFemale ?? true) && (params.female ?? random() < FEMALE_SHARE);
+  const tone = params.tone ?? (uniform ? DECAY_SKIN[0] : pick(SKIN_TONES));
+  const topColor = outfit.cloth ?? (uniform ? UNIFORM_SHIRTS[(params.clothIndex ?? typeIndex) % UNIFORM_SHIRTS.length] : pick(TOP_COLORS));
+  const pantsColor = outfit.pants ?? (uniform ? UNIFORM_PANTS : pick(PANTS_COLORS));
+  const look = uniform ? uniformLook() : drawLook({ random, pick, female, outfit, human, params });
+  const hairColor = params.hairColor ?? (life === 2 ? OLD_HAIR : pick(HAIR_COLORS));
+  const shoeColor = uniform ? UNIFORM_SHOES : pick(SHOE_COLORS);
+  return { traits: { female, tone, topColor, pantsColor, ...look, hairColor, shoeColor }, random };
+};
+var uniformLook = () => ({
+  sleeve: "short",
+  hair: "short",
+  headWidth: 1,
+  headHeight: 1,
+  jaw: 1,
+  nose: 1,
+  beard: false,
+  glasses: false,
+  cap: false,
+  capColor: 0,
+  bag: false,
+  bagColor: 0,
+  torn: false,
+  apron: false
+});
+var drawLook = ({ random, pick, female, outfit, human, params }) => {
+  const sleeve = outfit.cloth ? "long" : pick(SLEEVES);
+  const hair = params.hairStyle ?? (params.wet ? "long" : params.charred ? "bald" : pick(female ? HAIR_STYLES_FEMALE : HAIR_STYLES_MALE));
+  const headWidth = 1 + (random() - 0.5) * 0.16;
+  const headHeight = 1 + (random() - 0.5) * 0.14;
+  const jaw = 1 + (random() - 0.5) * 0.3;
+  const nose = 1 + (random() - 0.5) * 0.5;
+  const beard = !female && random() < BEARD_SHARE;
+  const glasses = random() < GLASSES_SHARE;
+  const cap = !outfit.hat && random() < CAP_SHARE;
+  const capColor = pick(CAP_COLORS);
+  const bag = random() < BAG_SHARE && !human;
+  const bagColor = pick(BAG_COLORS);
+  const torn = random() < TORN_SHARE && !human;
+  const apron = random() < APRON_SHARE;
+  return { sleeve, hair, headWidth, headHeight, jaw, nose, beard, glasses, cap, capColor, bag, bagColor, torn, apron };
+};
+export {
+  ARSENAL_RULES,
+  palette_exports as AppearancePalette,
+  BLOOD_LITERS_PER_DROP,
+  BLOOD_SEED_OFFSET,
+  BODY_MATERIAL,
+  BODY_REGIONS,
+  CASCADE,
+  CRAWL_TILT_RATE,
+  DAMAGE_PRESETS,
+  DEAD_TILT_RATE,
+  DEFAULT_CORPSES,
+  DEFAULT_DAMAGE_RULES,
+  ELENCO_RULES,
+  GAME_BONES,
+  GUIDE,
+  INSTANCE_POSES,
+  JOINT_IDS,
+  JOINT_PARENTS,
+  LAYERED_PROTECTION_CAP,
+  LIMB_REGIONS,
+  LIMP,
+  MOVES,
+  MOVE_BLEND_RATE,
+  PENETRATION_MODELS,
+  PERSON_PRESET,
+  PHYSICAL_PENETRATION,
+  PROTECTION_PRESETS,
+  REGION_HIT_POINTS,
+  REGION_SEGMENTS,
+  SEGMENT_IDS,
+  SEGMENT_NUMBERS,
+  SEGMENT_TREE,
+  TEAM_GAME,
+  TEAM_GAME_CALIBERS,
+  TEAM_GAME_CALIBER_KEYS,
+  TEAM_GAME_PENETRATION,
+  TORSO_RESISTANCE,
+  animateProfile,
+  applyPatches,
+  applyPreset,
+  bleedRateAt,
+  blendMoves,
+  crawlPose,
+  createBloodStream,
+  createBodySpec,
+  createCharacters,
+  createConditionTimeline,
+  createCorpseLedger,
+  createRig,
+  createRng,
+  cutOf,
+  deadPose,
+  decodePoseHeight,
+  describeBody,
+  drawAppearance,
+  drawBodyVariance,
+  emptySample,
+  encodePoseHeight,
+  energyKept,
+  humanPose,
+  isBodyRegion,
+  isSegmentId,
+  layeredProtection,
+  layersOn,
+  lerpPose,
+  mergeById,
+  moveBlendOf,
+  penetrateLine,
+  penetrationForce,
+  pointsFromEnergy,
+  projectileOf,
+  protect,
+  removeIds,
+  resolveDamageRules,
+  resolvePoints,
+  segmentNode,
+  segmentResistance,
+  segmentsBelow,
+  spreadPoints,
+  stepCascade,
+  strideFor,
+  teamGameCost,
+  teamGameFalloff,
+  variantCountFor,
+  variantDecay,
+  variantSeed,
+  walkCadence,
+  walkGait
+};
+//# sourceMappingURL=index.js.map