@adatechnology/game-player 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1025 @@
+// src/data/defaults.json
+var defaults_default = {
+  sources: {
+    game: "specs/001-migracao-entregas-dos-times/artefatos/2UG1Mhe9LqJkQKKVsJkTWR/jogo.js",
+    attributes: "G 62004 FICHA (Personagens 3.2: every attribute 5, no traits)",
+    derived: "G 62005-62012 DERIV",
+    wounds: "G 62016 FERIDA (Personagens 3.7): share of each wound kind, and its infection chance (used only when an infection rule is on)",
+    infection: "G 62015 INFEC (the slice's accelerated clock: fever 30 s, delirium 70 s, death 120 s, reanimation 8 s after); G 68509 fever noise",
+    numbers: "G 68427-68640 player, playerUpdate, frontZombies, shove, knife; G 68678-68681 the aim spread modifiers; G 65507 walkCad"
+  },
+  attributes: { strength: 5, vigor: 5, agility: 5, perception: 5, intellect: 5, presence: 5 },
+  derived: {
+    maxHealth: { base: 70, terms: [["vigor", 6]] },
+    maxStamina: { base: 40, terms: [["vigor", 6], ["agility", 4]] },
+    runSpeed: { base: 5.2, terms: [["agility", 0.12]] },
+    walkSpeed: { base: 1.6, terms: [] },
+    footstepNoise: { base: 100, terms: [["agility", -4]], divide: 100 },
+    composure: { base: 20, terms: [["vigor", 3], ["presence", 4]] }
+  },
+  wounds: {
+    scratch: { share: 0.6, infectionChance: 0.06, bleeds: false },
+    laceration: { share: 0.3, infectionChance: 0.22, bleeds: true },
+    bite: { share: 0.1, infectionChance: 1, bleeds: true }
+  },
+  infection: {
+    feverSeconds: 30,
+    deliriumSeconds: 70,
+    deathSeconds: 120,
+    reanimateSeconds: 8,
+    feverNoiseEvery: 2,
+    feverNoiseChance: 0.5,
+    feverNoiseRadius: 10,
+    feverNoiseVolume: 2,
+    feverSpeed: 0.85,
+    feverSpread: 1.5
+  },
+  numbers: {
+    hurtFlash: 0.4,
+    hurtVolume: 0.8,
+    biteDamage: 25,
+    biteFlash: 0.8,
+    biteVolume: 1.2,
+    burnPerSecond: 3,
+    bleedPerSecond: 0.15,
+    grabSeconds: 3,
+    grabVolume: 1,
+    grabFollow: 12,
+    grabOffset: 0.55,
+    grabPushCost: 6,
+    grabPushMinStamina: 5,
+    grabPushVolume: 1.5,
+    grabPushes: 6,
+    grabPushStun: 1.2,
+    grabPushSpeed: 3,
+    grabKnifeChance: 0.7,
+    grabKnifeRegion: 0,
+    grabKnifeDamage: 22,
+    grabKnifeDistance: 0.5,
+    grabKnifeCut: 0.7,
+    drownDamage: 30,
+    drownFlash: 0.8,
+    noJawDamage: 8,
+    grabAttackCooldown: 2,
+    vaultSeconds: 0.7,
+    vaultCost: 15,
+    vaultHeight: 1.9,
+    vaultScanFrom: 0.3,
+    vaultScanTo: 1,
+    vaultScanStep: 0.1,
+    vaultLandFrom: 0.4,
+    vaultLandTo: 1.4,
+    vaultClearance: 0.3,
+    vaultCheckHeight: 0.4,
+    vaultNoise: 6,
+    vaultStartVolume: 0.8,
+    vaultLandVolume: 1,
+    crouchSpeed: 1,
+    walkFactor: 1.35,
+    aimSpeedCap: 1.4,
+    waterSpeed: 0.55,
+    runMinStamina: 1,
+    runDrain: 12,
+    regenMoving: 4,
+    regenStill: 8,
+    acceleration: 10,
+    radius: 0.3,
+    blockHeight: 0.4,
+    pushApartRadius: 0.55,
+    pushApartHeight: 1.2,
+    hipFollow: 10,
+    hipMinSpeed: 0.3,
+    hipLimit: 0.9,
+    backwardsBelow: -0.1,
+    cadenceBase: 0.5,
+    cadencePerSpeed: 0.3,
+    cadenceMinSpeed: 0.05,
+    turnFollow: 12,
+    stepEvery: 0.75,
+    stepMinSpeed: 0.3,
+    stepNoiseRun: 8,
+    stepNoiseWalk: 3,
+    stepNoiseCrouch: 1,
+    stepNoiseWater: 2,
+    stepVolumeRun: 0.6,
+    stepVolumeWalk: 0.3,
+    shoveCost: 10,
+    shoveVolume: 1.2,
+    shoveRange: 1.6,
+    shoveCone: 0.3,
+    shoveStun: 0.9,
+    shoveSpeed: 2.5,
+    meleeMinStamina: 5,
+    meleeCostLight: 5,
+    meleeCostHeavy: 12,
+    meleeHeavyKg: 1.5,
+    meleeVolume: 0.6,
+    meleeRangeBase: 0.9,
+    meleeCone: 0.5,
+    meleeHeadChance: 0.35,
+    meleeArmChance: 0.5,
+    meleeStrengthPerPoint: 0.06,
+    meleeStrengthBase: 5,
+    meleeCritToCut: 60,
+    panicGain: 1.2,
+    panicDecay: 3,
+    panicMax: 100,
+    panicSpreadAt: 0.6,
+    panicSpread: 1.4,
+    moveSpread: 0.4
+  },
+  fist: { damage: 8, crit: 0, reach: 0.5, noise: 1 }
+};
+
+// src/rng.ts
+function 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;
+  };
+}
+
+// src/player.ts
+var PLAYER_DEFAULTS = defaults_default;
+var TAU_APPROX = 6.2832;
+var evaluate = (formula, attributes) => {
+  let value = formula.base;
+  for (const [attribute, coefficient] of formula.terms) value += coefficient * attributes[attribute];
+  return formula.divide === void 0 ? value : value / formula.divide;
+};
+var deriveVitals = (attributes, formulas = PLAYER_DEFAULTS.derived) => {
+  const out = {};
+  for (const id of Object.keys(formulas)) out[id] = evaluate(formulas[id], attributes);
+  return out;
+};
+var drawWound = (wounds, random) => {
+  const kinds = Object.keys(wounds);
+  const draw = random();
+  let acc = 0;
+  for (let k = 0; k < kinds.length - 1; k++) {
+    acc += wounds[kinds[k]].share;
+    if (draw < acc) return kinds[k];
+  }
+  return kinds[kinds.length - 1];
+};
+var clamp = (v, a, b) => v < a ? a : v > b ? b : v;
+var lerp = (a, b, t) => a + (b - a) * t;
+var freshState = (derived, position) => ({
+  x: position?.x ?? 0,
+  z: position?.z ?? 0,
+  y: 0,
+  vx: 0,
+  vz: 0,
+  yaw: position?.yaw ?? 0,
+  floor: 0,
+  alive: true,
+  turned: false,
+  health: derived.maxHealth,
+  stamina: derived.maxStamina,
+  crouch: false,
+  running: false,
+  stepTimer: 0,
+  phase: 0,
+  hip: 0,
+  grabbedBy: -1,
+  grabTimer: 0,
+  grabPushes: 0,
+  grabNoJaw: false,
+  grabDrown: false,
+  infected: false,
+  infectionTime: 0,
+  infectionSource: "",
+  wounds: [],
+  bleeding: 0,
+  blind: 0,
+  screamBoost: 0,
+  panic: 0,
+  hurtFlash: 0,
+  deathTime: 0,
+  cause: "",
+  downTimer: 0,
+  burnTimer: 0,
+  scentTimer: 0,
+  vaultTimer: 0,
+  vault: null
+});
+function createPlayer(options = {}) {
+  const random = options.random ?? createRng(options.seed ?? 1);
+  const attributes = { ...PLAYER_DEFAULTS.attributes, ...options.attributes };
+  const formulas = { ...PLAYER_DEFAULTS.derived, ...options.derived };
+  const derived = deriveVitals(attributes, formulas);
+  const numbers = { ...PLAYER_DEFAULTS.numbers, ...options.numbers };
+  const wounds = options.wounds ?? PLAYER_DEFAULTS.wounds;
+  const infection = options.infection === void 0 || options.infection === false ? null : options.infection === true ? PLAYER_DEFAULTS.infection : { ...PLAYER_DEFAULTS.infection, ...options.infection };
+  const fist = options.fist ?? PLAYER_DEFAULTS.fist;
+  const listeners = /* @__PURE__ */ new Map();
+  let P = freshState(derived, options.position);
+  let defaultWorld = options.world ?? {};
+  let world = defaultWorld;
+  const emit = (event, payload) => {
+    const set = listeners.get(event);
+    if (set) for (const listener of set) listener(payload);
+  };
+  const sound = (id, volume) => emit("sound", { sound: id, volume, position: [P.x, P.y, P.z] });
+  const noise = (x, z, radius) => emit("noise", { x, z, radius });
+  const message = (id, seconds) => emit("message", { id, seconds });
+  const inWater = (x, z) => world.inWater?.(x, z) ?? false;
+  const solidAt = (x, z, y) => world.solidAt?.(x, z, y) ?? false;
+  const cellKind = (x, z) => world.cellKind?.(x, z) ?? 0;
+  const blocked = (x, z) => world.blocked ? world.blocked(x, z) : solidAt(x, z, numbers.blockHeight);
+  const chanceOf = (kind) => infection?.chances?.[kind] ?? wounds[kind]?.infectionChance ?? 0;
+  const die = (cause) => {
+    if (!P.alive) return;
+    P.alive = false;
+    P.cause = cause;
+    P.deathTime = 0;
+    P.grabbedBy = -1;
+    message(cause, 6);
+    emit("died", { cause });
+  };
+  const infect = (source) => {
+    if (P.infected || !infection) return;
+    P.infected = true;
+    P.infectionTime = 0;
+    P.infectionSource = source;
+    emit("infected", { source });
+  };
+  const release = (how = "free") => {
+    const by = P.grabbedBy;
+    P.grabbedBy = -1;
+    if (by >= 0) emit("released", { by, how });
+  };
+  const hurt = (amount) => {
+    if (!P.alive) return;
+    P.health -= amount;
+    P.hurtFlash = numbers.hurtFlash;
+    sound("flesh", numbers.hurtVolume);
+    const kind = drawWound(wounds, random);
+    P.wounds.push(kind);
+    if (wounds[kind]?.bleeds) P.bleeding = 1;
+    emit("hurt", { amount, wound: kind });
+    if (infection && !P.infected && random() < chanceOf(kind)) infect(kind);
+    if (P.health <= 0) die(P.infected ? "infected" : "killed");
+  };
+  const bite = () => {
+    P.health -= numbers.biteDamage;
+    P.hurtFlash = numbers.biteFlash;
+    P.bleeding = 1;
+    P.wounds.push("bite");
+    sound("flesh", numbers.biteVolume);
+    emit("hurt", { amount: numbers.biteDamage, wound: "bite" });
+    infect("bite");
+    message("bitten", 5);
+    if (P.health <= 0) die("bitten_to_death");
+  };
+  const grab = (by, noJaw = false, drown = false) => {
+    P.grabbedBy = by;
+    P.grabTimer = numbers.grabSeconds;
+    P.grabPushes = 0;
+    P.grabNoJaw = noJaw;
+    P.grabDrown = drown;
+    message(drown ? "grabbed_drown" : "grabbed", 3);
+    sound("flesh", numbers.grabVolume);
+    emit("grabbed", { by, noJaw, drown });
+  };
+  const front = (range, cosMin, yaw, crowd = world.crowd) => {
+    const out = [];
+    if (!crowd) return out;
+    const fx = -Math.sin(yaw);
+    const fz = -Math.cos(yaw);
+    const n = crowd.count();
+    for (let i = 0; i < n; i++) {
+      if (!crowd.active(i) || crowd.floor(i) !== P.floor) continue;
+      const ex = crowd.x(i) - P.x;
+      const ez = crowd.z(i) - P.z;
+      const d = Math.hypot(ex, ez);
+      if (d < range && (ex * fx + ez * fz) / (d || 1) > cosMin) out.push([d, i]);
+    }
+    return out.sort((a, b) => a[0] - b[0]);
+  };
+  const shove = (yaw) => {
+    sound("step", numbers.shoveVolume);
+    const crowd = world.crowd;
+    const targets = [];
+    for (const [d, i] of front(numbers.shoveRange, numbers.shoveCone, yaw)) {
+      crowd.stun(i, numbers.shoveStun, (crowd.x(i) - P.x) / d * numbers.shoveSpeed, (crowd.z(i) - P.z) / d * numbers.shoveSpeed);
+      targets.push(i);
+    }
+    emit("shove", { targets });
+  };
+  const melee = (item, yaw) => {
+    const t = front(numbers.meleeRangeBase + (item.reach ?? 0), numbers.meleeCone, yaw)[0];
+    sound("flesh", numbers.meleeVolume);
+    noise(P.x, P.z, item.noise || 1);
+    if (!t) return;
+    const crowd = world.crowd;
+    const i = t[1];
+    const region = crowd.down(i) ? 0 : random() < numbers.meleeHeadChance ? 0 : random() < numbers.meleeArmChance ? 1 : 2 + Math.floor(random() * 2);
+    const damage = item.damage * (1 + (attributes.strength - numbers.meleeStrengthBase) * numbers.meleeStrengthPerPoint);
+    const cut = Math.min(1, (item.crit || 0) / numbers.meleeCritToCut);
+    crowd.damage(i, { region, amount: damage, distance: t[0], cut });
+    emit("melee", { target: i, region, damage, distance: t[0], cut });
+  };
+  const update = (dt, input = {}, frameWorld) => {
+    world = frameWorld ?? defaultWorld;
+    if (!P.alive) {
+      P.deathTime += dt;
+      if (P.infected && infection && !P.turned && P.deathTime >= infection.reanimateSeconds) {
+        P.turned = true;
+        emit("turned", { x: P.x, z: P.z, floor: P.floor });
+      }
+      return;
+    }
+    const pressed = { ...input.pressed };
+    const wasPressed = (action) => {
+      const v = pressed[action] === true;
+      pressed[action] = false;
+      return v;
+    };
+    const viewYaw = input.yaw ?? 0;
+    const crowd = world.crowd;
+    P.screamBoost = Math.max(0, P.screamBoost - dt);
+    P.blind = Math.max(0, P.blind - dt);
+    P.hurtFlash = Math.max(0, P.hurtFlash - dt);
+    if (P.infected && infection) {
+      const before = P.infectionTime;
+      P.infectionTime += dt;
+      if (before <= infection.feverSeconds && P.infectionTime > infection.feverSeconds) emit("stage", { stage: "fever" });
+      if (before <= infection.deliriumSeconds && P.infectionTime > infection.deliriumSeconds) emit("stage", { stage: "delirium" });
+      const every = 1 / infection.feverNoiseEvery;
+      if (P.infectionTime > infection.feverSeconds && Math.floor(P.infectionTime * every) !== Math.floor((P.infectionTime - dt) * every) && random() < infection.feverNoiseChance) {
+        noise(P.x, P.z, infection.feverNoiseRadius);
+        sound("step", infection.feverNoiseVolume);
+      }
+      if (P.infectionTime > infection.deathSeconds) {
+        P.health = 0;
+        die("infection");
+        return;
+      }
+    }
+    if (P.burnTimer > 0) {
+      P.burnTimer -= dt;
+      P.health -= numbers.burnPerSecond * dt;
+      if (inWater(P.x, P.z)) P.burnTimer = 0;
+    }
+    P.scentTimer = Math.max(0, P.scentTimer - dt);
+    if (P.bleeding) {
+      P.health -= dt * numbers.bleedPerSecond;
+      if (input.bandage && P.bleeding) {
+        P.bleeding = 0;
+        message("bandaged", 2);
+      }
+    }
+    if (P.health <= 0) {
+      die(P.infected ? "infected" : P.bleeding ? "bled_out" : "hunger_thirst");
+      return;
+    }
+    if (P.grabbedBy >= 0) {
+      const i = P.grabbedBy;
+      P.grabTimer -= dt;
+      if (crowd) {
+        const k = 1 - Math.exp(-dt * numbers.grabFollow);
+        crowd.hold(i, P.x - Math.sin(P.yaw) * numbers.grabOffset, P.z - Math.cos(P.yaw) * numbers.grabOffset, k, P.x, P.z);
+      }
+      if (wasPressed("push") && P.stamina > numbers.grabPushMinStamina) {
+        P.grabPushes++;
+        P.stamina -= numbers.grabPushCost;
+        sound("step", numbers.grabPushVolume);
+      }
+      if (wasPressed("knife")) {
+        if (random() < numbers.grabKnifeChance) {
+          crowd?.damage(i, { region: numbers.grabKnifeRegion, amount: numbers.grabKnifeDamage, distance: numbers.grabKnifeDistance, cut: numbers.grabKnifeCut });
+          message("knife_head", 1.5);
+          release("knife");
+          return;
+        } else message("knife_miss", 1);
+      }
+      if (P.grabPushes >= numbers.grabPushes) {
+        crowd?.stun(i, numbers.grabPushStun, -Math.sin(viewYaw) * numbers.grabPushSpeed, -Math.cos(viewYaw) * numbers.grabPushSpeed);
+        release("push");
+        message("pushed_off", 1.2);
+        return;
+      }
+      if (P.grabTimer <= 0) {
+        if (P.grabDrown) {
+          P.health -= numbers.drownDamage;
+          P.hurtFlash = numbers.drownFlash;
+          message("drowning", 2);
+          if (P.health <= 0) {
+            die("drowned");
+            return;
+          }
+          P.grabTimer = numbers.grabSeconds;
+          P.grabPushes = 0;
+          return;
+        }
+        if (P.grabNoJaw) {
+          hurt(numbers.noJawDamage);
+          message("no_jaw", 2);
+        } else bite();
+        crowd?.chase(i, numbers.grabAttackCooldown);
+        release(P.grabNoJaw ? "scratch" : "bite");
+      }
+      return;
+    }
+    if (P.downTimer > 0) {
+      P.downTimer -= dt;
+      P.vx = P.vz = 0;
+      if (P.downTimer <= 0) message("stood_up", 0.8);
+      return;
+    }
+    if (world.busy?.(dt)) return;
+    if (P.vaultTimer > 0 && P.vault) {
+      P.vaultTimer -= dt;
+      const k = 1 - P.vaultTimer / numbers.vaultSeconds;
+      P.x = lerp(P.vault[0], P.vault[2], k);
+      P.z = lerp(P.vault[1], P.vault[3], k);
+      P.y = Math.sin(k * Math.PI) * numbers.vaultHeight;
+      if (P.vaultTimer <= 0) {
+        P.y = 0;
+        noise(P.x, P.z, numbers.vaultNoise);
+        sound("step", numbers.vaultLandVolume);
+      }
+      return;
+    }
+    if (wasPressed("vault") && P.stamina > numbers.vaultCost && (world.canVault?.() ?? !P.floor)) {
+      const fx0 = -Math.sin(viewYaw);
+      const fz0 = -Math.cos(viewYaw);
+      for (let a = numbers.vaultScanFrom; a <= numbers.vaultScanTo; a += numbers.vaultScanStep) {
+        const c = cellKind(P.x + fx0 * a, P.z + fz0 * a);
+        if (c === 2) {
+          for (let e = a + numbers.vaultLandFrom; e <= a + numbers.vaultLandTo; e += numbers.vaultScanStep) {
+            const ex = P.x + fx0 * e;
+            const ez = P.z + fz0 * e;
+            if (!solidAt(ex, ez, numbers.vaultCheckHeight) && !solidAt(ex + fx0 * numbers.vaultClearance, ez + fz0 * numbers.vaultClearance, numbers.vaultCheckHeight)) {
+              P.vault = [P.x, P.z, ex, ez];
+              P.vaultTimer = numbers.vaultSeconds;
+              P.stamina -= numbers.vaultCost;
+              sound("step", numbers.vaultStartVolume);
+              emit("vault", { from: [P.x, P.z], to: [ex, ez] });
+              return;
+            }
+          }
+          break;
+        }
+        if (c > 0 && c !== 3) break;
+      }
+    }
+    const f = input.forward ?? 0;
+    const s = input.right ?? 0;
+    if (wasPressed("crouch")) P.crouch = !P.crouch;
+    const want = f || s;
+    P.running = !!(input.run && want && P.stamina > numbers.runMinStamina && !input.aim && !P.crouch);
+    const fever = P.infected && infection !== null && P.infectionTime > infection.feverSeconds;
+    let sp = P.running ? derived.runSpeed : P.crouch ? numbers.crouchSpeed : derived.walkSpeed * numbers.walkFactor;
+    if (fever) sp *= infection.feverSpeed;
+    if (input.aim) sp = Math.min(sp, numbers.aimSpeedCap);
+    const wet = inWater(P.x, P.z);
+    if (wet) sp *= numbers.waterSpeed;
+    if (P.running) P.stamina = Math.max(0, P.stamina - numbers.runDrain * dt);
+    else P.stamina = Math.min(derived.maxStamina, P.stamina + (want ? numbers.regenMoving : numbers.regenStill) * dt);
+    const fx = -Math.sin(viewYaw);
+    const fz = -Math.cos(viewYaw);
+    const mx = fx * f - fz * s;
+    const mz = fz * f + fx * s;
+    const ml = Math.hypot(mx, mz) || 1;
+    const tvx = want ? mx / ml * sp : 0;
+    const tvz = want ? mz / ml * sp : 0;
+    P.vx = lerp(P.vx, tvx, Math.min(1, dt * numbers.acceleration));
+    P.vz = lerp(P.vz, tvz, Math.min(1, dt * numbers.acceleration));
+    const r = numbers.radius;
+    const nx = P.x + P.vx * dt;
+    const nz = P.z + P.vz * dt;
+    if (!blocked(nx + Math.sign(P.vx) * r, P.z)) P.x = nx;
+    if (!blocked(P.x, nz + Math.sign(P.vz) * r)) P.z = nz;
+    world.afterMove?.(P);
+    if (crowd) {
+      const n = crowd.count();
+      const rr = numbers.pushApartRadius;
+      for (let i = 0; i < n; i++) {
+        if (!crowd.active(i) || Math.abs(crowd.y(i) - P.y) > numbers.pushApartHeight) continue;
+        const ex = P.x - crowd.x(i);
+        const ez = P.z - crowd.z(i);
+        const e2 = ex * ex + ez * ez;
+        if (e2 < rr * rr && e2 > 1e-5) {
+          const e = Math.sqrt(e2);
+          const k = (rr - e) / e * 0.5;
+          if (!solidAt(P.x + ex * k, P.z + ez * k, numbers.blockHeight)) {
+            P.x += ex * k;
+            P.z += ez * k;
+          }
+        }
+      }
+    }
+    const spd = Math.hypot(P.vx, P.vz);
+    {
+      const cy = Math.cos(P.yaw);
+      const sy = Math.sin(P.yaw);
+      const lx = P.vx * cy - P.vz * sy;
+      const lz = P.vx * sy + P.vz * cy;
+      const back = lz < numbers.backwardsBelow ? -1 : 1;
+      const hip = spd > numbers.hipMinSpeed ? clamp(Math.atan2(lx * back, lz * back), -numbers.hipLimit, numbers.hipLimit) : 0;
+      P.hip = P.hip + (hip - P.hip) * Math.min(1, dt * numbers.hipFollow);
+      P.phase += dt * (spd < numbers.cadenceMinSpeed ? 0 : numbers.cadenceBase + numbers.cadencePerSpeed * spd) * back;
+    }
+    {
+      const target = viewYaw + Math.PI;
+      let dy = target - P.yaw;
+      dy -= Math.round(dy / TAU_APPROX) * TAU_APPROX;
+      P.yaw += input.aim || input.firing ? dy : dy * Math.min(1, dt * numbers.turnFollow);
+    }
+    P.stepTimer -= dt * spd;
+    if (P.stepTimer <= 0 && spd > numbers.stepMinSpeed) {
+      P.stepTimer = numbers.stepEvery;
+      noise(P.x, P.z, (P.running ? numbers.stepNoiseRun : P.crouch ? numbers.stepNoiseCrouch : numbers.stepNoiseWalk) * derived.footstepNoise * (wet ? numbers.stepNoiseWater : 1));
+      sound("step", P.running ? numbers.stepVolumeRun : numbers.stepVolumeWalk);
+      emit("step", { x: P.x, z: P.z, yaw: P.yaw });
+    }
+    if (wasPressed("push") && P.stamina > numbers.shoveCost) {
+      P.stamina -= numbers.shoveCost;
+      shove(viewYaw);
+    }
+    if (wasPressed("throw")) emit("throw", {});
+    if (wasPressed("knife") && P.stamina > numbers.meleeMinStamina) {
+      const item = input.melee ?? fist;
+      P.stamina -= (item.kg ?? 0) > numbers.meleeHeavyKg ? numbers.meleeCostHeavy : numbers.meleeCostLight;
+      melee(item, viewYaw);
+    }
+    let near = 0;
+    if (crowd) {
+      const n = crowd.count();
+      for (let i = 0; i < n; i++) if (crowd.active(i) && crowd.chasing(i)) near += crowd.panicWeight?.(i) ?? 1;
+    }
+    P.panic = clamp(P.panic + (near * numbers.panicGain - (near ? 0 : numbers.panicDecay)) * dt, 0, numbers.panicMax);
+  };
+  return {
+    get state() {
+      return P;
+    },
+    attributes,
+    derived,
+    numbers,
+    infection,
+    update,
+    hurt: (amount) => hurt(amount),
+    bite: () => bite(),
+    grab,
+    release: () => release("free"),
+    knock(seconds) {
+      if (!P.alive) return;
+      P.downTimer = Math.max(P.downTimer, seconds);
+      P.crouch = false;
+    },
+    infect,
+    die,
+    stage() {
+      if (!P.infected || !infection) return "none";
+      return P.infectionTime > infection.deliriumSeconds ? "delirium" : P.infectionTime > infection.feverSeconds ? "fever" : "malaise";
+    },
+    timeLeft: () => P.infected && infection ? Math.max(0, infection.deathSeconds - P.infectionTime) : null,
+    spreadFactor() {
+      const panic = P.panic > derived.composure * numbers.panicSpreadAt ? numbers.panicSpread : 1;
+      const fever = P.infected && infection && P.infectionTime > infection.feverSeconds ? infection.feverSpread : 1;
+      return panic * fever * (1 + Math.hypot(P.vx, P.vz) * numbers.moveSpread);
+    },
+    front,
+    on(event, listener) {
+      let set = listeners.get(event);
+      if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => void set.delete(listener);
+    },
+    save: () => ({ state: structuredClone(P), attributes }),
+    load(save) {
+      P = structuredClone(save.state);
+    },
+    setWorld(next) {
+      defaultWorld = next;
+    }
+  };
+}
+
+// src/locales/index.ts
+var PT_BR = {
+  grabbed: "AGARRADO! Aperte E v\xE1rias vezes para empurrar ou F para a faca",
+  grabbed_drown: "O AFOGADO TE PUXA PARA O FUNDO! E v\xE1rias vezes ou F para a faca",
+  bitten: "Voc\xEA foi mordido. N\xE3o h\xE1 cura.",
+  bandaged: "Curativo feito",
+  knife_head: "Faca na cabe\xE7a!",
+  knife_miss: "Errou a facada",
+  pushed_off: "Empurrou!",
+  drowning: "Afogando! Solte-se!",
+  no_jaw: "Sem mand\xEDbula: s\xF3 arranhou",
+  stood_up: "De p\xE9!",
+  infected: "Morreu infectado",
+  killed: "Morto pela horda",
+  bitten_to_death: "Mordido",
+  infection: "A infec\xE7\xE3o venceu",
+  bled_out: "Sangrou at\xE9 a morte",
+  hunger_thirst: "Fome e sede",
+  drowned: "Afogado",
+  burned: "Queimado"
+};
+var EN = {
+  grabbed: "GRABBED! Press E repeatedly to push or F for the knife",
+  grabbed_drown: "THE DROWNED PULLS YOU UNDER! E repeatedly or F for the knife",
+  bitten: "You were bitten. There is no cure.",
+  bandaged: "Wound dressed",
+  knife_head: "Knife to the head!",
+  knife_miss: "The stab missed",
+  pushed_off: "Pushed off!",
+  drowning: "Drowning! Break free!",
+  no_jaw: "No jaw: only a scratch",
+  stood_up: "Back on your feet!",
+  infected: "Died infected",
+  killed: "Killed by the horde",
+  bitten_to_death: "Bitten",
+  infection: "The infection won",
+  bled_out: "Bled to death",
+  hunger_thirst: "Hunger and thirst",
+  drowned: "Drowned",
+  burned: "Burned"
+};
+var PLAYER_TEXT = { en: EN, "pt-BR": PT_BR };
+var playerTextOf = (id, locale = "pt-BR") => {
+  const table = locale.toLowerCase().startsWith("en") ? EN : PT_BR;
+  return table[id] ?? id;
+};
+
+// src/bench/locale.ts
+var EN2 = {
+  group: "Player",
+  name: "Player area",
+  controls: {
+    infection: "Individual infection",
+    agility: "Agility",
+    vigor: "Vigor",
+    seed: "Seed",
+    hurt: "Take a hit (10)",
+    bite: "Bite",
+    grab: "Get grabbed",
+    push: "Push (E)",
+    knife: "Knife (F)",
+    bandage: "Bandage (B)",
+    knock: "Knocked down 1.5 s",
+    crouch: "Crouch (C)",
+    reset: "Start again"
+  },
+  hints: {
+    infection: "Off: a normal world, wounds never infect. On: the game rule (scratch 6%, laceration 22%, bite 100%; fever at 30 s, death at 120 s).",
+    agility: "The sheet: stamina, run speed and footstep noise come from it.",
+    vigor: "The sheet: health, stamina and composure come from it.",
+    seed: "The same seed gives the same wounds and the same knife rolls.",
+    grab: "Something grabs you from behind: 3 s to push it off (6 pushes) or to land the knife (70%).",
+    push: "Shoves what is in front, or pushes off what holds you."
+  },
+  metrics: {
+    health: "Health",
+    stamina: "Stamina",
+    bleeding: "Bleeding",
+    wounds: "Wounds",
+    stage: "Infection",
+    time_left: "Time left",
+    panic: "Panic",
+    spread: "Aim spread x",
+    grab: "Grab timer",
+    noise: "Last noise",
+    steps: "Footsteps",
+    message: "Message"
+  },
+  stages: { none: "None", malaise: "Malaise", fever: "Fever", delirium: "Delirium", dead: "Dead" },
+  scenarios: {
+    stamina: "Running drains stamina and resting gives it back",
+    bleed_bandage: "A laceration bleeds until it is dressed",
+    normal_world: "In a normal world a bite hurts and bleeds but never infects",
+    infection_kills: "With the infection on, a bite brings fever and kills at its time",
+    grab_break_free: "Six pushes break a grab before the bite",
+    determinism: "The same seed gives the same wounds"
+  },
+  yes: "yes",
+  no: "no"
+};
+var PT_BR2 = {
+  group: "Jogador",
+  name: "\xC1rea do jogador",
+  controls: {
+    infection: "Infec\xE7\xE3o individual",
+    agility: "Agilidade",
+    vigor: "Vigor",
+    seed: "Semente",
+    hurt: "Levar um golpe (10)",
+    bite: "Mordida",
+    grab: "Ser agarrado",
+    push: "Empurrar (E)",
+    knife: "Faca (F)",
+    bandage: "Curativo (B)",
+    knock: "Derrubado 1,5 s",
+    crouch: "Agachar (C)",
+    reset: "Recome\xE7ar"
+  },
+  hints: {
+    infection: "Desligada: mundo normal, ferida nunca infecta. Ligada: a regra do jogo (arranh\xE3o 6%, lacera\xE7\xE3o 22%, mordida 100%; febre aos 30 s, morte aos 120 s).",
+    agility: "A ficha: f\xF4lego, velocidade de corrida e ru\xEDdo dos passos saem dela.",
+    vigor: "A ficha: vida, f\xF4lego e compostura saem dela.",
+    seed: "A mesma semente d\xE1 as mesmas feridas e os mesmos golpes de faca.",
+    grab: "Algo te agarra por tr\xE1s: 3 s para empurrar (6 empurr\xF5es) ou acertar a faca (70%).",
+    push: "Empurra o que est\xE1 na frente, ou se solta do que te segura."
+  },
+  metrics: {
+    health: "Vida",
+    stamina: "F\xF4lego",
+    bleeding: "Sangrando",
+    wounds: "Feridas",
+    stage: "Infec\xE7\xE3o",
+    time_left: "Tempo restante",
+    panic: "P\xE2nico",
+    spread: "Dispers\xE3o x",
+    grab: "Agarr\xE3o",
+    noise: "\xDAltimo ru\xEDdo",
+    steps: "Passos",
+    message: "Mensagem"
+  },
+  stages: { none: "Nenhuma", malaise: "Mal-estar", fever: "Febre", delirium: "Del\xEDrio", dead: "Morto" },
+  scenarios: {
+    stamina: "Correr gasta f\xF4lego e descansar devolve",
+    bleed_bandage: "Uma lacera\xE7\xE3o sangra at\xE9 o curativo",
+    normal_world: "No mundo normal a mordida machuca e sangra, mas n\xE3o infecta",
+    infection_kills: "Com a infec\xE7\xE3o ligada, a mordida d\xE1 febre e mata no tempo dela",
+    grab_break_free: "Seis empurr\xF5es soltam o agarr\xE3o antes da mordida",
+    determinism: "A mesma semente d\xE1 as mesmas feridas"
+  },
+  yes: "sim",
+  no: "n\xE3o"
+};
+var playerBenchTextOf = (locale) => locale.toLowerCase().startsWith("en") ? EN2 : PT_BR2;
+
+// src/bench/module.ts
+var MOVING_SPEED = 0.2;
+var SPRINT_SPEED = 3.4;
+var FRAME = 1 / 30;
+var createGrabber = () => {
+  const agent = { x: 0, z: 0, on: false, stunned: 0, hits: 0 };
+  const crowd = {
+    count: () => agent.on ? 1 : 0,
+    active: () => agent.on,
+    x: () => agent.x,
+    z: () => agent.z,
+    y: () => 0,
+    floor: () => 0,
+    chasing: () => agent.on,
+    down: () => agent.stunned > 0,
+    hold(_i, x, z, k) {
+      agent.x += (x - agent.x) * k;
+      agent.z += (z - agent.z) * k;
+    },
+    stun(_i, seconds) {
+      agent.stunned = seconds;
+      agent.on = false;
+    },
+    chase() {
+      agent.on = false;
+    },
+    damage() {
+      agent.hits += 1;
+      agent.on = false;
+    }
+  };
+  return { agent, crowd };
+};
+function createPlayerTestModule(options = {}) {
+  const locale = options.locale ?? "pt-BR";
+  const text = playerBenchTextOf(locale);
+  const { locale: _locale, ...playerOptions } = options;
+  void _locale;
+  const settings = { infection: options.infection === void 0 ? false : options.infection !== false, agility: options.attributes?.agility ?? 5, vigor: options.attributes?.vigor ?? 5, seed: options.seed ?? 1 };
+  let host = null;
+  const grabber = createGrabber();
+  let lastNoise = 0;
+  let steps = 0;
+  let lastMessage = "";
+  let pending = {};
+  let bandage = false;
+  let last = null;
+  const offs = [];
+  const build = () => {
+    for (const off of offs.splice(0)) off();
+    const made = createPlayer({ ...playerOptions, seed: settings.seed, infection: settings.infection, attributes: { ...playerOptions.attributes, agility: settings.agility, vigor: settings.vigor } });
+    offs.push(made.on("noise", (e) => void (lastNoise = e.radius)));
+    offs.push(made.on("step", () => void (steps += 1)));
+    offs.push(made.on("message", (e) => void (lastMessage = playerTextOf(e.id, locale))));
+    offs.push(made.on("sound", (e) => void host?.audio?.play({ sound: e.sound, volume: e.volume, position: e.position })));
+    offs.push(made.on("died", (e) => host?.log(`player died: ${e.cause}`, { cause: e.cause })));
+    lastNoise = 0;
+    steps = 0;
+    lastMessage = "";
+    return made;
+  };
+  let player = build();
+  const view = () => {
+    const camera = host?.camera;
+    if (!camera?.position) return null;
+    const Vector3 = host?.THREE?.Vector3;
+    if (camera.getWorldDirection && Vector3) {
+      const look = camera.getWorldDirection(new Vector3());
+      return { x: camera.position.x, z: camera.position.z, yaw: Math.atan2(-look.x, -look.z) };
+    }
+    return { x: camera.position.x, z: camera.position.z, yaw: camera.rotation?.y ?? 0 };
+  };
+  const frame = (dt) => {
+    const here = view();
+    const speed = here && last && dt > 0 ? Math.hypot(here.x - last.x, here.z - last.z) / dt : 0;
+    if (here) {
+      player.state.x = here.x;
+      player.state.z = here.z;
+    }
+    const input = { forward: speed > MOVING_SPEED ? 1 : 0, run: speed > SPRINT_SPEED, yaw: here?.yaw ?? 0, bandage, pressed: pending };
+    pending = {};
+    bandage = false;
+    player.update(dt, input, { crowd: grabber.crowd });
+    if (here) {
+      player.state.x = here.x;
+      player.state.z = here.z;
+      last = { x: here.x, z: here.z };
+    }
+    if (grabber.agent.stunned > 0) grabber.agent.stunned = Math.max(0, grabber.agent.stunned - dt);
+  };
+  const grab = () => {
+    const P = player.state;
+    grabber.agent.on = true;
+    grabber.agent.x = P.x - Math.sin(P.yaw) * player.numbers.grabOffset;
+    grabber.agent.z = P.z - Math.cos(P.yaw) * player.numbers.grabOffset;
+    player.grab(0);
+  };
+  const onChange = (change) => {
+    if (change.kind === "action") {
+      const id2 = change.id;
+      if (id2 === "hurt") player.hurt(10);
+      else if (id2 === "bite") player.bite();
+      else if (id2 === "grab") grab();
+      else if (id2 === "knock") player.knock(1.5);
+      else if (id2 === "bandage") bandage = true;
+      else if (id2 === "push" || id2 === "knife" || id2 === "crouch") pending = { ...pending, [id2]: true };
+      else if (id2 === "reset") player = build();
+      return;
+    }
+    if (change.kind !== "control") return;
+    const { id, value } = change;
+    if (id === "infection" && typeof value === "boolean" && value !== settings.infection) settings.infection = value;
+    else if ((id === "agility" || id === "vigor" || id === "seed") && typeof value === "number" && value !== settings[id]) settings[id] = value;
+    else return;
+    player = build();
+  };
+  const controls = () => [
+    { kind: "boolean", id: "infection", name: text.controls.infection, hint: text.hints.infection, default: settings.infection },
+    { kind: "number", id: "agility", name: text.controls.agility, hint: text.hints.agility, min: 1, max: 8, step: 1, default: settings.agility },
+    { kind: "number", id: "vigor", name: text.controls.vigor, hint: text.hints.vigor, min: 1, max: 8, step: 1, default: settings.vigor },
+    { kind: "number", id: "seed", name: text.controls.seed, hint: text.hints.seed, min: 1, max: 9999, step: 1, default: settings.seed },
+    { kind: "action", id: "hurt", name: text.controls.hurt },
+    { kind: "action", id: "bite", name: text.controls.bite },
+    { kind: "action", id: "grab", name: text.controls.grab, hint: text.hints.grab },
+    { kind: "action", id: "push", name: text.controls.push, hint: text.hints.push },
+    { kind: "action", id: "knife", name: text.controls.knife },
+    { kind: "action", id: "bandage", name: text.controls.bandage },
+    { kind: "action", id: "knock", name: text.controls.knock },
+    { kind: "action", id: "crouch", name: text.controls.crouch },
+    { kind: "action", id: "reset", name: text.controls.reset }
+  ];
+  const stageName = () => player.state.alive ? text.stages[player.stage()] : text.stages.dead;
+  const metrics = () => [
+    { id: "health", name: text.metrics.health, digits: 1, max: player.derived.maxHealth, read: () => Math.max(0, player.state.health) },
+    { id: "stamina", name: text.metrics.stamina, digits: 1, max: player.derived.maxStamina, read: () => player.state.stamina },
+    { id: "bleeding", name: text.metrics.bleeding, read: () => player.state.bleeding ? text.yes : text.no },
+    { id: "wounds", name: text.metrics.wounds, digits: 0, read: () => player.state.wounds.length },
+    { id: "stage", name: text.metrics.stage, read: stageName },
+    { id: "time_left", name: text.metrics.time_left, unit: "s", digits: 0, read: () => player.timeLeft() ?? 0 },
+    { id: "panic", name: text.metrics.panic, digits: 1, read: () => player.state.panic },
+    { id: "spread", name: text.metrics.spread, digits: 2, read: () => player.spreadFactor() },
+    { id: "grab_timer", name: text.metrics.grab, unit: "s", digits: 1, read: () => player.state.grabbedBy >= 0 ? player.state.grabTimer : 0 },
+    { id: "noise", name: text.metrics.noise, unit: "m", digits: 1, read: () => lastNoise },
+    { id: "steps", name: text.metrics.steps, digits: 0, read: () => steps },
+    { id: "message", name: text.metrics.message, read: () => lastMessage }
+  ];
+  const fresh = (extra = {}) => createPlayer({ ...playerOptions, ...extra });
+  const run = (made, seconds, input = {}, crowd) => {
+    for (let t = 0; t < seconds; t += FRAME) made.update(FRAME, input, crowd ? { crowd } : void 0);
+  };
+  const scenarios = () => [
+    {
+      id: "player_stamina",
+      name: text.scenarios.stamina,
+      run: ({ expect }) => {
+        const made = fresh({ seed: 1 });
+        const full = made.state.stamina;
+        run(made, 4, { forward: 1, run: true });
+        const tired = made.state.stamina;
+        expect(tired < full - 40, "four seconds of running spend 48 of stamina", { full, tired });
+        run(made, 3);
+        expect(made.state.stamina > tired, "standing still gives it back", { tired, rested: made.state.stamina });
+      }
+    },
+    {
+      id: "player_bleed_bandage",
+      name: text.scenarios.bleed_bandage,
+      run: ({ expect }) => {
+        const made = fresh({ seed: 1 });
+        made.bite();
+        const after = made.state.health;
+        run(made, 2);
+        expect(made.state.bleeding === 1 && made.state.health < after, "the wound bleeds", { health: made.state.health });
+        run(made, FRAME, { bandage: true });
+        const dressed = made.state.health;
+        run(made, 2);
+        expect(made.state.bleeding === 0 && made.state.health === dressed, "dressed, it stops", { health: made.state.health });
+      }
+    },
+    {
+      id: "player_normal_world",
+      name: text.scenarios.normal_world,
+      run: ({ expect }) => {
+        const made = fresh({ seed: 1, infection: false });
+        made.bite();
+        run(made, 10);
+        expect(!made.state.infected && made.state.health < made.derived.maxHealth, "bitten, hurt, not infected", { health: made.state.health });
+      }
+    },
+    {
+      id: "player_infection_kills",
+      name: text.scenarios.infection_kills,
+      run: ({ expect }) => {
+        const made = fresh({ seed: 1, infection: true });
+        made.bite();
+        run(made, FRAME, { bandage: true });
+        run(made, 40);
+        expect(made.stage() === "fever", "fever after 30 s", { stage: made.stage() });
+        run(made, 90);
+        expect(!made.state.alive && made.state.cause === "infection", "dead at 120 s", { cause: made.state.cause });
+      }
+    },
+    {
+      id: "player_grab_break_free",
+      name: text.scenarios.grab_break_free,
+      run: ({ expect }) => {
+        const made = fresh({ seed: 1 });
+        const { agent, crowd } = createGrabber();
+        agent.on = true;
+        made.grab(0);
+        for (let push = 0; push < 6; push++) {
+          made.update(FRAME, { pressed: { push: true } }, { crowd });
+          made.update(FRAME, {}, { crowd });
+        }
+        expect(made.state.grabbedBy === -1 && made.state.wounds.length === 0, "free, and no bite", { grabbedBy: made.state.grabbedBy });
+      }
+    },
+    {
+      id: "player_determinism",
+      name: text.scenarios.determinism,
+      run: ({ expect }) => {
+        const wounds = (seed) => {
+          const made = fresh({ seed });
+          for (let k = 0; k < 12; k++) made.hurt(1);
+          return made.state.wounds.join(",");
+        };
+        expect(wounds(4) === wounds(4), "the same seed gives the same wounds");
+        expect(wounds(4) !== wounds(5), "another seed gives others");
+      }
+    }
+  ];
+  const module = {
+    id: "player_area",
+    name: text.name,
+    group: text.group,
+    get player() {
+      return player;
+    },
+    items: () => [],
+    controls: () => controls(),
+    metrics: () => metrics(),
+    scenarios: () => scenarios(),
+    attach(lent) {
+      host = lent;
+      last = null;
+      const off = lent.bench?.onChange(onChange);
+      const offFrame = lent.onFrame(frame);
+      return () => {
+        off?.();
+        offFrame();
+        host = null;
+      };
+    }
+  };
+  return module;
+}
+export {
+  PLAYER_DEFAULTS,
+  PLAYER_TEXT,
+  createPlayer,
+  createPlayerTestModule,
+  createRng,
+  deriveVitals,
+  drawWound,
+  playerTextOf
+};
+//# sourceMappingURL=index.js.map