@adatechnology/game-crowd-three 0.4.0 → 0.5.0

package/dist/index.global.js

@@ -333,45 +333,45 @@ var GameCrowdThree = (() => {
     segmentRadius: SEGMENT_RADIUS
   };
   var createCorpseLedger = (options) => {
-    const entries = [];
+    const entries2 = [];
     return {
-      entries,
+      entries: entries2,
       get count() {
-        return entries.length;
+        return entries2.length;
       },
       add(data) {
-        if (entries.length < options.max) {
-          entries.push({ age: 0, data });
+        if (entries2.length < options.max) {
+          entries2.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 };
+        for (let index = 1; index < entries2.length; index++) if (entries2[index].age > entries2[oldest].age) oldest = index;
+        const replaced = entries2[oldest].data;
+        entries2[oldest] = { age: 0, data };
         return replaced;
       },
       update(dt) {
         const removed = [];
-        for (let index = 0; index < entries.length; index++) {
-          const entry = entries[index];
+        for (let index = 0; index < entries2.length; index++) {
+          const entry = entries2[index];
           entry.age += dt;
           if (entry.age <= options.seconds) continue;
           removed.push(entry.data);
-          entries[index] = entries[entries.length - 1];
-          entries.pop();
+          entries2[index] = entries2[entries2.length - 1];
+          entries2.pop();
           index--;
         }
         return removed;
       },
       remove(index) {
-        const entry = entries[index];
+        const entry = entries2[index];
         if (!entry) return void 0;
-        entries[index] = entries[entries.length - 1];
-        entries.pop();
+        entries2[index] = entries2[entries2.length - 1];
+        entries2.pop();
         return entry.data;
       },
       clear() {
-        entries.length = 0;
+        entries2.length = 0;
       }
     };
   };
@@ -1511,7 +1511,7 @@ var GameCrowdThree = (() => {
   var POSE_CLIPS = pose_clips_default.clips;
   var POSE_CLIP_LOCALES = pose_clips_default.locales;
 
-  // ../game-audio/dist/chunk-DZITVFMJ.js
+  // ../game-audio/dist/chunk-7TLFY7VO.js
   var DISTANCE_CURVES = {
     /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
     game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
@@ -1574,15 +1574,31 @@ var GameCrowdThree = (() => {
     {
       id: "game",
       master: 0.5,
-      noise: { seconds: 1.5, create: "lazy" },
-      sources: ["jogo:L62077-62081 master 0.5 to the output", "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"]
+      noise: {
+        seconds: 1.5,
+        create: "lazy"
+      },
+      sources: [
+        "jogo:L62077-62081 master 0.5 to the output",
+        "jogo:L62082-62088 noise 1.5 s made by the first sound that needs it"
+      ]
     },
     {
       id: "art_scene",
       master: 0.85,
-      compressor: { threshold: -12, ratio: 5 },
-      reverb: { seconds: 2.2, decay: 3.4, wet: 0.4 },
-      noise: { seconds: 2, create: "eager" },
+      compressor: {
+        threshold: -12,
+        ratio: 5
+      },
+      reverb: {
+        seconds: 2.2,
+        decay: 3.4,
+        wet: 0.4
+      },
+      noise: {
+        seconds: 2,
+        create: "eager"
+      },
       sources: [
         "cena:L1308 compressor -12 dB, ratio 5",
         "cena:L1309 master 0.85",
@@ -1590,6 +1606,30 @@ var GameCrowdThree = (() => {
         "cena:L1311 wet 0.4",
         "cena:L1312 noise 2 s made with the chain"
       ]
+    },
+    {
+      id: "kit",
+      master: 0.85,
+      compressor: {
+        threshold: -12,
+        ratio: 5
+      },
+      reverb: {
+        seconds: 2.2,
+        decay: 3.4,
+        wet: 0.4
+      },
+      noise: {
+        seconds: 2,
+        create: "eager"
+      },
+      sources: [
+        "sdk: the art scene chain (cena L1308-L1312) with a limiter after the compressor: the page has none, and a blast with its debris and a fire catching reached +7 dBFS"
+      ],
+      limiter: {
+        ceiling: -1,
+        knee: -6
+      }
     }
   ];
   var MIX_PROFILES = Object.fromEntries(
@@ -1640,6 +1680,339 @@ var GameCrowdThree = (() => {
       }
     ]
   };
+  var entries = (category, list2) => list2.map(([id, priority, current]) => ({ id, category, priority, ...current ? { current } : {} }));
+  var SFX_CATALOG = [
+    ...entries("armas", [
+      ["pistol_22lr", 2, "sfx_pistol"],
+      ["pistol_9mm", 1, "sfx_pistol"],
+      ["pistol_45", 1, "sfx_pistol"],
+      ["revolver_38_357", 2, "sfx_pistol"],
+      ["revolver_44_50ae", 3, "sfx_pistol"],
+      ["smg_9mm_auto", 1, "sfx_pistol"],
+      ["shotgun_12", 1, "sfx_shotgun"],
+      ["rifle_5_56", 1, "sfx_rifle"],
+      ["rifle_7_62x39", 1, "sfx_rifle"],
+      ["rifle_auto_burst", 1, "sfx_rifle"],
+      ["rifle_308_3006", 2, "sfx_rifle"],
+      ["sniper_338_300wm", 2, "sfx_rifle"],
+      ["antimateriel_50bmg", 3, "sfx_rifle"],
+      ["suppressed_pistol", 2],
+      ["suppressed_rifle", 2],
+      ["gunshot_far_pistol", 1],
+      ["gunshot_far_rifle", 1],
+      ["gunshot_far_shotgun", 1],
+      ["gunshot_far_heavy", 2],
+      ["gunshot_tail_indoor", 1],
+      ["gunshot_tail_outdoor", 1],
+      ["bullet_crack_by", 2],
+      ["bullet_whiz", 2],
+      ["ricochet_metal", 2, "ping"],
+      ["dry_fire", 1],
+      ["mag_out", 1],
+      ["mag_in", 1],
+      ["slide_pull_release", 1],
+      ["pump_cycle", 1],
+      ["casing_drop_concreto_pistol", 1],
+      ["casing_drop_concreto_rifle", 1],
+      ["casing_drop_concreto_shell", 1],
+      ["casing_drop_madeira_pistol", 1],
+      ["casing_drop_madeira_rifle", 1],
+      ["casing_drop_madeira_shell", 1],
+      ["casing_drop_metal_pistol", 1],
+      ["casing_drop_metal_rifle", 1],
+      ["casing_drop_metal_shell", 1],
+      ["casing_drop_terra_pistol", 1],
+      ["casing_drop_terra_rifle", 1],
+      ["casing_drop_terra_shell", 1],
+      ["rocket_fire", 2]
+    ]),
+    ...entries("explosoes-fogo", [
+      ["explosion_grenade", 1, "boom"],
+      ["explosion_big", 1, "boom_big"],
+      ["explosion_car", 2, "boom_big"],
+      ["explosion_far", 1],
+      ["debris_rain_stone", 1],
+      ["molotov_break_ignite", 1, "glass_shatter"],
+      ["fire_ignite", 1, "hiss"],
+      ["fire_loop_small", 1],
+      ["fire_loop_large", 1],
+      ["fire_extinguish", 2, "hiss"],
+      ["gas_leak_hiss", 2],
+      ["structure_collapse", 2, "crumble"]
+    ]),
+    ...entries("personagem", [
+      ["footstep_concrete_walk", 1, "sfx_step"],
+      ["footstep_wood_walk", 1, "sfx_step"],
+      ["footstep_dirt_walk", 1, "sfx_step"],
+      ["footstep_grass_walk", 1, "sfx_step"],
+      ["footstep_gravel_walk", 1, "sfx_step"],
+      ["land_concrete", 1, "sfx_step"],
+      ["punch_swing", 1],
+      ["punch_hit_body", 1, "sfx_flesh"],
+      ["kick_hit", 1, "sfx_flesh"],
+      ["knife_stab", 1],
+      ["blunt_hit", 1],
+      ["bite", 1, "sfx_flesh"],
+      ["body_fall", 1],
+      ["player_hurt", 2]
+    ]),
+    ...entries("veiculos", [
+      ["engine_loop_car", 1],
+      ["engine_start", 1],
+      ["crash_light", 1, "crash"],
+      ["crash_heavy", 1, "crash"],
+      ["car_door_open", 1, "latch"],
+      ["car_door_close", 1, "shut_metal"],
+      ["horn_car", 2, "horn"],
+      ["tire_skid_asphalt", 2]
+    ]),
+    ...entries("itens-portas", [
+      ["item_pickup_metal", 1],
+      ["can_open", 1],
+      ["can_crush", 1],
+      ["door_wood_open", 1, "latch"],
+      ["door_wood_close", 1, "shut_wood"],
+      ["door_creak", 1, "creak_wood"],
+      ["door_locked_rattle", 1, "rattle"],
+      ["drawer_open", 2, "slide"],
+      ["fridge_close", 2, "shut_metal"]
+    ]),
+    ...entries("ambiente", [
+      ["rain_loop", 2],
+      ["wind_loop", 2],
+      ["thunder_near", 2],
+      ["thunder_far", 2],
+      ["water_splash", 2]
+    ])
+  ];
+  var SFX_MATERIALS = [
+    ["steel", "metal"],
+    ["aluminium", "metal"],
+    ["wood", "wood"],
+    ["plywood", "wood"],
+    ["mdf", "wood"],
+    ["glass", "glass"],
+    ["tempered_glass", "glass"],
+    ["ceramic", "glass"],
+    ["concrete", "masonry"],
+    ["brick", "masonry"],
+    ["plaster", "masonry"],
+    ["plastic", "soft"],
+    ["fabric", "soft"],
+    ["paper", "soft"],
+    ["foliage", "soft"],
+    ["soil", "soft"],
+    ["flesh", "soft"]
+  ];
+  var SFX_BLOWS = ["bullet", "blunt", "blade", "break", "drag"];
+  var CURRENT_BY_GROUP = {
+    metal: { bullet: "clang", blunt: "clang", blade: "clang", break: "clang", drag: "drag_metal" },
+    wood: { bullet: "wood_hit", blunt: "wood_hit", blade: "wood_hit", break: "crack", drag: "drag_wood" },
+    glass: { bullet: "ping", blunt: "ping", break: "glass_shatter", drag: "drag_glass" },
+    masonry: { bullet: "chip", blunt: "chip", blade: "chip", break: "crumble", drag: "drag_masonry" },
+    soft: { bullet: "thud", blunt: "thud", blade: "thud", break: "thud", drag: "drag_soft" }
+  };
+  var impactSoundId = (material, blow) => `impact_${material}_${blow}`;
+  var SFX_IMPACTS = SFX_MATERIALS.flatMap(
+    ([material, group]) => SFX_BLOWS.map((blow) => {
+      const current = CURRENT_BY_GROUP[group]?.[blow];
+      return { id: impactSoundId(material, blow), category: "impactos", priority: ["steel", "wood", "glass", "concrete", "brick", "soil", "flesh"].includes(material) && blow === "bullet" ? 1 : 2, ...current ? { current } : {} };
+    })
+  );
+  var CALIBRATION_ID = "calibration_shot";
+  var PREFIX = "calibration/";
+  var url = (name) => `${PREFIX}${name}`;
+  var CALIBRATION_SOUND = {
+    id: CALIBRATION_ID,
+    bus: "weapons",
+    close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })),
+    far: ["far_1.wav", "far_2.wav"].map((name) => ({ url: url(name) })),
+    tiers: [
+      { name: "light", from: 0, close: ["light_1.wav", "light_2.wav"].map((name) => ({ url: url(name) })) },
+      { name: "medium", from: 0.34, close: ["close_1.wav", "close_2.wav", "close_3.wav", "close_4.wav"].map((name) => ({ url: url(name) })) },
+      { name: "heavy", from: 0.67, close: ["heavy_1.wav", "heavy_2.wav"].map((name) => ({ url: url(name) })) }
+    ],
+    tail: { indoor: [{ url: url("tail_in.wav") }], outdoor: [{ url: url("tail_out.wav") }] },
+    pitch: 0.04,
+    choke: { voices: 2 },
+    fallback: "sfx_pistol",
+    sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+  };
+  var CALIBRATION_LOOP_ID = "calibration_loop";
+  var CALIBRATION_LOOP_SOUND = {
+    id: CALIBRATION_LOOP_ID,
+    bus: "ambience",
+    close: ["loop_1.wav", "loop_2.wav", "loop_3.wav"].map((name) => ({ url: url(name) })),
+    loop: { crossfade: 0.15 },
+    sources: ["sdk: calibration takes synthesized by the harness (measure/calibration.ts), no file, no licence"]
+  };
+  var CRITERIA_TARGETS = {
+    /** C1: event to the first sample, and onset to the peak (one 60 fps frame). */
+    syncMs: 20,
+    peakAfterOnsetMs: 1e3 / 60,
+    /** C3: distances measured, metres. */
+    distances: [1, 10, 50, 200],
+    /** C5: plays, distinct takes and the pitch range (fraction). */
+    plays: 10,
+    minTakes: 4,
+    pitch: [0.03, 0.05],
+    /** C6: the highest peak, dBFS. */
+    peakDb: -1,
+    /** C8: the end of each file against its peak, dB. */
+    endDropDb: -40,
+    /** C9: a burst of rapid fire. */
+    burst: 20,
+    burstSpacing: 0.06
+  };
+  var PT = {
+    group: "Som",
+    name: "Painel de som (arquivos e C1\u2013C10)",
+    controls: {
+      category: "1 \xB7 Categoria",
+      sound: "1 \xB7 Som",
+      play: "1 \xB7 \u25B6 Tocar",
+      material: "2 \xB7 Material",
+      blow: "2 \xB7 Golpe",
+      strike: "2 \xB7 \u25B6 Tocar golpe",
+      distance: "3 \xB7 Dist\xE2ncia",
+      bearing: "3 \xB7 Dire\xE7\xE3o",
+      environment: "3 \xB7 Lugar",
+      strength: "3 \xB7 For\xE7a",
+      wall: "3 \xB7 Atr\xE1s da parede",
+      burst: "3 \xB7 Rajada 20\xD7",
+      play_a: "4 \xB7 \u25B6 A (atual)",
+      play_b: "4 \xB7 \u25B6 B (novo)",
+      ab_cycle: "4 \xB7 Alternar A/B",
+      blind: "4 \xB7 \xC0s cegas (X)",
+      reveal: "4 \xB7 Revelar X",
+      prefer_a: "4 \xB7 Prefiro A",
+      prefer_b: "4 \xB7 Prefiro B",
+      measure: "5 \xB7 Medir C1\u2013C10",
+      record: "5 \xB7 Gravar 3 s",
+      approve: "5 \xB7 Aprovo (C10)"
+    },
+    hints: {
+      sound: "A = arquivo, S = sintetizado, F = faltando. O que tem arquivo toca o arquivo; o resto toca o som atual.",
+      strike: "Toca impact_<material>_<golpe>: o arquivo se existir, sen\xE3o o som atual daquele material.",
+      wall: "P\xF5e a parede de casa entre voc\xEA e a fonte: o som fica abafado (C4).",
+      burst: "Vinte vezes a cada 60 ms, como uma rajada (C9).",
+      ab_cycle: "A, B, A, B, um por segundo.",
+      blind: "Toca A ou B sem dizer qual; depois revele.",
+      measure: "Mede o som escolhido no motor real (contexto offline): sincronia, som certo, dist\xE2ncia, lado, varia\xE7\xE3o, volume, for\xE7a, cauda e rajada.",
+      record: "Grava 3 s da sa\xEDda com o som tocando e baixa o arquivo (C10).",
+      approve: "Marca o C10 do som escolhido como aprovado pelo seu ouvido."
+    },
+    categories: {
+      armas: "Armas",
+      impactos: "Impactos",
+      "explosoes-fogo": "Explos\xF5es e fogo",
+      personagem: "Personagem",
+      veiculos: "Ve\xEDculos",
+      "itens-portas": "Itens e portas",
+      ambiente: "Ambiente",
+      calibracao: "Calibra\xE7\xE3o (SDK)"
+    },
+    blows: { bullet: "tiro", blunt: "soco/chute", blade: "faca", break: "quebra", drag: "arrasto/queda" },
+    materials: {
+      steel: "a\xE7o",
+      aluminium: "alum\xEDnio",
+      wood: "madeira",
+      plywood: "compensado",
+      mdf: "MDF",
+      glass: "vidro",
+      tempered_glass: "vidro temperado",
+      ceramic: "cer\xE2mica",
+      concrete: "concreto",
+      brick: "tijolo",
+      plaster: "gesso",
+      plastic: "pl\xE1stico",
+      fabric: "tecido",
+      paper: "papel\xE3o",
+      foliage: "folhagem",
+      soil: "terra",
+      flesh: "carne"
+    },
+    environments: { indoor: "interior", outdoor: "exterior" },
+    strengths: { light: "leve", medium: "m\xE9dio", heavy: "forte" },
+    states: { file: "A", synth: "S", missing: "F" },
+    criteria: { C1: "C1 Sincronia", C2: "C2 Certo p/ a\xE7\xE3o", C3: "C3 Dist\xE2ncia", C4: "C4 Posi\xE7\xE3o", C5: "C5 Varia\xE7\xE3o", C6: "C6 Volume", C7: "C7 Intensidade", C8: "C8 Cauda", C9: "C9 Rajada", C10: "C10 Escuta" },
+    metrics: { chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
+    run: { idle: "parada", measuring: "medindo\u2026", done: "pronta", failed: "falhou", recording: "gravando\u2026", recorded: "grava\xE7\xE3o baixada" },
+    words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono" },
+    probe: "Fonte do som",
+    wall: "Parede (oclus\xE3o)",
+    scenarios: { pipeline: "Arquivo \u2192 decodifica \u2192 toca (round-robin, cauda)", criteria: "Crit\xE9rios C1\u2013C9 no som de calibra\xE7\xE3o", loop: "Loop de arquivo: emenda sem buraco (crossfade)", panel: "Painel: categorias, matriz, A/B e parede" }
+  };
+  var EN2 = {
+    ...PT,
+    group: "Sound",
+    name: "Sound panel (files and C1\u2013C10)",
+    controls: {
+      category: "1 \xB7 Category",
+      sound: "1 \xB7 Sound",
+      play: "1 \xB7 \u25B6 Play",
+      material: "2 \xB7 Material",
+      blow: "2 \xB7 Blow",
+      strike: "2 \xB7 \u25B6 Play blow",
+      distance: "3 \xB7 Distance",
+      bearing: "3 \xB7 Bearing",
+      environment: "3 \xB7 Place",
+      strength: "3 \xB7 Strength",
+      wall: "3 \xB7 Behind the wall",
+      burst: "3 \xB7 Burst 20\xD7",
+      play_a: "4 \xB7 \u25B6 A (current)",
+      play_b: "4 \xB7 \u25B6 B (new)",
+      ab_cycle: "4 \xB7 Alternate A/B",
+      blind: "4 \xB7 Blind (X)",
+      reveal: "4 \xB7 Reveal X",
+      prefer_a: "4 \xB7 Prefer A",
+      prefer_b: "4 \xB7 Prefer B",
+      measure: "5 \xB7 Measure C1\u2013C10",
+      record: "5 \xB7 Record 3 s",
+      approve: "5 \xB7 Approve (C10)"
+    },
+    hints: {
+      sound: "A = file, S = synthesized, F = missing. A file plays the file; the rest plays the current sound.",
+      strike: "Plays impact_<material>_<blow>: the file if there is one, else the current sound of that material.",
+      wall: "Puts the house wall between you and the source: the sound is muffled (C4).",
+      burst: "Twenty times every 60 ms, like a burst (C9).",
+      ab_cycle: "A, B, A, B, one a second.",
+      blind: "Plays A or B without saying which; reveal it after.",
+      measure: "Measures the chosen sound through the real engine (offline context): sync, right sound, distance, side, variation, level, strength, tail and burst.",
+      record: "Records 3 s of the output with the sound playing and downloads it (C10).",
+      approve: "Marks C10 of the chosen sound as approved by your ear."
+    },
+    categories: { armas: "Weapons", impactos: "Impacts", "explosoes-fogo": "Explosions and fire", personagem: "Character", veiculos: "Vehicles", "itens-portas": "Items and doors", ambiente: "Ambience", calibracao: "Calibration (SDK)" },
+    blows: { bullet: "bullet", blunt: "punch/kick", blade: "knife", break: "break", drag: "drag/fall" },
+    materials: {
+      steel: "steel",
+      aluminium: "aluminium",
+      wood: "wood",
+      plywood: "plywood",
+      mdf: "MDF",
+      glass: "glass",
+      tempered_glass: "tempered glass",
+      ceramic: "ceramic",
+      concrete: "concrete",
+      brick: "brick",
+      plaster: "plaster",
+      plastic: "plastic",
+      fabric: "fabric",
+      paper: "cardboard",
+      foliage: "foliage",
+      soil: "soil",
+      flesh: "flesh"
+    },
+    environments: { indoor: "indoor", outdoor: "outdoor" },
+    strengths: { light: "light", medium: "medium", heavy: "heavy" },
+    criteria: { C1: "C1 Sync", C2: "C2 Right sound", C3: "C3 Distance", C4: "C4 Position", C5: "C5 Variation", C6: "C6 Level", C7: "C7 Strength", C8: "C8 Tail", C9: "C9 Burst", C10: "C10 Listening" },
+    metrics: { chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
+    run: { idle: "idle", measuring: "measuring\u2026", done: "done", failed: "failed", recording: "recording\u2026", recorded: "recording downloaded" },
+    words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner" },
+    probe: "Sound source",
+    wall: "Wall (occlusion)",
+    scenarios: { pipeline: "File \u2192 decode \u2192 play (round-robin, tail)", criteria: "Criteria C1\u2013C9 on the calibration sound", loop: "File loop: seamless joins (crossfade)", panel: "Panel: categories, matrix, A/B and wall" }
+  };
 
   // ../game-audio/dist/index.js
   var ATTACK = 2e-3;
@@ -1704,6 +2077,7 @@ var GameCrowdThree = (() => {
       ]
     };
   }
+  var sceneMany = (count, make2) => Array.from({ length: count }, make2);
   function sceneRecipe(id, layers, line, options = {}) {
     return {
       id,
@@ -1716,6 +2090,569 @@ var GameCrowdThree = (() => {
       sources: [`cena:${line}`]
     };
   }
+  var FOLEY_FALLOFF = {
+    model: "inverse_square",
+    k: 0.02,
+    cutoffK: 0.04,
+    minGain: 4e-3
+  };
+  var vary = (f, pct = 0.04) => [Math.round(f * (1 - pct)), Math.round(f * (1 + pct))];
+  var foley = (id, layers, note) => ({
+    id,
+    bus: "world",
+    pan: true,
+    layers,
+    falloff: FOLEY_FALLOFF,
+    sources: [`sdk: ${note}`]
+  });
+  var click = (f, vol, delay = 0) => [
+    sceneNoise({
+      type: "bandpass",
+      f: vary(f, 0.08),
+      q: 4,
+      d: [0.018, 0.03],
+      vol: [vol * 0.85, vol * 1.1],
+      delay
+    }),
+    sceneTone({
+      f: vary(f * 0.8, 0.06),
+      f2: Math.round(f * 0.62),
+      d: [0.015, 0.025],
+      vol: vol * 0.18,
+      delay
+    })
+  ];
+  var meet = (body, panel, vol, latch) => [
+    sceneTone({
+      f: vary(body),
+      f2: Math.round(body * 0.5),
+      d: [0.12, 0.16],
+      vol: [vol * 0.9, vol * 1.1]
+    }),
+    sceneNoise({
+      type: "bandpass",
+      f: vary(panel, 0.06),
+      q: 1.2,
+      d: [0.08, 0.12],
+      vol: [vol * 0.9, vol * 1.1],
+      wet: 0.25
+    }),
+    ...click(latch, vol * 0.45, [0.012, 0.028])
+  ];
+  var LEAF_FOLEY = [
+    // a wooden house door or wardrobe door: latch, a short creak, the leaf on the frame (the hard slam adds the frame rattling)
+    foley("door_wood_open", click(2400, 0.4), "the latch of a wooden door giving"),
+    foley(
+      "door_creak",
+      [
+        sceneTone({ f: [190, 240], f2: 310, d: [0.4, 0.55], vol: [0.04, 0.06] }),
+        sceneNoise({
+          type: "bandpass",
+          f: [480, 560],
+          q: 6,
+          a: 0.05,
+          d: [0.35, 0.5],
+          vol: [0.1, 0.14]
+        })
+      ],
+      "a wooden hinge turning"
+    ),
+    foley("door_wood_close", meet(120, 600, 0.55, 2400), "a wooden leaf meeting its frame"),
+    foley(
+      "door_wood_slam",
+      [
+        ...meet(110, 560, 0.85, 2300),
+        ...sceneMany(
+          3,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [900, 1500],
+            q: 3,
+            d: 0.03,
+            vol: [0.08, 0.14],
+            delay: [0.05, 0.18]
+          })
+        )
+      ],
+      "a wooden door slammed: the frame and the hinges rattle after the hit"
+    ),
+    // a metal door or gate: a hollow panel that rings a little
+    foley("door_metal_open_close", [...meet(160, 900, 0.55, 2e3), sceneTone({ f: vary(1250), f2: 1150, d: [0.1, 0.16], vol: 0.06, wet: 0.3 })], "a metal door or gate meeting its frame"),
+    foley(
+      "door_creak_metal",
+      [
+        sceneTone({ f: [620, 760], f2: 900, d: [0.3, 0.4], vol: [0.03, 0.045] }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1300, 1500],
+          q: 8,
+          a: 0.04,
+          d: [0.25, 0.35],
+          vol: [0.07, 0.09]
+        })
+      ],
+      "a metal hinge turning"
+    ),
+    // the handle of a locked door shaken: the latch knocking in its keeper, five to seven times in half a second
+    foley(
+      "door_locked_rattle",
+      [
+        ...sceneMany(
+          6,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [1600, 2600],
+            q: 3,
+            d: [0.025, 0.04],
+            vol: [0.22, 0.34],
+            delay: [0, 0.45]
+          })
+        ),
+        ...sceneMany(
+          3,
+          () => sceneTone({
+            f: [170, 210],
+            f2: 120,
+            d: 0.05,
+            vol: [0.12, 0.18],
+            delay: [0.02, 0.4]
+          })
+        )
+      ],
+      "the handle of a locked door shaken: latch knocks and the leaf thumping in its frame"
+    ),
+    // a fridge: the rubber seal lets go with a soft suck, the bottles in the door clink; closing it is a soft thump and the seal pulling shut
+    foley(
+      "fridge_open",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [320, 380],
+          a: 0.03,
+          d: [0.14, 0.2],
+          vol: [0.32, 0.4]
+        }),
+        sceneNoise({
+          type: "bandpass",
+          f: [800, 950],
+          f2: 1400,
+          q: 2,
+          a: 0.02,
+          d: 0.12,
+          vol: [0.08, 0.12]
+        }),
+        ...sceneMany(
+          2,
+          () => sceneTone({
+            f: [2600, 4200],
+            d: [0.04, 0.08],
+            vol: [0.015, 0.03],
+            delay: [0.08, 0.22]
+          })
+        )
+      ],
+      "a fridge door: the seal letting go and the bottles in the door"
+    ),
+    foley(
+      "fridge_close",
+      [
+        sceneTone({ f: vary(85), f2: 45, d: [0.1, 0.13], vol: [0.38, 0.46] }),
+        sceneNoise({
+          type: "lowpass",
+          f: [520, 620],
+          d: [0.08, 0.12],
+          vol: [0.3, 0.36]
+        }),
+        sceneNoise({
+          type: "lowpass",
+          f: [260, 320],
+          a: 0.02,
+          d: 0.1,
+          vol: [0.12, 0.18],
+          delay: [0.04, 0.07]
+        }),
+        ...sceneMany(
+          2,
+          () => sceneTone({
+            f: [2600, 4200],
+            d: [0.04, 0.07],
+            vol: [0.015, 0.03],
+            delay: [0.03, 0.12]
+          })
+        )
+      ],
+      "a fridge door shut: a soft thump, the seal pulling and the bottles"
+    ),
+    // a microwave: the spring catch of the door, plastic on plastic
+    foley(
+      "microwave_open",
+      [
+        ...click(1800, 0.34),
+        sceneTone({
+          f: [3e3, 3400],
+          f2: 2800,
+          d: 0.05,
+          vol: 0.025,
+          delay: [0.01, 0.02]
+        })
+      ],
+      "the spring catch of a microwave door"
+    ),
+    foley(
+      "microwave_close",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1200, 1450],
+          q: 2.5,
+          d: [0.04, 0.06],
+          vol: [0.36, 0.44]
+        }),
+        sceneTone({ f: vary(180), f2: 120, d: 0.05, vol: [0.16, 0.22] }),
+        ...click(2200, 0.2, [8e-3, 0.016])
+      ],
+      "a microwave door clacking shut"
+    ),
+    foley("microwave_beep", [sceneTone({ wave: "square", f: 2e3, d: 0.12, vol: 0.05 })], "the beep of a microwave"),
+    // drawers and sliding leaves: the runners, then the stop
+    foley(
+      "drawer_open",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [620, 780],
+          q: 2,
+          a: 0.04,
+          d: [0.28, 0.36],
+          vol: [0.18, 0.24]
+        }),
+        sceneNoise({ type: "bandpass", f: [2e3, 2400], q: 5, d: 0.28, vol: 0.04 }),
+        ...click(1400, 0.16, [0.28, 0.34])
+      ],
+      "a drawer on its runners and its stop"
+    ),
+    foley(
+      "drawer_close",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [620, 780],
+          q: 2,
+          a: 0.03,
+          d: [0.2, 0.28],
+          vol: [0.18, 0.24]
+        }),
+        sceneTone({
+          f: vary(150),
+          f2: 90,
+          d: 0.08,
+          vol: [0.22, 0.3],
+          delay: [0.2, 0.26]
+        })
+      ],
+      "a drawer pushed home"
+    )
+  ];
+  var ITEM_FOLEY = [
+    // the hand closing on the item: a touch of skin and cloth, then the item's own small sound
+    foley(
+      "item_pickup_metal",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneTone({
+          f: [1900, 2600],
+          f2: 1700,
+          d: [0.05, 0.08],
+          vol: [0.06, 0.09],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a metal thing"
+    ),
+    foley(
+      "item_pickup_plastic",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1500, 1900],
+          q: 3,
+          d: 0.03,
+          vol: [0.15, 0.21],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a plastic thing"
+    ),
+    foley(
+      "item_pickup_glass",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.15 }),
+        sceneTone({
+          f: [3200, 4200],
+          d: [0.05, 0.08],
+          vol: [0.038, 0.06],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a glass thing"
+    ),
+    foley(
+      "item_pickup_paper",
+      [
+        sceneNoise({
+          type: "highpass",
+          f: [2600, 3400],
+          a: 0.01,
+          d: [0.1, 0.14],
+          vol: [0.12, 0.18]
+        }),
+        sceneNoise({ type: "bandpass", f: [800, 1e3], q: 1, d: 0.05, vol: 0.12 })
+      ],
+      "picking up paper or cardboard"
+    ),
+    foley(
+      "item_pickup_fabric",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [900, 1300],
+          q: 0.8,
+          a: 0.02,
+          d: [0.12, 0.16],
+          vol: [0.15, 0.21]
+        })
+      ],
+      "picking up cloth"
+    ),
+    foley(
+      "item_pickup_wood",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "bandpass",
+          f: [900, 1100],
+          q: 2,
+          d: 0.04,
+          vol: [0.15, 0.21],
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up a wooden thing"
+    ),
+    foley(
+      "item_pickup_food",
+      [
+        sceneNoise({ type: "bandpass", f: [700, 900], q: 1, d: 0.06, vol: 0.18 }),
+        sceneNoise({
+          type: "lowpass",
+          f: [500, 650],
+          d: 0.05,
+          vol: 0.12,
+          delay: [0.01, 0.03]
+        })
+      ],
+      "picking up food"
+    ),
+    foley(
+      "item_throw",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [450, 650],
+          f2: 1400,
+          q: 1.5,
+          a: 0.05,
+          d: 0.18,
+          vol: [0.1, 0.14]
+        })
+      ],
+      "the arm throwing something: air"
+    ),
+    // a can: the tab cracks, the gas hisses out; drinking is gulps; crushing it crumples the sheet
+    foley(
+      "can_open",
+      [
+        ...click(3200, 0.36),
+        sceneNoise({
+          type: "highpass",
+          f: [3600, 4400],
+          a: 5e-3,
+          d: [0.22, 0.3],
+          vol: [0.16, 0.22],
+          delay: [0.012, 0.02]
+        }),
+        ...sceneMany(5, () => sceneTone({ f: [4e3, 7e3], d: 0.02, vol: 0.01, delay: [0.05, 0.4] }))
+      ],
+      "the tab of a can and the gas hissing out"
+    ),
+    foley(
+      "can_crush",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1600, 2200],
+          q: 1.2,
+          d: [0.18, 0.25],
+          vol: [0.3, 0.38]
+        }),
+        ...sceneMany(
+          6,
+          () => sceneTone({
+            f: [1200, 3400],
+            f2: 900,
+            d: 0.03,
+            vol: [0.03, 0.06],
+            delay: [0, 0.2]
+          })
+        )
+      ],
+      "a can crushed in the hand"
+    ),
+    foley(
+      "can_puncture_spray",
+      [
+        sceneNoise({
+          type: "highpass",
+          f: [2400, 3e3],
+          a: 5e-3,
+          d: [0.5, 0.7],
+          vol: [0.2, 0.26]
+        }),
+        sceneNoise({ type: "bandpass", f: [600, 800], q: 2, d: 0.4, vol: 0.06 })
+      ],
+      "a can holed: the jet hissing out"
+    ),
+    foley(
+      "bottle_open",
+      [
+        ...sceneMany(
+          5,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [2200, 3e3],
+            q: 4,
+            d: 8e-3,
+            vol: [0.1, 0.16],
+            delay: [0, 0.18]
+          })
+        ),
+        sceneNoise({
+          type: "highpass",
+          f: 3800,
+          a: 5e-3,
+          d: 0.12,
+          vol: [0.06, 0.1],
+          delay: [0.18, 0.22]
+        })
+      ],
+      "the screw cap of a bottle turning off"
+    ),
+    foley(
+      "drink_gulp",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [280, 360],
+          a: 0.02,
+          d: [0.1, 0.14],
+          vol: [0.24, 0.3]
+        }),
+        sceneTone({ f: [140, 170], f2: 85, d: [0.08, 0.11], vol: [0.12, 0.16] })
+      ],
+      "a gulp"
+    ),
+    foley(
+      "eat_crunch",
+      [
+        ...sceneMany(
+          4,
+          () => sceneNoise({
+            type: "bandpass",
+            f: [1800, 3200],
+            q: 1.5,
+            d: [0.02, 0.04],
+            vol: [0.12, 0.2],
+            delay: [0, 0.12]
+          })
+        )
+      ],
+      "a bite of something crunchy"
+    ),
+    foley(
+      "eat_chew",
+      [
+        sceneNoise({
+          type: "lowpass",
+          f: [450, 600],
+          a: 0.03,
+          d: [0.1, 0.14],
+          vol: [0.12, 0.16]
+        }),
+        sceneNoise({
+          type: "bandpass",
+          f: [1100, 1400],
+          q: 2,
+          d: 0.04,
+          vol: 0.04,
+          delay: [0.03, 0.06]
+        })
+      ],
+      "chewing"
+    ),
+    foley(
+      "bandage_wrap",
+      [
+        sceneNoise({
+          type: "bandpass",
+          f: [1400, 1800],
+          f2: 2400,
+          q: 1,
+          a: 0.04,
+          d: [0.3, 0.4],
+          vol: [0.12, 0.16]
+        })
+      ],
+      "a bandage unrolled round a limb"
+    ),
+    foley(
+      "pills_shake",
+      [
+        ...sceneMany(
+          8,
+          () => sceneTone({
+            f: [2400, 3600],
+            d: 0.015,
+            vol: [0.03, 0.05],
+            delay: [0, 0.25]
+          })
+        ),
+        sceneNoise({ type: "bandpass", f: [1500, 1900], q: 2, d: 0.25, vol: 0.05 })
+      ],
+      "pills shaken in their bottle"
+    ),
+    foley(
+      "medkit_use",
+      [
+        ...click(1700, 0.24),
+        sceneNoise({
+          type: "bandpass",
+          f: [1e3, 1400],
+          q: 1,
+          a: 0.03,
+          d: [0.25, 0.32],
+          vol: [0.08, 0.12],
+          delay: [0.05, 0.08]
+        })
+      ],
+      "a first aid kit opened and rummaged"
+    ),
+    foley("flashlight_click", click(2600, 0.3), "the switch of a flashlight")
+  ];
+  var FOLEY_BANK = {
+    id: "foley",
+    sounds: [...LEAF_FOLEY, ...ITEM_FOLEY]
+  };
   var TAKES = [
     { f: 1, t: 1, v: 1 },
     { f: 1.08, t: 0.9, v: 0.92 },
@@ -1883,7 +2820,7 @@ var GameCrowdThree = (() => {
   };
   var BODY_FOLEY_SET_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
 
-  // ../game-shapes/dist/chunk-IFXQIDSA.js
+  // ../game-shapes/dist/chunk-M5N2SHNL.js
   function canonicalJson(value) {
     if (value === null) return "null";
     if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
@@ -3130,8 +4067,8 @@ var GameCrowdThree = (() => {
       groups: []
     };
   }
-  function make(kind, p2) {
-    switch (kind) {
+  function make(p2) {
+    switch (p2.kind) {
       case "box": {
         const size = p2.size ?? [1, 1, 1];
         const segments = p2.segments ?? [1, 1, 1];
@@ -3160,7 +4097,7 @@ var GameCrowdThree = (() => {
       case "mesh":
         return mesh(p2);
       default:
-        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+        throw new Error(`game-shapes: unknown primitive kind "${String(p2.kind)}"`);
     }
   }
   var templates = /* @__PURE__ */ new Map();
@@ -3168,7 +4105,7 @@ var GameCrowdThree = (() => {
   var stats = { hits: 0, misses: 0 };
   function buildPrimitive(node, options = {}) {
     const parameters = primitiveParameters(node, options);
-    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    if (node.kind === "mesh" || templateLimit === 0) return make({ ...node, ...parameters });
     const key = `${node.kind}:${canonicalJson(parameters)}`;
     const cached = templates.get(key);
     if (cached) {
@@ -3178,7 +4115,7 @@ var GameCrowdThree = (() => {
       return cached;
     }
     stats.misses++;
-    const built2 = make(node.kind, parameters);
+    const built2 = make({ ...node, ...parameters });
     templates.set(key, built2);
     if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
     return built2;
@@ -3484,7 +4421,7 @@ var GameCrowdThree = (() => {
     return releaseObject3D(list2, { keep });
   }
 
-  // ../game-characters-three/dist/chunk-3CHBEUHW.js
+  // ../game-characters-three/dist/chunk-XSMP7T6O.js
   var UNDEAD_VOICE_GROUP = "undead_voice";
   var voiced = { bus: "voices", group: UNDEAD_VOICE_GROUP };
   var p = (param) => ({ param });
@@ -3702,12 +4639,12 @@ var GameCrowdThree = (() => {
         const o = add(Hd, cap(0.205, PI / 2), c, 0, 1.835, -5e-3);
         o.scale.set(1, 0.98, 1.08);
         add(Hd, new THREE.CylinderGeometry(0.208, 0.212, 0.04, 20), c, 0, 1.84, -5e-3);
-        if (sp.hat.tape) add(Hd, new THREE.CylinderGeometry(0.205, 0.207, 0.035, 20), cmat(sp.hat.tape), 0, 1.9, -5e-3);
-        if (sp.hat.photo) {
+        if (sp.hat?.tape) add(Hd, new THREE.CylinderGeometry(0.205, 0.207, 0.035, 20), cmat(sp.hat.tape), 0, 1.9, -5e-3);
+        if (sp.hat?.photo) {
           add(Hd, Bx(0.07, 0.08, 0.012), cmat(16052448), 0.13, 1.9, 0.14, 0, 0.75, 0);
           add(Hd, Bx(0.05, 0.055, 0.014), cmat(9071184), 0.13, 1.9, 0.141, 0, 0.75, 0);
         }
-        if (sp.hat.nvg) {
+        if (sp.hat?.nvg) {
           add(Hd, Bx(0.07, 0.05, 0.06), cmat(1710618), 0, 2, 0.175);
           for (const s of [-1, 1]) add(Hd, new THREE.CylinderGeometry(0.024, 0.024, 0.09, 10).rotateX(PI / 2), cmat(2767402), s * 0.032, 1.965, 0.235);
         }
@@ -5902,6 +6839,7 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
     return { requestFall, stagger, shove, step, flush, landed, pending: () => requests.length };
   }
   var CENTRE_HEIGHT = 1;
+  var SHELTERED = 0.5;
   var DISMEMBER_SHARE = 0.5;
   var LIMB_CHANCE = 0.5;
   var STUN_BASE = 0.45;
@@ -5940,22 +6878,23 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
       emitBlood(tally, i);
       ctx.deferKill(i);
     };
-    const hurt = (i, blast, distance2, index) => {
-      const falloff = (1 - distance2 / blast.radius) ** 2;
+    const hurt = (i, blast, distance2, index, reach = 1) => {
+      const falloff = (1 - distance2 / blast.radius) ** 2 * reach;
       const amount = blast.energy / 1e3 * options.pointsPerKilojoule * falloff;
       const draw = (salt) => () => unit(store.identity[i], ctx.step, salt);
       if (ctx.damage(i, { region: 1, amount, distance: distance2, cut: falloff }, draw(SALT.JAW + index)).died) return true;
       const region = Math.floor(unit(store.identity[i], ctx.step, SALT.REGION + index) * 6);
       return ctx.damage(i, { region, amount: amount / 2, distance: distance2, cut: falloff }, draw(SALT.JAW + 8 + index)).died;
     };
-    const shoveOf = (i, blasts) => {
+    const shoveOf = (i, blasts, reaches) => {
       const position = [store.x[i], store.y[i] + CENTRE_HEIGHT * store.height[i], store.z[i]];
       let vx = 0;
       let vy = 0;
       let vz = 0;
       let falloff = 0;
-      for (const blast of blasts) {
-        const shove = blastShove({ point: blast.point, energy: blast.energy, radius: blast.radius }, { position, mass: store.mass[i] }, options.shove);
+      for (let b = 0; b < blasts.length; b++) {
+        const blast = blasts[b];
+        const shove = blastShove({ point: blast.point, energy: blast.energy, radius: blast.radius, reach: reaches?.[b] ?? 1 }, { position, mass: store.mass[i] }, options.shove);
         if (!shove) continue;
         vx += shove.speed * shove.direction[0];
         vy += shove.speed * shove.direction[1];
@@ -5990,16 +6929,19 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
     };
     const affect = (i, blasts, tallies, candidates) => {
       let dead = store.hp[i] <= 0;
+      const reaches = blasts.map(
+        (blast) => blast.reach && distanceTo(i, blast) <= blast.radius ? blast.reach([store.x[i], store.y[i] + CENTRE_HEIGHT * store.height[i], store.z[i]]) : 1
+      );
       for (let b = 0; b < blasts.length && !dead; b++) {
         const blast = blasts[b];
         const distance2 = distanceTo(i, blast);
         if (distance2 > blast.radius) continue;
         tallies[b].reached++;
-        if (blast.lethalRadius !== void 0 && distance2 < blast.lethalRadius) kill(i, blast, distance2, tallies[b]);
-        else if (hurt(i, blast, distance2, b)) tallies[b].killed++;
+        if (blast.lethalRadius !== void 0 && distance2 < blast.lethalRadius && reaches[b] >= SHELTERED) kill(i, blast, distance2, tallies[b]);
+        else if (hurt(i, blast, distance2, b, reaches[b])) tallies[b].killed++;
         dead = store.hp[i] <= 0 || dead;
       }
-      const shove = shoveOf(i, blasts);
+      const shove = shoveOf(i, blasts, reaches);
       if (shove) applyShove(i, shove, candidates, tallies, blasts);
     };
     const resolve = () => {
@@ -6344,7 +7286,7 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
     const touched = new Int32Array((store.capacity + extraBodies) * CELLS_PER_BODY * 2);
     let touchedCount = 0;
     const entryCapacity = (store.capacity + extraBodies) * CELLS_PER_BODY;
-    const entries = { count: 0, cell: new Int32Array(entryCapacity), thickness: new Uint16Array(entryCapacity), identity: new Uint32Array(entryCapacity), agent: new Int32Array(entryCapacity) };
+    const entries2 = { count: 0, cell: new Int32Array(entryCapacity), thickness: new Uint16Array(entryCapacity), identity: new Uint32Array(entryCapacity), agent: new Int32Array(entryCapacity) };
     const standMass = new Float32Array(cellCount);
     const standTouched = new Int32Array(store.capacity);
     let standTouchedCount = 0;
@@ -6364,17 +7306,17 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
         if (cell < 0) continue;
         if (height[cell] === 0) touched[touchedCount++] = cell;
         height[cell] += millimetres;
-        const index = entries.count++;
-        entries.cell[index] = cell;
-        entries.thickness[index] = millimetres;
-        entries.identity[index] = identity2;
-        entries.agent[index] = agent;
+        const index = entries2.count++;
+        entries2.cell[index] = cell;
+        entries2.thickness[index] = millimetres;
+        entries2.identity[index] = identity2;
+        entries2.agent[index] = agent;
       }
     };
     const sumBodies = () => {
       for (let k = 0; k < touchedCount; k++) height[touched[k]] = 0;
       touchedCount = 0;
-      entries.count = 0;
+      entries2.count = 0;
       for (let i = 0; i < store.n; i++) {
         const state = store.balance[i];
         if (store.band[i] !== 0 || state !== BALANCE.FALLEN && state !== BALANCE.GETTING_UP) continue;
@@ -6402,14 +7344,14 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
       return best;
     };
     const slideEntry = (index) => {
-      const cell = entries.cell[index];
-      const target = lowestNeighbour(cell, entries.thickness[index]);
+      const cell = entries2.cell[index];
+      const target = lowestNeighbour(cell, entries2.thickness[index]);
       if (target < 0) return;
       if (height[target] === 0) touched[touchedCount++] = target;
-      height[target] += entries.thickness[index];
-      height[cell] -= entries.thickness[index];
-      entries.cell[index] = target;
-      const agent = entries.agent[index];
+      height[target] += entries2.thickness[index];
+      height[cell] -= entries2.thickness[index];
+      entries2.cell[index] = target;
+      const agent = entries2.agent[index];
       if (agent < 0) return;
       store.x[agent] += (target % grid.n - cell % grid.n) * grid.cell;
       store.z[agent] += (Math.floor(target / grid.n) - Math.floor(cell / grid.n)) * grid.cell;
@@ -6418,17 +7360,17 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
       let over = false;
       for (let k = 0; k < touchedCount && !over; k++) over = height[touched[k]] > maxMillimetres;
       if (!over) return;
-      const order = Array.from({ length: entries.count }, (_, index) => index).sort((a, b) => entries.cell[a] - entries.cell[b] || entries.identity[a] - entries.identity[b] || a - b);
+      const order = Array.from({ length: entries2.count }, (_, index) => index).sort((a, b) => entries2.cell[a] - entries2.cell[b] || entries2.identity[a] - entries2.identity[b] || a - b);
       let current = -1;
       let running = 0;
       for (const index of order) {
-        const cell = entries.cell[index];
+        const cell = entries2.cell[index];
         if (cell !== current) {
           current = cell;
           running = 0;
         }
         if (height[cell] <= maxMillimetres) continue;
-        if (running + entries.thickness[index] <= maxMillimetres) running += entries.thickness[index];
+        if (running + entries2.thickness[index] <= maxMillimetres) running += entries2.thickness[index];
         else slideEntry(index);
       }
       for (let k = 0; k < touchedCount; k++) if (height[touched[k]] > maxMillimetres) height[touched[k]] = maxMillimetres;
@@ -6488,14 +7430,14 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
   }
   function createDefaultWorkerFactory() {
     if (typeof Worker === "undefined") return null;
-    let url;
+    let url2;
     try {
-      url = new URL("./physics-worker.js", import_meta.url);
+      url2 = new URL("./physics-worker.js", import_meta.url);
     } catch {
       return null;
     }
     return () => {
-      const worker = new Worker(url, { type: "module" });
+      const worker = new Worker(url2, { type: "module" });
       return {
         postMessage: (message, transfer) => worker.postMessage(message, transfer ?? []),
         onMessage: (listener) => worker.addEventListener("message", (event) => listener(event.data)),
@@ -9869,10 +10811,10 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
       for (let i = 0; i < count; i++) order[sortStarts[sortBin(distances[i])]++] = i;
     };
     const corpseHistogram = new Uint32Array(budget ? Math.ceil(CORPSE_REACH / BUDGET_BIN) + 1 : 0);
-    const fitCorpseEdges = (entries, cx, cz, scale) => {
+    const fitCorpseEdges = (entries2, cx, cz, scale) => {
       if (!budget) return [N.corpseNear, Infinity];
       corpseHistogram.fill(0);
-      for (const { data } of entries) {
+      for (const { data } of entries2) {
         const distance2 = Math.hypot(data.x - cx, data.z - cz);
         if (distance2 < CORPSE_REACH) corpseHistogram[Math.floor(distance2 / BUDGET_BIN)]++;
       }
@@ -9951,11 +10893,11 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
         }
         return written;
       },
-      corpses(entries, variants, frame, life, sink, plain) {
+      corpses(entries2, variants, frame, life, sink, plain) {
         const cx = frame.camera.x;
         const cz = frame.camera.z;
-        const [nearEdge, middleEdge] = fitCorpseEdges(entries, cx, cz, frame.detailScale ?? 1);
-        for (const { age: t, data: C } of entries) {
+        const [nearEdge, middleEdge] = fitCorpseEdges(entries2, cx, cz, frame.detailScale ?? 1);
+        for (const { age: t, data: C } of entries2) {
           const dark = Math.min(1, t / life);
           const shade = 1 - dark * N.corpseDarken;
           const fade = t > life - N.corpseFade ? (life - t) / N.corpseFade : 1;
@@ -10483,7 +11425,7 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
   };
   var HERD_SOUND_IDS = { bark: "dog_bark", lapwing: "lapwing_call", cluck: "hen_cluck", moo: "cow_moo" };
 
-  // ../game-player/dist/chunk-FRZ6ISLA.js
+  // ../game-player/dist/chunk-RUFQCNZH.js
   var defaults_default2 = {
     sources: {
       game: "specs/001-migracao-entregas-dos-times/artefatos/2UG1Mhe9LqJkQKKVsJkTWR/jogo.js",
@@ -11950,7 +12892,17 @@ ${accessoryHead}`).replace("{ vec3 _nn = objectNormal; bodyAnim(position, _nn);"
         const offFixed = lent.onFrame((step) => world.physics ? stepCrowd(step) : void 0, { phase: "fixedSimulate" });
         const offBlast = lent.on((event) => {
           if (event.type !== "explosion") return;
-          world.crowd.blast({ point: event.point, energy: event.energy, radius: event.radius, lethalRadius: event.radius * LETHAL_SHARE, source: event.source, ...event.cause === "part" ? { chain: event.source } : {} });
+          const cover = lent.blastReach;
+          world.crowd.blast({
+            point: event.point,
+            energy: event.energy,
+            radius: event.radius,
+            lethalRadius: event.radius * LETHAL_SHARE,
+            source: event.source,
+            ...event.cause === "part" ? { chain: event.source } : {},
+            // a wall or a car between the blast and an agent takes its share of the shove and the damage
+            ...cover ? { reach: (target) => cover(event.point, [target[0], target[1], target[2]], [event.source]) } : {}
+          });
         });
         if (host) removeProps = sceneOf()?.props?.(host, { cx, cz }, options.props ?? {}) ?? null;
         if (options.eager) queueMicrotask(() => prepareDrawing());