Odyssey/RTS UX: pausable factories, box-select prefers fighters, sub-select by type

Three requested quality-of-life changes.

Pause producers (engine/industry.js + hud.js): a Smelter (or any factory) can eat ore
faster than you want. A selected factory now has a Pause/Resume button; a paused factory
consumes no inputs, banks no output, and frees its reserved Power for the rest of the
grid (or a charging Gate). The status line reads "Paused". The flag rides the building
object, so it persists across save/load for free.

Box-select prioritises the army (input.js): a drag-box that catches any fighter now drops
the workers from the selection, so sweeping across your base to grab your army no longer
drags the miners along. A box with no fighters still selects workers as before.

Sub-select by type (input.js + hud.js): when a mixed group is selected, the aggregated
type rows ("3× Bastion", "12× Skiff") are now buttons — click one to narrow the selection
to just that type. Single-type selections render as before (nothing to sub-select).

Tests: +1 industry (a paused factory consumes/produces/draws nothing, resumes cleanly);
462 pass. Browser-verified all three end-to-end.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AEQUVetLk31Jj7niDQAsXL

engine/industry.js

@@ -66,7 +66,7 @@ export function powerDraw(state, owner) {
     if (b.owner !== owner || b.constructing) continue;
     const def = BUILDINGS[b.type];
     const r = def.recipe ? RECIPE_BY_ID[def.recipe] : null;
-    if (r) draw += (r.in.energy || 0) * (def.prodRate || 1);
+    if (r && !b.paused) draw += (r.in.energy || 0) * (def.prodRate || 1);   // a paused factory frees its reserved Power
     // A wonder still charging loads the grid too, so the Antimatter Gate competes
     // with the factories for Reactor Power (engine/wonder.js) — making the finale a
     // real "feed the factories vs charge the Gate" call, and Fusion Containment worth it.
@@ -95,6 +95,7 @@ export function updateProduction(state, building, dt) {
   if (building.constructing) return;
   const recipe = recipeOf(building);
   if (!recipe) return;
+  if (building.paused) return;   // player-paused to conserve its inputs — banks nothing, draws nothing (see hud.js)
   const throttle = powerThrottle(state, building.owner);
   if (throttle <= 0) return;
   const player = state.players[building.owner];

hud.js

@@ -392,6 +392,7 @@ function renderMarket(state) {
 // applies, in priority order: no Power at all, then a missing input, then a Power
 // shortfall throttling everything, else running (with the live output rate).
 function factoryStatus(state, b, recipe) {
+  if (b.paused) return { cls: "paused", text: "Paused — banking its inputs" };
   const throttle = powerThrottle(state, b.owner);
   if (throttle <= 0) return { cls: "bad", text: "Stalled — no Power" };
 
@@ -449,13 +450,27 @@ function rebuildSelectionPanel(sel) {
   }
 
   if (sel.length > 1 && sel.every(e => e.kind === "unit")) {
-    for (const [type, entry] of countByType(sel)) {
+    const counts = countByType(sel);
+    const multiType = counts.size > 1;   // only worth sub-selecting when the mix has 2+ types
+    for (const [type, entry] of counts) {
       const def = UNITS[type];
-      const row = document.createElement("div");
-      row.className = "sel-row";
       const pct = Math.round((entry.hp / entry.maxHp) * 100);
-      row.textContent = `${entry.count}× ${def.name} — ${pct}% hp`;
-      panelEl.appendChild(row);
+      const label = `${entry.count}× ${def.name} — ${pct}% hp`;
+      // With several types selected, each row is a button that narrows the selection
+      // to just that type (input.selectType) — click "3× Bastion" to keep only them.
+      if (multiType) {
+        const btn = document.createElement("button");
+        btn.className = "sel-row type-row";
+        btn.textContent = label;
+        btn.title = `Select only your ${def.name}s`;
+        btn.addEventListener("click", () => input.selectType(type));
+        panelEl.appendChild(btn);
+      } else {
+        const row = document.createElement("div");
+        row.className = "sel-row";
+        row.textContent = label;
+        panelEl.appendChild(row);
+      }
     }
   } else {
     sel.forEach(e => {
@@ -606,6 +621,13 @@ function rebuildSelectionPanel(sel) {
     stRow.className = "sel-note " + st.cls;
     stRow.textContent = st.text;
     panelEl.appendChild(stRow);
+
+    // Pause toggle: stop this factory drawing down its inputs (and Power) — the way to
+    // keep a hungry Smelter from eating all your ore, or to free the grid for the Gate.
+    panelEl.appendChild(makeButton(factory.paused ? "▶ Resume production" : "⏸ Pause production",
+      () => { factory.paused = !factory.paused; },
+      { tip: factory.paused ? "Resume converting inputs into goods"
+                            : "Stop consuming inputs — banks and draws nothing until resumed" }));
   }
 
   // Reactor (Odyssey): grants Power to the grid rather than running a recipe, so

input.js

@@ -115,9 +115,14 @@ export function attachInput(canvas, state, onChange) {
     } else {
       const x1 = Math.min(box.x1, box.x2), x2 = Math.max(box.x1, box.x2);
       const y1 = Math.min(box.y1, box.y2), y2 = Math.max(box.y1, box.y2);
-      picks = [...state.units.values()]
-        .filter(u => u.owner === "player" && u.x >= x1 && u.x <= x2 && u.y >= y1 && u.y <= y2)
-        .map(u => u.id);
+      let inBox = [...state.units.values()]
+        .filter(u => u.owner === "player" && u.x >= x1 && u.x <= x2 && u.y >= y1 && u.y <= y2);
+      // Prioritise the army: a box that catches any fighter drops the workers, so
+      // sweeping across your base to grab your army doesn't drag the miners along
+      // (standard RTS). A box with no fighters still selects the workers as before.
+      if (inBox.some(u => UNITS[u.type].role === "combat"))
+        inBox = inBox.filter(u => u.type !== "worker");
+      picks = inBox.map(u => u.id);
     }
     if (additive) {
       if (picks.length) state.selection = [...new Set([...state.selection, ...picks])];
@@ -460,6 +465,13 @@ export function attachInput(canvas, state, onChange) {
     getCamera: () => camera,
     focusIdleWorker,
     selectAllArmy: () => { selectAllArmy(); onChange(); },
+    // Narrow the current selection to one unit type — the HUD's aggregated type rows
+    // are clickable (hud.js), so clicking "12× Skiff" keeps only the Skiffs.
+    selectType(type) {
+      const ids = state.selection
+        .map(id => state.units.get(id)).filter(u => u && u.type === type).map(u => u.id);
+      if (ids.length) { state.selection = ids; sound.playSelect(); onChange(); }
+    },
     stopSelected: () => { stopSelected(); onChange(); },
     scoutSelected: () => { scoutSelected(); onChange(); },
     holdSelected: () => { holdSelected(); onChange(); },

style.css

@@ -260,6 +260,16 @@ html, body {
 .sel-note.good { color: var(--good, #4ade80); }
 .sel-note.warn { color: var(--warn); }
 .sel-note.bad  { color: var(--bad); }
+.sel-note.paused { color: var(--muted); }
+
+/* Aggregated type row as a button (hud.js) — click "3× Bastion" to sub-select that
+   type. Strips the default button chrome, keeps the .sel-row look, adds a hover cue. */
+.type-row {
+  display: block; width: 100%; text-align: left;
+  background: none; border: none; border-bottom: 1px solid var(--border);
+  color: var(--text); font-family: inherit; cursor: pointer;
+}
+.type-row:hover { color: var(--accent); background: rgba(255, 255, 255, 0.03); }
 
 /* Section header in the Odyssey build menu (Economy / Military / …) — a quiet
    divider so the ~18-building list is scannable instead of a flat wall. */

test/industry.test.js

@@ -73,6 +73,19 @@ test("an unpowered factory produces nothing", () => {
   assert.equal(s.players.player.resources.ore, 1000, "…and no inputs consumed");
 });
 
+test("a paused factory consumes no inputs, banks no output, and frees its Power", () => {
+  const s = stub([reactor(), smelter({ paused: true })], { ore: 1000 });
+  const sm = [...s.buildings.values()].find(b => b.type === "smelter");
+  assert.equal(powerDraw(s, "player"), 0, "a paused factory reserves no Power (frees the grid for others)");
+  updateProduction(s, sm, 0.1);
+  assert.equal(s.players.player.resources.ore, 1000, "paused → no ore consumed");
+  assert.equal(s.players.player.resources.metals || 0, 0, "paused → no metals banked");
+  sm.paused = false;                       // resume
+  assert.equal(powerDraw(s, "player"), 4, "resumed → it reserves its draw again");
+  updateProduction(s, sm, 0.1);
+  assert.ok(s.players.player.resources.metals > 0, "resumed → it refines again");
+});
+
 test("updateProduction is a no-op for a building with no recipe (e.g. a Command Center)", () => {
   const s = stub([{ type: "command" }], { ore: 500 });
   const cc = [...s.buildings.values()][0];