Give the Helium Bomb distance-based damage falloff and a slow shockwave (#11)

Replace the flat "erase everything within blast radius" kill with a
distance-squared decay of HP loss: entities within BOMB_CORE_RADIUS
(1.5x the bomb's own radius) still take a guaranteed-kill hit, but
damage tapers off with the square of distance beyond that, reaching
zero at BOMB_BLAST_RADIUS. Blast-killed entities still grant no
salvage, same as before.

Also slows and reworks the detonation VFX into a dramatic, decelerating
shockwave ring that crawls out to the true blast radius and cools from
a hot core color to ash-grey at the tapering edge, echoing the new
damage curve. Updates the HUD panel text and test suite to match.

Co-authored-by: Claude <noreply@anthropic.com>

boot.js

@@ -453,10 +453,11 @@ function processFrameEvents() {
         addDeathFlash(ev.x, ev.y);
         break;
       // The Helium Bomb's detonation (engine/bomb.js) — one event for the blast itself,
-      // alongside the individual entityKilled events for everything it erased.
+      // alongside the individual entityKilled events for everything the falloff-damaged
+      // blast actually killed outright.
       case "bombDetonated":
         sound.playExplosion(pan);
-        addExplosion(ev.x, ev.y, ev.radius);
+        addExplosion(ev.x, ev.y, ev.radius, ev.coreRadius);
         if (ev.owner === "ai") triggerUnderAttack(ev.x, ev.y);
         break;
       // A Helium Bomb crater (engine/bomb.js) finished terraforming — the payoff for the

effects.js

@@ -17,7 +17,10 @@ const TRACER_LIFETIME_MS = 120;
 const DEATH_LIFETIME_MS = 280;
 const PING_LIFETIME_MS = 3000;
 const FIREWORK_LIFETIME_MS = 1500;
-const EXPLOSION_LIFETIME_MS = 900;
+// Long enough for the shockwave ring (renderEffects.js) to visibly crawl
+// out to its real blast radius rather than snapping there in a couple of
+// frames — the slow travel is what sells the blast's true reach.
+const EXPLOSION_LIFETIME_MS = 2400;
 
 let tracers = [];
 let deaths = [];
@@ -40,11 +43,14 @@ export function addUnderAttackPing(x, y) {
   pings.push({ x, y, born: performance.now() });
 }
 
-// The Helium Bomb's detonation (engine/bomb.js's bombDetonated event): a shockwave ring
-// that expands out to the blast's real radius (so the VFX itself shows the player exactly
-// how far the erasure reached), not a fixed cosmetic size like the death flash above.
-export function addExplosion(x, y, radius) {
-  explosions.push({ x, y, radius, born: performance.now() });
+// The Helium Bomb's detonation (engine/bomb.js's bombDetonated event): a slow-moving
+// shockwave ring that crawls out to the blast's real radius (so the VFX itself shows the
+// player exactly how far the damage reached), not a fixed cosmetic size like the death
+// flash above. `coreRadius` is the inner "guaranteed kill" distance (BOMB_CORE_RADIUS) the
+// ring starts from, so the render side can shade the traveling front from hot (peak
+// damage, near ground zero) to cool (the tapering edge) as it goes.
+export function addExplosion(x, y, radius, coreRadius = 0) {
+  explosions.push({ x, y, radius, coreRadius, born: performance.now() });
 }
 
 // A celebratory burst show for Odyssey progress milestones (engine/galaxy.js). Screen-space,

engine/bomb.js

@@ -18,10 +18,22 @@
 
    The blast radius is deliberately tied to POWER_TIERS[0] (engine/industry.js)
    — the same "on-grid" ring every Reactor/Generator projects — rather than an
-   independent magic number: the bomb erases everything inside the reach of a
+   independent magic number: the bomb's damage reaches exactly as far as a
    power station's innermost efficiency zone, so the number on the tooltip can
    never silently drift from what the power-grid UI already shows the player.
 
+   DAMAGE FALLOFF: the blast isn't a flat "erase everything inside the
+   radius" cutoff — HP loss decays with the square of distance from ground
+   zero (bombDamageAt below), same shape as a real blast's inverse-square
+   falloff. The curve is referenced against BOMB_CORE_RADIUS (1.5x the bomb's
+   own footprint) rather than the true center, since 1/d^2 diverges as d->0;
+   inside that "unitary distance" everything takes the same peak hit
+   (BOMB_MAX_DAMAGE, enough to one-shot even the toughest building in the
+   game), and it tapers off from there out to zero at BOMB_BLAST_RADIUS. So
+   ground zero is still an indiscriminate kill, but a lightly-built unit
+   caught out near the edge may only take a scratch instead of vanishing
+   outright.
+
    TERRAFORMING: a detonation doesn't just erase — it also schedules a crater
    (state.craters) at the blast center. Once CRATER_SPAWN_DELAY of sim time
    passes, updateCraters (called every tick from engine/sim.js) turns it into
@@ -45,7 +57,8 @@ import { hashStr } from "./rng.js";
 import { COM } from "../data.js";
 
 // The power station's "first circle": POWER_TIERS[0] is the innermost,
-// on-grid efficiency band every Reactor/Generator projects.
+// on-grid efficiency band every Reactor/Generator projects. Nothing this far
+// out (or beyond) takes any blast damage at all.
 export const BOMB_BLAST_RADIUS = POWER_TIERS[0].max;
 
 // How close a live enemy has to come before an ARMED bomb detonates on its
@@ -53,6 +66,31 @@ export const BOMB_BLAST_RADIUS = POWER_TIERS[0].max;
 // already too late to back out of the blast.
 export const BOMB_DETECT_RANGE = BOMB_BLAST_RADIUS + 30;
 
+// The falloff curve's "unitary distance": 1.5x the bomb unit's own radius
+// (engine/entities.js). Derived, not a separate magic number, so it can
+// never drift out of proportion to the unit it's describing. Everything at
+// or inside this distance takes the full BOMB_MAX_DAMAGE hit — an inverse-
+// square curve diverges as distance approaches zero, so it has to be capped
+// somewhere, and this is the natural "ground zero" radius to cap it at.
+export const BOMB_CORE_RADIUS = UNITS.heliumbomb.radius * 1.5;
+
+// Peak HP loss at/inside BOMB_CORE_RADIUS — comfortably past the toughest
+// building in the game (the Antimatter Gate, 1200hp) so ground zero still
+// reads as an outright kill, same as the old flat-erasure blast.
+export const BOMB_MAX_DAMAGE = 3000;
+
+// HP lost to the blast at `dist` from ground zero: flat BOMB_MAX_DAMAGE out
+// to BOMB_CORE_RADIUS, then falling off with the square of distance the rest
+// of the way to BOMB_BLAST_RADIUS (0 beyond it). A pre-baked lookup table
+// isn't worth it here — this only ever runs once per detonation, over the
+// handful of entities caught in range, never per-frame — so the curve is
+// just computed directly rather than approximated.
+export function bombDamageAt(dist) {
+  if (dist > BOMB_BLAST_RADIUS) return 0;
+  const d = Math.max(dist, BOMB_CORE_RADIUS);
+  return BOMB_MAX_DAMAGE * (BOMB_CORE_RADIUS / d) ** 2;
+}
+
 // How long (sim seconds — state.time, not wall clock) after a detonation the
 // crater takes to mature into a mineable deposit.
 export const CRATER_SPAWN_DELAY = 60;
@@ -69,28 +107,41 @@ function isBomb(e) {
 }
 
 // Detonate `bomb` right now, unconditionally — the ONE place the blast itself
-// happens, so every trigger produces the exact same result. Erases (outright
-// removes — no salvage, no partial hp, no survivors) every unit and building
-// within BOMB_BLAST_RADIUS, ANY owner included: the bomb's own side's units
-// and buildings, and the bomb itself, are not exempt. Snapshots the caught
-// set before removing anything, so the sweep can't be thrown off by entities
-// disappearing mid-scan. One bombDetonated event drives the explosion VFX +
-// sound (boot.js/effects.js/sound.js); each erased entity still gets its own
-// entityKilled event so the ordinary death-flash plays across the whole blast.
+// happens, so every trigger produces the exact same result. Every unit and
+// building within BOMB_BLAST_RADIUS, ANY owner included (the bomb's own
+// side's units and buildings, and the bomb itself, are not exempt), takes
+// bombDamageAt(dist) HP loss and dies (outright removed — no salvage, this
+// is blast damage, not a normal kill) if that drops it to 0 or below;
+// anything too far out to be reduced to 0 just survives, scarred. Snapshots
+// the caught set with its distances before removing anything, so the sweep
+// can't be thrown off by entities disappearing mid-scan. One bombDetonated
+// event drives the explosion VFX + sound (boot.js/effects.js/sound.js); each
+// killed entity still gets its own entityKilled event so the ordinary
+// death-flash plays across the whole blast.
 export function detonateBomb(state, bomb) {
   if (!bomb || bomb.hp <= 0) return;   // already gone — e.g. two triggers fired the same tick
 
   const caught = [];
-  for (const u of state.units.values())
-    if (Math.hypot(u.x - bomb.x, u.y - bomb.y) <= BOMB_BLAST_RADIUS) caught.push(u);
-  for (const b of state.buildings.values())
-    if (Math.hypot(b.x - bomb.x, b.y - bomb.y) <= BOMB_BLAST_RADIUS) caught.push(b);
-
-  for (const e of caught) {
-    removeEntity(state, e.id);
-    state.events.push({ type: "entityKilled", x: e.x, y: e.y, owner: e.owner });
+  for (const u of state.units.values()) {
+    const dist = Math.hypot(u.x - bomb.x, u.y - bomb.y);
+    if (dist <= BOMB_BLAST_RADIUS) caught.push({ e: u, dist });
   }
-  state.events.push({ type: "bombDetonated", x: bomb.x, y: bomb.y, radius: BOMB_BLAST_RADIUS, owner: bomb.owner });
+  for (const b of state.buildings.values()) {
+    const dist = Math.hypot(b.x - bomb.x, b.y - bomb.y);
+    if (dist <= BOMB_BLAST_RADIUS) caught.push({ e: b, dist });
+  }
+
+  for (const { e, dist } of caught) {
+    e.hp -= bombDamageAt(dist);
+    if (e.hp <= 0) {
+      removeEntity(state, e.id);
+      state.events.push({ type: "entityKilled", x: e.x, y: e.y, owner: e.owner });
+    }
+  }
+  state.events.push({
+    type: "bombDetonated", x: bomb.x, y: bomb.y,
+    radius: BOMB_BLAST_RADIUS, coreRadius: BOMB_CORE_RADIUS, owner: bomb.owner,
+  });
 
   // Schedule the crater. Named off the bomb's own (globally-unique, module-global-minted)
   // id rather than a fresh counter, so it can never collide with a map-generated node's

engine/combat.js

@@ -142,8 +142,9 @@ function nearestEnemyUnitWithin(state, unit, radius) {
 // its own "turret" type), and `heavy` so a siege hit thumps deeper.
 function performAttack(state, attacker, def, target) {
   // An ARMED Helium Bomb doesn't take damage from a hit — it detonates instead,
-  // erasing everything (attacker included) within its blast radius. Checked
-  // before the normal damage/death path, which never runs for it.
+  // dealing distance-falloff blast damage to everything (attacker included)
+  // within its blast radius. Checked before the normal damage/death path,
+  // which never runs for it.
   if (detonateIfAttacked(state, target)) return true;
   target.hp -= attackDamage(state, attacker, def, target);
   state.events.push({

hudSelection.js

@@ -26,7 +26,7 @@ import { supplyUsed, supplyCap } from "./engine/supply.js";
 import { powerCap, powerDraw, recipeOf, powerThrottle, planetIndustryScale, powerEfficiency, onPowerGrid, electrifyBoost, ELECTRIFY_POWER } from "./engine/industry.js";
 import { storeTotal, storeCapOf, storeRoom, inputTotal, inputCapOf, isElectrifiable } from "./engine/entities.js";
 import { rigInfo } from "./engine/rig.js";
-import { detonateBomb, BOMB_BLAST_RADIUS, BOMB_DETECT_RANGE } from "./engine/bomb.js";
+import { detonateBomb, BOMB_BLAST_RADIUS, BOMB_CORE_RADIUS, BOMB_DETECT_RANGE } from "./engine/bomb.js";
 import { TECHS, researchTech, techMult } from "./engine/techtree.js";
 import { BUILDINGS, UNITS, UPGRADES, canAfford, prereqsMet, committedDoctrine } from "./engine/entities.js";
 import { repairCost, repairConvoy, departNow } from "./engine/scenarios.js";
@@ -730,7 +730,7 @@ function rebuildSelectionPanel(sel) {
     const bombLocked = !prereqsMet(state, "player", bombDef);
     panelEl.appendChild(prodButton(`Produce ${bombDef.name} (${costText(bombDef.cost)})`,
       () => queueProduction(state, stardock.id, "heliumbomb"),
-      { cost: bombDef.cost, tip: `${unitTip(bombDef)} · ${BOMB_BLAST_RADIUS}-radius blast when armed and triggered`,
+      { cost: bombDef.cost, tip: `${unitTip(bombDef)} · ${BOMB_BLAST_RADIUS}-radius blast when armed and triggered — damage falls off with distance from ground zero`,
         locked: bombLocked, lockTip: bombLocked ? lockTipFor(bombDef) : null, icon: { kind: "unit", type: "heliumbomb" } }));
     if (stardock.queue.length) renderQueueRows(stardock);
   }
@@ -1056,8 +1056,8 @@ function rebuildSelectionPanel(sel) {
     const note = document.createElement("div");
     note.className = "sel-note " + (armed ? "bad" : "good");
     note.textContent = armed
-      ? `⚠ ARMED — erases every unit and building (any owner, including yours) within ${BOMB_BLAST_RADIUS} — a power station's on-grid reach. Detonates on the next hit it takes, if an enemy comes within ${BOMB_DETECT_RANGE}, or on your command.`
-      : `Unarmed — safe to move anywhere. Once armed: ${BOMB_BLAST_RADIUS}-radius blast erasing every unit and building inside it, any owner.`;
+      ? `⚠ ARMED — blasts every unit and building (any owner, including yours) within ${BOMB_BLAST_RADIUS} — a power station's on-grid reach. Anything within ${Math.round(BOMB_CORE_RADIUS)} of ground zero is destroyed outright; damage tapers off with distance beyond that. Detonates on the next hit it takes, if an enemy comes within ${BOMB_DETECT_RANGE}, or on your command.`
+      : `Unarmed — safe to move anywhere. Once armed: ${BOMB_BLAST_RADIUS}-radius blast, any owner — a guaranteed kill within ${Math.round(BOMB_CORE_RADIUS)} of ground zero, tapering off with distance beyond that.`;
     panelEl.appendChild(note);
     panelEl.appendChild(makeButton(armed ? "◯ Disarm" : "☢ Arm the Bomb",
       () => { const v = !armed; for (const e of sel) if (e.kind === "unit" && UNITS[e.type].role === "bomb") e.armed = v; },

renderEffects.js

@@ -104,6 +104,23 @@ function tracerColor(unitType) {
   return "#f87171";
 }
 
+// The Helium Bomb shockwave (see drawEffects below): the fireball collapses
+// within the first slice of the effect's life, the ring then spends most of
+// the rest slowly traveling out to the true blast radius, and the remainder
+// is left for it to fade out once it arrives.
+const EXPLOSION_FLASH_FRACTION = 0.15;
+const EXPLOSION_SHOCKWAVE_FRACTION = 0.85;
+// Hot (near ground zero, peak damage) -> cool ash-grey (the tapering edge),
+// matching bombDamageAt's own falloff from full HP loss to a scratch.
+const SHOCKWAVE_HOT = [255, 180, 80];
+const SHOCKWAVE_COOL = [148, 163, 184];
+function lerpColor(a, b, t) {
+  const r = Math.round(a[0] + (b[0] - a[0]) * t);
+  const g = Math.round(a[1] + (b[1] - a[1]) * t);
+  const b2 = Math.round(a[2] + (b[2] - a[2]) * t);
+  return `rgb(${r}, ${g}, ${b2})`;
+}
+
 // Attack tracers, death flashes, and under-attack pings: all purely
 // cosmetic and short-lived (see effects.js), so this is the only place
 // in render.js that reads wall-clock-timed state instead of the sim's
@@ -164,22 +181,43 @@ export function drawEffects(ctx) {
     ctx.stroke();
   }
 
-  // The Helium Bomb's detonation (engine/bomb.js): a bright flash that collapses fast, under
-  // an expanding shockwave ring that reaches `e.radius` — the ACTUAL blast radius that just
-  // erased everything inside it — a third of the way through its life, then fades out. The
-  // ring's real size (not a fixed cosmetic one) is what tells the player how far it reached.
+  // The Helium Bomb's detonation (engine/bomb.js): a bright fireball flash at ground zero
+  // that collapses fast, under a slow-moving shockwave ring that crawls out from
+  // e.coreRadius (the guaranteed-kill distance) to e.radius (the true blast radius the
+  // damage falloff reaches zero at) over most of the effect's life — a deliberately
+  // unhurried, decelerating travel (real shockwaves lose speed as they lose energy) so the
+  // blast reads as a big, dramatic event rather than a one-frame pop. The ring cools from a
+  // hot core color to an ash-grey edge color as it travels, echoing bombDamageAt's own
+  // falloff from peak damage to a scratch. Reduced-motion viewers get a single fast static
+  // ring at the true radius instead of the slow travel.
   for (const e of explosions) {
-    const flashR = e.radius * 0.3 * Math.max(0, 1 - e.age * 3);
-    ctx.globalAlpha = Math.max(0, 1 - e.age * 4);
+    const flashT = Math.min(1, e.age / EXPLOSION_FLASH_FRACTION);
+    const flashR = (e.coreRadius || e.radius * 0.3) * Math.max(0, 1 - flashT);
+    ctx.globalAlpha = Math.max(0, 1 - flashT * 1.2);
     ctx.fillStyle = "#fff3c4";
     ctx.beginPath();
     ctx.arc(e.x, e.y, flashR, 0, Math.PI * 2);
     ctx.fill();
 
-    const ringR = e.radius * Math.min(1, e.age * 3);
-    ctx.globalAlpha = Math.max(0, 1 - e.age);
-    ctx.strokeStyle = "#ff8a3d";
-    ctx.lineWidth = 4 * Math.max(0, 1 - e.age);
+    if (reduced) {
+      ctx.globalAlpha = Math.max(0, 0.6 * (1 - e.age));
+      ctx.strokeStyle = "#ff8a3d";
+      ctx.lineWidth = 3;
+      ctx.beginPath();
+      ctx.arc(e.x, e.y, e.radius, 0, Math.PI * 2);
+      ctx.stroke();
+      continue;
+    }
+
+    const travel = Math.min(1, e.age / EXPLOSION_SHOCKWAVE_FRACTION);
+    const eased = 1 - (1 - travel) ** 3;   // ease-out: fast off the blast, decelerating outward
+    const ringR = (e.coreRadius || 0) + (e.radius - (e.coreRadius || 0)) * eased;
+    const ringAlpha = e.age < EXPLOSION_SHOCKWAVE_FRACTION
+      ? 0.9 - 0.5 * travel
+      : Math.max(0, 0.4 * (1 - (e.age - EXPLOSION_SHOCKWAVE_FRACTION) / (1 - EXPLOSION_SHOCKWAVE_FRACTION)));
+    ctx.globalAlpha = Math.max(0, ringAlpha);
+    ctx.strokeStyle = lerpColor(SHOCKWAVE_HOT, SHOCKWAVE_COOL, eased);
+    ctx.lineWidth = Math.max(1, 5 * (1 - eased * 0.6));
     ctx.beginPath();
     ctx.arc(e.x, e.y, ringR, 0, Math.PI * 2);
     ctx.stroke();

test/bomb.test.js

@@ -5,8 +5,9 @@ import { updateCombat } from "../engine/combat.js";
 import { tick } from "../engine/sim.js";
 import { UNITS, BUILDINGS } from "../engine/entities.js";
 import { POWER_TIERS } from "../engine/industry.js";
-import { detonateBomb, detonateIfAttacked, checkBombProximity, updateCraters,
-         BOMB_BLAST_RADIUS, BOMB_DETECT_RANGE, CRATER_SPAWN_DELAY, CRATER_NODE_AMOUNT, CRATER_COMMODITIES } from "../engine/bomb.js";
+import { detonateBomb, detonateIfAttacked, checkBombProximity, updateCraters, bombDamageAt,
+         BOMB_BLAST_RADIUS, BOMB_CORE_RADIUS, BOMB_MAX_DAMAGE, BOMB_DETECT_RANGE,
+         CRATER_SPAWN_DELAY, CRATER_NODE_AMOUNT, CRATER_COMMODITIES } from "../engine/bomb.js";
 import { serializeGame, deserializeGame } from "../engine/persist.js";
 import { queueProduction } from "../engine/production.js";
 import { COM } from "../data.js";
@@ -175,54 +176,108 @@ test("detonateBomb on an already-gone bomb is a harmless no-op", () => {
   assert.doesNotThrow(() => detonateBomb(state, bomb));   // calling again on the same (now-orphaned) object
 });
 
-/* ---------- the blast itself: radius, indiscriminate, "erasing" ---------- */
+/* ---------- the blast itself: distance-squared damage falloff ---------- */
 
-test("the blast erases every unit and building within radius, ANY owner — including the bomb's own side", () => {
+test("BOMB_CORE_RADIUS is exactly 1.5x the bomb unit's own footprint", () => {
+  assert.equal(BOMB_CORE_RADIUS, UNITS.heliumbomb.radius * 1.5);
+});
+
+test("bombDamageAt: flat peak damage inside the core, inverse-square falloff beyond it, zero past the blast radius", () => {
+  assert.equal(bombDamageAt(0), BOMB_MAX_DAMAGE, "ground zero itself takes the peak hit");
+  assert.equal(bombDamageAt(BOMB_CORE_RADIUS), BOMB_MAX_DAMAGE, "still full damage exactly at the core boundary");
+  assert.equal(bombDamageAt(BOMB_CORE_RADIUS / 2), BOMB_MAX_DAMAGE, "inside the core the curve is clamped flat, not left to diverge");
+
+  // Distance-SQUARED decay referenced off BOMB_CORE_RADIUS: doubling the distance past the
+  // core should quarter the damage, tripling it should cut damage to a ninth.
+  const at2x = bombDamageAt(BOMB_CORE_RADIUS * 2);
+  const at3x = bombDamageAt(BOMB_CORE_RADIUS * 3);
+  assert.ok(Math.abs(at2x - BOMB_MAX_DAMAGE / 4) < 1e-9, `2x core distance should be ~1/4 damage, got ${at2x}`);
+  assert.ok(Math.abs(at3x - BOMB_MAX_DAMAGE / 9) < 1e-9, `3x core distance should be ~1/9 damage, got ${at3x}`);
+
+  assert.ok(bombDamageAt(BOMB_BLAST_RADIUS) > 0, "still some token damage right at the edge of the blast radius");
+  assert.equal(bombDamageAt(BOMB_BLAST_RADIUS + 0.01), 0, "nothing at all past the blast radius");
+});
+
+test("ground zero (within BOMB_CORE_RADIUS) still kills everything outright, ANY owner — indiscriminate", () => {
   const state = createGameState({ planetId: "ferros", endless: true });
   const bomb = makeUnit("heliumbomb", "player", 4000, 4000);
   state.units.set(bomb.id, bomb);
 
-  const ownWorker = makeUnit("worker", "player", 4050, 4000);           // friendly, well inside
-  const enemyWorker = makeUnit("worker", "ai", 4000, 4050);             // enemy, well inside
-  const ownBuilding = makeBuilding("command", "player", 4000, 4100);    // friendly building, inside
-  const enemyBuilding = makeBuilding("barracks", "ai", 3900, 4000);     // enemy building, inside
+  const ownWorker = makeUnit("worker", "player", 4005, 4000);            // friendly, well within the core
+  const enemyWorker = makeUnit("worker", "ai", 4000, 4010);              // enemy, well within the core
+  const ownBuilding = makeBuilding("command", "player", 4000, 3986);     // friendly, 1000hp — but at dist 14, inside the core
+  const enemyBuilding = makeBuilding("barracks", "ai", 3985, 4000);      // enemy, at dist 15 — exactly the core boundary
   for (const u of [ownWorker, enemyWorker]) state.units.set(u.id, u);
   for (const b of [ownBuilding, enemyBuilding]) state.buildings.set(b.id, b);
 
   detonateBomb(state, bomb);
 
-  assert.ok(!state.units.has(ownWorker.id), "the bomb owner's own worker is erased too — indiscriminate");
+  assert.ok(!state.units.has(ownWorker.id), "the bomb owner's own worker dies too — indiscriminate");
   assert.ok(!state.units.has(enemyWorker.id));
-  assert.ok(!state.buildings.has(ownBuilding.id), "even the owner's own Command Center is erased");
+  assert.ok(!state.buildings.has(ownBuilding.id), "even the owner's own 1000hp Command Center dies at ground zero");
   assert.ok(!state.buildings.has(enemyBuilding.id));
 });
 
-test("something just outside the blast radius survives untouched", () => {
+test("further from ground zero, damage falls off — a fragile unit dies where a tough building only takes a scratch", () => {
+  const state = createGameState({ planetId: "ferros", endless: true });
+  const bomb = makeUnit("heliumbomb", "player", 4000, 4000);
+  state.units.set(bomb.id, bomb);
+
+  const dist = 90;
+  const worker = makeUnit("worker", "ai", 4000 + dist, 4000);            // 40hp
+  const command = makeBuilding("command", "ai", 4000, 4000 + dist);      // 1000hp, same distance
+  state.units.set(worker.id, worker);
+  state.buildings.set(command.id, command);
+  const expectedDmg = bombDamageAt(dist);
+
+  detonateBomb(state, bomb);
+
+  assert.ok(!state.units.has(worker.id), "40hp worker doesn't survive this far out");
+  assert.ok(state.buildings.has(command.id), "1000hp Command Center survives the same distance");
+  const survivor = state.buildings.get(command.id);
+  assert.ok(Math.abs(survivor.hp - (1000 - expectedDmg)) < 1e-6, "took real, partial damage — not untouched, not erased");
+});
+
+test("something well past the blast radius survives completely untouched", () => {
   const state = createGameState({ planetId: "ferros", endless: true });
   const bomb = makeUnit("heliumbomb", "player", 4000, 4000);
   state.units.set(bomb.id, bomb);
   const safe = makeUnit("worker", "ai", 4000 + BOMB_BLAST_RADIUS + 5, 4000);
   state.units.set(safe.id, safe);
-  const caught = makeUnit("worker", "ai", 4000 + BOMB_BLAST_RADIUS - 5, 4000);
-  state.units.set(caught.id, caught);
 
   detonateBomb(state, bomb);
 
-  assert.ok(state.units.has(safe.id), "just past the blast radius — untouched");
-  assert.ok(!state.units.has(caught.id), "just inside — erased");
+  assert.ok(state.units.has(safe.id), "past the blast radius — untouched");
+  assert.equal(state.units.get(safe.id).hp, safe.hp, "not even scratched");
+});
+
+test("right at the ragged edge of the blast radius, a fragile unit only takes a scratch — not necessarily lethal", () => {
+  const state = createGameState({ planetId: "ferros", endless: true });
+  const bomb = makeUnit("heliumbomb", "player", 4000, 4000);
+  state.units.set(bomb.id, bomb);
+  const dist = BOMB_BLAST_RADIUS - 5;
+  const edge = makeUnit("worker", "ai", 4000 + dist, 4000);
+  state.units.set(edge.id, edge);
+  const expectedDmg = bombDamageAt(dist);
+
+  detonateBomb(state, bomb);
+
+  assert.ok(state.units.has(edge.id), "the tapering tail of the blast isn't lethal to a full-hp worker this far out");
+  assert.ok(Math.abs(state.units.get(edge.id).hp - (40 - expectedDmg)) < 1e-6);
 });
 
-test("erased entities grant no salvage — a total loss, not a normal kill", () => {
+test("entities killed by the blast grant no salvage — a total loss, not a normal kill", () => {
   const state = createGameState({ planetId: "ferros", endless: true });
   const bomb = makeUnit("heliumbomb", "player", 5000, 5000);
   state.units.set(bomb.id, bomb);
-  const skiff = makeUnit("skiff", "ai", 5010, 5000);
+  const skiff = makeUnit("skiff", "ai", 5010, 5000);   // well within the core — guaranteed kill
   state.units.set(skiff.id, skiff);
   const resourcesBefore = { ...state.players.ai.resources };
 
   detonateBomb(state, bomb);
 
-  assert.deepEqual(state.players.ai.resources, resourcesBefore, "no salvage was granted for the erased skiff");
+  assert.ok(!state.units.has(skiff.id), "sanity check: it actually died");
+  assert.deepEqual(state.players.ai.resources, resourcesBefore, "no salvage was granted for the blast-killed skiff");
 });
 
 /* ---------- terraforming: the crater matures into a mineable deposit ---------- */