diff --git a/game/.gitignore b/game/.gitignore
new file mode 100644
index 0000000..504afef
--- /dev/null
+++ b/game/.gitignore
@@ -0,0 +1,2 @@
+node_modules/
+package-lock.json
diff --git a/game/README.md b/game/README.md
new file mode 100644
index 0000000..2c577a3
--- /dev/null
+++ b/game/README.md
@@ -0,0 +1,111 @@
+# STANDARD OPERATING PSYCHOPATHY
+
+A post-apocalyptic bunker-management sim in the spirit of **Sheltered × Oxygen
+Not Included × BoomTown**, skinned as an institutional surveillance terminal in the
+aesthetic of the **Neue Deutsche Welle** — monochrome CRT amber, hard sans-serif
+propaganda headers, and cold motorik audio.
+
+You do not control the inmates directly. You manage the **grid** — power, air,
+food, and excavation — while your subjects act on their own drives.
+
+**v0.2 adds the surface.** Build a **Luftschleuse** (airlock) into the bunker
+ceiling to send subjects on **expeditions** for Öl, Konserven and Schrott, and
+to receive **Neuzugänge** (new subjects) — a powered **Funkturm** (radio tower)
+doubles their arrival rate. Progress is persisted with **save / load**
+(localStorage) plus a file export / import fallback.
+
+---
+
+## The fantasy
+
+> Die Oberfläche ist erledigt. Sie überwachen Sektor 4.
+
+The UI is diegetic: a rigid engineering monitor inside the bunker. Everything
+is uppercase German institutional copy. The bottom strip is a looping
+`DURCHSAGE` (announcement) ticker of NDW-flavored slogans.
+
+## Systems
+
+| System | What it does |
+| --- | --- |
+| **Conative Utility AI** | Each subject scores every possible action against its *Affective* state (Stress / Hunger / Erschöpfung / Argwohn / O₂-Mangel) and commits to the highest-scoring directive. No state machines. |
+| **Blackboard** | Shared memory where dig orders, hazards, and electrical nodes are posted. Subjects read it to pick work. |
+| **Power graph** | Devices are wired into components (Crosslink). Generation vs. draw decides whether a component is powered. Batteries buffer. |
+| **Gas / O₂ diffusion** | A Laplacian spread over the grid. Digging can rupture gas pockets. Scrubbers clean. |
+| **Ecology** | Farms grow rations from power. The generator burns **Öl** (dug up). Excavation yields caches of Beton / Metall / Rationen / Öl. |
+| **Disasters** | Erdbeben break devices and spike stress. High-stress Pyromanes sabotage wiring. |
+| **Surface** | The airlock is the only way out. An expedition sends one subject topside for a timer; they return with weighted loot and a chance of injury. New subjects arrive at the gate on their own schedule. |
+| **Persistence** | Autosave every ~5 min, manual save/load, and JSON export/import of the whole Akte. |
+
+## Traits
+
+- **Pyromane** — triggers a psychotic break (cuts a wire) at very high stress.
+- **Paranoid** — panics in darkness, needs light.
+- **Befehlsfixiert** — digs harder, ignores warnings.
+- **Schlafwandler** — sleeps anywhere.
+
+## Controls
+
+| Key / input | Action |
+| --- | --- |
+| `1–8`, `9`, `0` | Select a module to build |
+| `Q` | Luftschleuse (airlock) — place on the ceiling row |
+| `F` | Funkturm (radio tower) — doubles arrival rate |
+| `W` | Build wall |
+| `X` | Dig order (click dirt to mark) |
+| `V` | Toggle Physical ↔ Crosslink |
+| `E` | Toggle selected device on/off |
+| `F5` | Save |
+| `M` | Toggle audio |
+| `Space` | Pause |
+| `Esc` | Cancel placement |
+| Click module in **Crosslink** twice | Wire / unwire two nodes (≤ 8 tiles) |
+| Click the airlock | Open the expedition panel: pick a subject, send them topside |
+
+## Device table
+
+| Module | Watts | Role |
+| --- | --- | --- |
+| Tretbar-Dynamo | −60 | Hand-cranked power (a subject must work it) |
+| Lampe | +12 | Light radius 4, suppresses dark-stress |
+| Pritsche | 0 | Bed |
+| Rationen-Ausgabe | +5 | Serves meals (needs power + rations) |
+| Luft-Wäscher | +25 | Scrubs gas, emits O₂ |
+| Notstromaggregat | −100 | Burns 1 Öl / 35 s |
+| Schott | +10 | Door; blocks path while unpowered |
+| Bewegungssensor | +5 | Can be coupled to a Schott |
+| Akku-Block | 0 | Stores 2000 units of charge |
+| Pilzfarm | +15 | Grows 1 ration / 30 s of power |
+| Luftschleuse | 0 | Surface gate. One per sector, only on the ceiling row. Expedition + arrival point. |
+| Funkturm | +30 | Broadcasts on all bands; halves the interval between new subjects. |
+
+## Layout
+
+```
+game/
+ index.html shell + HUD
+ style.css brutalist CRT theme
+ config.js all tuning constants & data
+ world.js grid, devices, power graph, gas diffusion, Blackboard
+ ai.js Conative Utility AI (drives, pathing, execution)
+ render.js Physical + Crosslink canvas layers
+ ui.js inspector, build menu, log, overlays
+ main.js loop, input, events, day cycle
+ audio.js cold-wave sequencer (WebAudio)
+ tools/smoke.js headless simulation harness
+ tools/dom_test.js jsdom boot/integration test
+```
+
+## Tuning
+
+Every balance number lives in `config.js`. The sim has been validated with
+`tools/smoke.js` (headless) across long runs with earthquakes; the colony is
+survivable with sensible play.
+
+## NDW styling notes
+
+- Palette: phosphor amber `#ffb000` on abyssal black `#050505`; alert red
+ `#ff0033`; Crosslink cyan `#00ccff`.
+- Typography: monospace body, `Arial Black` headers with wide letter-spacing.
+- CRT scanlines + phosphor bloom overlay; hard edges, no border-radius.
+- Audio: 4-on-the-floor kick, off-beat hats, sawtooth bassline ~126 BPM.
diff --git a/game/ai.js b/game/ai.js
new file mode 100644
index 0000000..6063a75
--- /dev/null
+++ b/game/ai.js
@@ -0,0 +1,483 @@
+/* ===========================================================================
+ CONATIVE UTILITY AI — inmates score every possible action against their
+ Affective state (needs/emotions) and pick the highest-scoring directive.
+ Movement is grid path-following; interaction happens on arrival.
+ =========================================================================== */
+window.SOP = window.SOP || {};
+
+SOP.InmateAI = class InmateAI {
+ constructor(name, trait, x, y) {
+ this.name = name;
+ this.trait = trait;
+ // desynchronized metabolisms so the crew never all drop the cranks at once
+ this.hungerRate = 0.20 + Math.random() * 0.05;
+ this.affective = {
+ stress: 15 + Math.random() * 15,
+ paranoia: 5 + Math.random() * 15,
+ hunger: 30 + Math.random() * 35,
+ exhaustion: 5 + Math.random() * 20,
+ o2: 0,
+ };
+ this.hp = 100;
+ this.tx = x; this.ty = y; // tile position
+ this.px = x; this.py = y; // pixel-lerp position (float tiles)
+ this.path = [];
+ this.currentAction = { name: 'IDLE', score: 0 };
+ this.goal = null; // {kind:'device'|'tile', ...}
+ this.progress = 0;
+ this.dead = false;
+ this.deadCause = '';
+ this.sleeping = false;
+ this.nextEval = 0;
+ this.sayCooldown = 0;
+ this.thought = '—';
+ this.walkPhase = Math.random() * 6.28;
+ this.id = name;
+ }
+
+ /* ---------------- UTILITY EVALUATOR ---------------- */
+ evaluateDrives(world) {
+ if (this.dead) return;
+ const A = this.affective;
+ const cand = [];
+ const push = (name, score, goal) => { if (score > 0) cand.push({ name, score, goal }); };
+
+ // broken infrastructure survey (drives both repair and crank decisions)
+ const brokenAll = world.devices.filter(d => d.broken && d.kind !== 'gas_vent');
+ const gridBroken = brokenAll.some(d => this.onDispenserGrid(world, d));
+
+ // --- EAT ---
+ let eatScore = A.hunger > 70 ? A.hunger * 1.5 : A.hunger;
+ const dispenser = this.nearestDevice(world, d => d.kind === 'dispenser' && !d.broken && d.powered);
+ const dispenserAny = dispenser || this.nearestDevice(world, d => d.kind === 'dispenser' && !d.broken);
+ if (world.res.rationen <= 0 || !dispenser) eatScore = 0;
+ push('ESSEN FASSEN', eatScore, dispenser ? { kind: 'device', dev: dispenser, act: 'eat' } : null);
+
+ // --- SLEEP ---
+ let sleepScore = A.exhaustion > 75 ? A.exhaustion * 1.3 : A.exhaustion * 0.7;
+ const bed = this.nearestDevice(world, d => d.kind === 'bed' && !d.broken &&
+ !world.inmates.some(i => i !== this && !i.dead && i.goal && i.goal.dev === d && i.sleeping));
+ if (bed) push('SCHLAFEN', sleepScore, { kind: 'device', dev: bed, act: 'sleep' });
+ else if (A.exhaustion > 60) push('SCHLAFEN (BODEN)', sleepScore * 0.8, { kind: 'tile', x: this.tx, y: this.ty, act: 'sleep' });
+
+ // --- CRANK DYNAMO (sticky: hold the cranks until exhausted) ---
+ const p = world.power;
+ if (this.goal && this.goal.act === 'crank' && this.goal.dev &&
+ !this.goal.dev.broken && this.goal.dev.operatedBy === this.id &&
+ A.exhaustion < 85) {
+ push('KURBELN', 95, this.goal);
+ } else if (A.exhaustion < 80 || A.hunger > 85) {
+ // hunger > 85: desperate cranking — starvation overrides exhaustion
+ const dyn = this.nearestDevice(world, d => d.kind === 'dynamo' && !d.broken && d.operatedBy == null && d.compDeficit > 0);
+ if (dyn) {
+ let crankScore = 62 + Math.min(30, dyn.compDeficit * 0.4) - A.exhaustion * 0.4;
+ // a hungry inmate powers the dispenser before trying to eat —
+ // but if the food grid is broken, repairing beats cranking
+ if (dispenserAny && dispenserAny.compDeficit > 0 && !gridBroken) {
+ if (A.hunger > 85) crankScore += 120; // starving override — beats sleep
+ else if (A.hunger > 55) crankScore += 40;
+ }
+ push('KURBELN', crankScore, { kind: 'device', dev: dyn, act: 'crank' });
+ }
+ }
+
+ // --- DIG (Standard Operating Procedure) ---
+ let workScore = 72 - A.stress * 0.35 - A.exhaustion * 0.6;
+ if (this.trait === 'Befehlsfixiert') workScore += 25;
+ // Blackboard work directive: low stocks order everyone underground
+ if (world.res.oel < 100 || world.res.rationen < 60 || world.res.metall < 10) workScore += 35;
+ const mark = this.nearestDigMark(world);
+ if (mark) {
+ // dig momentum: a tile already being excavated gets finished
+ if (this.goal && this.goal.act === 'dig' && this.progress > 0) workScore += 40;
+ push('GRABEN', workScore, { kind: 'dig', x: mark.x, y: mark.y, act: 'dig' });
+ }
+
+ // --- REPAIR ---
+ // prioritize broken nodes on the food/power grid over cosmetic fixes
+ let broken = null;
+ if (brokenAll.length) {
+ const crit = brokenAll.filter(d => this.onDispenserGrid(world, d));
+ const pool = crit.length ? crit : brokenAll;
+ broken = pool.reduce((a, b) =>
+ (Math.abs(a.x - this.tx) + Math.abs(a.y - this.ty)) <= (Math.abs(b.x - this.tx) + Math.abs(b.y - this.ty)) ? a : b);
+ }
+ if (broken) {
+ let repairScore = 60 - A.exhaustion * 0.3;
+ if (this.onDispenserGrid(world, broken)) repairScore = 210; // must beat desperate cranking
+ push('REPARIEREN', repairScore, { kind: 'device', dev: broken, act: 'repair' });
+ }
+
+ // --- FLEE DARKNESS (Paranoia) — capped so hunger can still win ---
+ const here = world.tiles[this.ty][this.tx];
+ if (!here.lit && here.t === 'empty' && !this.sleeping) {
+ let flee = A.paranoia * 1.2;
+ if (this.trait === 'Paranoid') flee *= 1.6;
+ if (this.trait === 'Befehlsfixiert') flee *= 0.3;
+ flee = Math.min(flee, 115);
+ const lit = world.nearestLit(this.tx, this.ty);
+ if (lit) push('LICHT SUCHEN', flee, { kind: 'tile', x: lit.x, y: lit.y, act: 'flee' });
+ }
+
+ // --- AVOID GAS ---
+ if (here.gas > 12) {
+ const clear = this.nearestClearAir(world);
+ if (clear) push('GAS MEIDEN', 92 + here.gas * 0.1, { kind: 'tile', x: clear.x, y: clear.y, act: 'flee' });
+ }
+
+ // --- SABOTAGE / PSYCHOTIC BREAK (trait-specific conative override) ---
+ if (A.stress >= 85 && this.trait === 'Pyromane') {
+ push(`PSYCHOTISCHER SCHUB (${this.trait})`, 100, this.pickSabotageTarget(world));
+ }
+ if (A.stress >= 92 && this.trait === 'Paranoid') {
+ const lit = world.nearestLit(this.tx, this.ty);
+ if (lit) push('IN ECKE VERKRIECHEN', 96, { kind: 'tile', x: lit.x, y: lit.y, act: 'hide' });
+ }
+
+ // --- WANDER baseline ---
+ push('UMHERIRREN', 25, this.randomWanderGoal(world));
+
+ let best = cand[0] || { name: 'IDLE', score: 0, goal: null };
+ for (const c of cand) if (c.score > best.score) best = c;
+
+ // commit
+ if (best.name !== this.currentAction.name || !this.goal) {
+ this.currentAction = { name: best.name, score: best.score };
+ this.goal = best.goal;
+ this.sleeping = false;
+ this.progress = 0;
+ this.path = [];
+ this.waitTicks = 0;
+ this.thought = this.thoughtFor(best.name);
+ }
+ this.logConativeState(best);
+ }
+
+ /* Is this device on the same wired component as any dispenser? */
+ onDispenserGrid(world, dev) {
+ const starts = world.devices.filter(d => d.kind === 'dispenser');
+ if (!starts.length) return false;
+ const seen = new Set(starts.map(d => d.id));
+ const q = [...starts];
+ while (q.length) {
+ const d = q.pop();
+ for (const id of d.links) {
+ if (seen.has(id)) continue;
+ seen.add(id);
+ const o = world.devices.find(x => x.id === id);
+ if (o) q.push(o);
+ }
+ }
+ return seen.has(dev.id);
+ }
+
+ pickSabotageTarget(world) {
+ const linked = world.devices.filter(d => d.links.length > 0 && d.kind !== 'gas_vent');
+ if (!linked.length) return null;
+ const d = linked[Math.floor(Math.random() * linked.length)];
+ return { kind: 'device', dev: d, act: 'sabotage' };
+ }
+
+ randomWanderGoal(world) {
+ for (let tries = 0; tries < 20; tries++) {
+ const x = Math.floor(Math.random() * world.W);
+ const y = Math.floor(Math.random() * world.H);
+ if (world.walkable(x, y)) return { kind: 'tile', x, y, act: 'wander' };
+ }
+ return null;
+ }
+
+ nearestDevice(world, pred) {
+ let best = null, bd = Infinity;
+ for (const d of world.devices) {
+ if (!pred(d)) continue;
+ const dist = Math.abs(d.x - this.tx) + Math.abs(d.y - this.ty);
+ if (dist < bd) { bd = dist; best = d; }
+ }
+ return best;
+ }
+
+ nearestDigMark(world) {
+ const taken = new Set();
+ for (const o of world.inmates) {
+ if (o !== this && !o.dead && o.goal && o.goal.act === 'dig') taken.add(o.goal.x + ',' + o.goal.y);
+ }
+ let best = null, bd = Infinity, bestTaken = null, bdt = Infinity;
+ for (const m of world.Blackboard.digMarks) {
+ if (world.tiles[m.y][m.x].t !== 'dirt') continue;
+ // must be reachable: at least one adjacent walkable tile
+ const reach = [[1,0],[-1,0],[0,1],[0,-1]].some(([dx, dy]) => world.walkable(m.x + dx, m.y + dy));
+ if (!reach) continue;
+ const dist = Math.abs(m.x - this.tx) + Math.abs(m.y - this.ty);
+ if (taken.has(m.x + ',' + m.y)) {
+ if (dist < bdt) { bdt = dist; bestTaken = m; }
+ } else if (dist < bd) { bd = dist; best = m; }
+ }
+ return best || bestTaken;
+ }
+
+ nearestClearAir(world) {
+ let best = null, bd = Infinity;
+ for (let y = 0; y < world.H; y++) for (let x = 0; x < world.W; x++) {
+ const tl = world.tiles[y][x];
+ if (tl.t !== 'empty' || tl.gas > 10 || tl.o2 < 30) continue;
+ const d = Math.abs(x - this.tx) + Math.abs(y - this.ty);
+ if (d < bd) { bd = d; best = { x, y }; }
+ }
+ return best;
+ }
+
+ thoughtFor(action) {
+ const T = {
+ 'ESSEN FASSEN': 'Ausgabe. Jetzt.',
+ 'SCHLAFEN': 'Die Pritsche ruft.',
+ 'SCHLAFEN (BODEN)': 'Boden genügt. Boden ist sicher.',
+ 'KURBELN': 'Strom durch Muskel. SOP.',
+ 'GRABEN': 'Die Erde gibt nicht freiwillig.',
+ 'REPARIEREN': 'Es knackt. Es muss ganz.',
+ 'LICHT SUCHEN': 'Nicht im Dunkeln. Nie wieder dunkel.',
+ 'GAS MEIDEN': 'Es schmeckt nach Kupfer.',
+ 'IN ECKE VERKRIECHEN': 'Wände beobachten.',
+ 'UMHERIRREN': 'Schritte zählen hilft.',
+ 'EXPEDITION': 'Raus. Nur kurz. Nur mit Maske.',
+ 'IDLE': '—',
+ };
+ return T[action] || '—';
+ }
+
+ releaseCrank(world) {
+ for (const d of world.devices) if (d.operatedBy === this.id) d.operatedBy = null;
+ }
+
+ /* ---------------- PER-TICK EXECUTION ---------------- */
+ tick(world, onEvent) {
+ if (this.dead) return;
+ // dynamo ownership sanity: a cranker who switched goals frees the cranks
+ if (!this.goal || this.goal.act !== 'crank') this.releaseCrank(world);
+ const A = this.affective;
+ const tl = world.tiles[this.ty][this.tx];
+
+ // ---- affective drift ----
+ A.hunger = Math.min(100, A.hunger + this.hungerRate);
+ if (!this.sleeping) A.exhaustion = Math.min(100, A.exhaustion + 0.18);
+ if (!tl.lit && tl.t === 'empty' && !this.sleeping) {
+ A.stress = Math.min(100, A.stress + 0.15);
+ A.paranoia = Math.min(100, A.paranoia + (this.trait === 'Paranoid' ? 0.5 : 0.22));
+ } else {
+ A.paranoia = Math.max(0, A.paranoia - 0.35);
+ A.stress = Math.max(0, A.stress - 0.15);
+ }
+ // breathing
+ if (tl.o2 < 14 || tl.gas > 12) {
+ A.o2 = Math.min(100, A.o2 + (tl.gas > 12 ? 2.4 : 1.1));
+ } else {
+ A.o2 = Math.max(0, A.o2 - 1.4);
+ }
+ if (A.o2 >= 100) { this.hp -= 2.5; if (this.hp <= 0) return this.die('ERSTICKT'); }
+ if (A.hunger >= 100) { this.hp -= 0.8; if (this.hp <= 0) return this.die('AUSGEZEHRT'); }
+
+ // ---- sleep is its own loop (recovery happens HERE, not in execute) ----
+ if (this.sleeping) {
+ const bed = this.goal && this.goal.dev && this.goal.dev.kind === 'bed' ? this.goal.dev : null;
+ A.exhaustion = Math.max(0, A.exhaustion - (bed ? 1.5 : 0.9));
+ A.stress = Math.max(0, A.stress - 0.3);
+ if (A.exhaustion <= 3 || A.o2 > 60 || tl.gas > 12 || A.hunger >= 85) {
+ this.sleeping = false;
+ this.goal = null;
+ }
+ if (this.sayCooldown > 0) this.sayCooldown--;
+ return;
+ }
+
+ // ---- movement along path (one tile every other tick) ----
+ this.moveGate = !this.moveGate;
+ if (this.moveGate && this.path.length && !this.executingHere) {
+ const [nx, ny] = this.path[0];
+ if (world.walkable(nx, ny) || (this.path.length === 1 && this.isGoalTile(nx, ny))) {
+ this.tx = nx; this.ty = ny;
+ this.path.shift();
+ this.walkPhase += 1;
+ } else {
+ this.repath(world);
+ }
+ }
+
+ // ---- goal arrival / execution ----
+ if (this.goal) this.execute(world, onEvent);
+
+ this.executingHere = false;
+ if (this.sayCooldown > 0) this.sayCooldown--;
+ }
+
+ isGoalTile(x, y) {
+ const g = this.goal;
+ if (!g) return false;
+ // fleeing to light/gas-free air only counts ON the target tile
+ if ((g.act === 'flee' || g.act === 'hide') && g.kind === 'tile') return g.x === x && g.y === y;
+ if (g.kind === 'tile' || g.kind === 'dig') return (Math.abs(g.x - x) + Math.abs(g.y - y)) <= 1;
+ if (g.kind === 'device') return (Math.abs(g.dev.x - x) + Math.abs(g.dev.y - y)) <= 1;
+ return false;
+ }
+
+ repath(world) {
+ const g = this.goal;
+ if (!g) { this.path = []; return; }
+ let tx, ty;
+ if (g.kind === 'tile') { tx = g.x; ty = g.y; }
+ else if (g.kind === 'dig') {
+ const spot = this.adjacentStand(world, g.x, g.y);
+ if (!spot) { this.goal = null; return; }
+ tx = spot.x; ty = spot.y;
+ } else {
+ // stand adjacent to the device, not on top of it
+ const spot = this.adjacentStand(world, g.dev.x, g.dev.y);
+ if (!spot) { this.goal = null; return; }
+ tx = spot.x; ty = spot.y;
+ }
+ const p = world.findPath(this.tx, this.ty, tx, ty);
+ this.path = p || [];
+ if (!p) this.goal = null; // unreachable — re-evaluate next round
+ }
+
+ adjacentStand(world, x, y) {
+ for (const [dx, dy] of [[1,0],[-1,0],[0,1],[0,-1]]) {
+ if (world.walkable(x + dx, y + dy)) return { x: x + dx, y: y + dy };
+ }
+ return null;
+ }
+
+ execute(world, onEvent) {
+ const g = this.goal;
+ if (!g) return;
+
+ // en route?
+ if (g.kind === 'tile' && !this.isGoalTile(this.tx, this.ty)) {
+ if (!this.path.length) this.repath(world);
+ return;
+ }
+ if (g.kind === 'device' && !this.isGoalTile(this.tx, this.ty)) {
+ if (!this.path.length) this.repath(world);
+ return;
+ }
+ if (g.kind === 'dig' && !this.isGoalTile(this.tx, this.ty)) {
+ if (!this.path.length) this.repath(world);
+ return;
+ }
+
+ this.executingHere = true;
+ const A = this.affective;
+
+ switch (g.act) {
+ case 'eat': {
+ if (world.res.rationen <= 0 || g.dev.broken) { this.goal = null; return; }
+ if (!g.dev.powered) {
+ // stand at the Ausgabe and wait for the grid (someone is cranking…)
+ this.waitTicks = (this.waitTicks || 0) + 1;
+ if (this.waitTicks > 40) { this.waitTicks = 0; this.goal = null; }
+ return;
+ }
+ this.waitTicks = 0;
+ world.res.rationen--;
+ A.hunger = Math.max(0, A.hunger - 45);
+ A.stress = Math.max(0, A.stress - 4);
+ onEvent({ type: 'meal', inmate: this });
+ this.goal = null;
+ break;
+ }
+ case 'sleep': {
+ // the sleep loop itself lives in tick(); getting here just commits
+ this.sleeping = true;
+ break;
+ }
+ case 'crank': {
+ if (!g.dev || g.dev.broken) { this.goal = null; return; }
+ if (g.dev.operatedBy != null && g.dev.operatedBy !== this.id) { this.goal = null; return; }
+ g.dev.operatedBy = this.id;
+ A.exhaustion = Math.min(100, A.exhaustion + 0.35);
+ A.hunger = Math.min(100, A.hunger + 0.10);
+ A.stress = Math.min(100, A.stress + 0.05);
+ if (A.exhaustion > 85) { g.dev.operatedBy = null; this.goal = null; }
+ break;
+ }
+ case 'dig': {
+ if (world.tiles[g.y][g.x].t !== 'dirt') { world.Blackboard.removeDigMark(g.x, g.y); this.goal = null; return; }
+ this.progress++;
+ A.stress = Math.min(100, A.stress + 0.10);
+ A.exhaustion = Math.min(100, A.exhaustion + 0.15);
+ if (this.progress >= SOP.DIG_TICKS) {
+ const ev = world.completeDig(g.x, g.y, this);
+ if (ev && ev.type === 'gas') onEvent({ type: 'gasburst', x: g.x, y: g.y });
+ if (ev && ev.type === 'cache') onEvent({ type: 'cache', inmate: this, label: ev.label, n: ev.n, res: ev.res });
+ this.progress = 0;
+ this.goal = null;
+ }
+ break;
+ }
+ case 'repair': {
+ if (!g.dev || !g.dev.broken) { this.goal = null; return; }
+ this.progress++;
+ if (this.progress >= 6) { g.dev.broken = false; this.progress = 0; onEvent({ type: 'repair', dev: g.dev, inmate: this }); this.goal = null; }
+ break;
+ }
+ case 'sabotage': {
+ if (!g.dev || g.dev.links.length === 0) { this.goal = null; A.stress = Math.max(0, A.stress - 25); return; }
+ const other = world.devices.find(d => d.id === g.dev.links[0]);
+ if (other) {
+ world.removeLink(g.dev, other);
+ onEvent({ type: 'sabotage', inmate: this, dev: g.dev });
+ }
+ A.stress = Math.max(0, A.stress - 30);
+ this.goal = null;
+ break;
+ }
+ case 'flee':
+ case 'hide':
+ case 'wander': {
+ this.goal = null; // arrived; next evaluation picks something new
+ break;
+ }
+ case 'expedition': {
+ // reached the airlock — hand control back to the Schichtleitung
+ onEvent({ type: 'board', inmate: this, dev: g.dev });
+ this.goal = null;
+ break;
+ }
+ }
+ }
+
+ die(cause) {
+ this.dead = true;
+ this.deadCause = cause;
+ this.sleeping = false;
+ // release any device I operate
+ for (const d of SOP.World.devices) if (d.operatedBy === this.id) d.operatedBy = null;
+ }
+
+ /* ---------------- SAVE / LOAD ---------------- */
+ serialize() {
+ return {
+ id: this.id, name: this.name, trait: this.trait,
+ tx: this.tx, ty: this.ty, hp: Math.round(this.hp),
+ hungerRate: this.hungerRate,
+ affective: Object.assign({}, this.affective),
+ dead: this.dead, deadCause: this.deadCause,
+ away: this.away ? Object.assign({}, this.away) : null,
+ };
+ }
+
+ static fromData(d) {
+ const i = new SOP.InmateAI(d.name, d.trait, d.tx, d.ty);
+ i.id = d.id || d.name;
+ Object.assign(i.affective, d.affective);
+ i.hp = d.hp;
+ i.hungerRate = d.hungerRate || i.hungerRate;
+ i.dead = !!d.dead;
+ i.deadCause = d.deadCause || '';
+ i.away = d.away || null;
+ return i;
+ }
+
+ logConativeState(action) {
+ this.lastScored = action;
+ }
+};
diff --git a/game/audio.js b/game/audio.js
new file mode 100644
index 0000000..1636ebd
--- /dev/null
+++ b/game/audio.js
@@ -0,0 +1,105 @@
+/* Standard Operating Psychopathy — audio.
+ Minimal cold-wave sequencer: motorik kick, dry hat, steely bass.
+ Starts only after a user gesture. Toggle with [M]. */
+window.SOP = window.SOP || {};
+
+SOP.Audio = (() => {
+ let ctx = null, master = null, running = false, nextNote = 0, step = 0;
+ const BPM = 126, LOOKAHEAD = 0.12, INTERVAL = 40;
+ let timer = null;
+
+ /* A minor, one cold riff: A1 A1 E2 A1 / C2 A1 G1 A1, straight 16ths. */
+ const BASS = [55, 55, 82.4, 55, 65.4, 55, 49, 55, 55, 55, 82.4, 55, 65.4, 98, 82.4, 55];
+ const HAT_PATTERN = [0,0,1,0, 0,0,1,0, 0,0,1,0, 0,0,1,1];
+
+ /** Create the audio context and master gain once, if Web Audio is available. */
+ function init() {
+ if (ctx) return;
+ const AC = window.AudioContext || window.webkitAudioContext;
+ if (!AC) return;
+ ctx = new AC();
+ master = ctx.createGain();
+ master.gain.value = 0.5;
+ master.connect(ctx.destination);
+ }
+
+ /** Schedule a short sine-wave kick at audio-context time t (seconds). */
+ function kick(t) {
+ const o = ctx.createOscillator(), g = ctx.createGain();
+ o.type = 'sine';
+ o.frequency.setValueAtTime(120, t);
+ o.frequency.exponentialRampToValueAtTime(40, t + 0.09);
+ g.gain.setValueAtTime(0.55, t);
+ g.gain.exponentialRampToValueAtTime(0.001, t + 0.12);
+ o.connect(g); g.connect(master);
+ o.start(t); o.stop(t + 0.13);
+ }
+
+ /** Schedule a high-pass noise hi-hat at audio-context time t (seconds). */
+ function hat(t) {
+ const len = 0.03;
+ const buf = ctx.createBuffer(1, ctx.sampleRate * len, ctx.sampleRate);
+ const d = buf.getChannelData(0);
+ for (let i = 0; i < d.length; i++) d[i] = (Math.random() * 2 - 1) * (1 - i / d.length);
+ const s = ctx.createBufferSource(); s.buffer = buf;
+ const f = ctx.createBiquadFilter(); f.type = 'highpass'; f.frequency.value = 6000;
+ const g = ctx.createGain(); g.gain.value = 0.08;
+ s.connect(f); f.connect(g); g.connect(master);
+ s.start(t);
+ }
+
+ /** Schedule a sawtooth bass note at time t (seconds) and frequency freq (Hz). */
+ function bass(t, freq) {
+ const o = ctx.createOscillator(), g = ctx.createGain(), f = ctx.createBiquadFilter();
+ o.type = 'sawtooth'; o.frequency.value = freq;
+ f.type = 'lowpass'; f.frequency.setValueAtTime(900, t);
+ f.frequency.exponentialRampToValueAtTime(180, t + 0.14);
+ g.gain.setValueAtTime(0.16, t);
+ g.gain.exponentialRampToValueAtTime(0.001, t + 0.16);
+ o.connect(f); f.connect(g); g.connect(master);
+ o.start(t); o.stop(t + 0.18);
+ }
+
+ /** Queue sixteenth-note steps through the audio lookahead window. */
+ function schedule() {
+ while (nextNote < ctx.currentTime + LOOKAHEAD) {
+ const s16 = step % 16;
+ if (s16 % 4 === 0) kick(nextNote);
+ if (HAT_PATTERN[s16]) hat(nextNote);
+ bass(nextNote, BASS[s16]);
+ nextNote += (60 / BPM) / 4;
+ step++;
+ }
+ }
+
+ /** Start or stop the sequencer; return whether playback is running. */
+ function toggle() {
+ init();
+ if (!ctx) return false;
+ if (running) {
+ clearInterval(timer); running = false;
+ } else {
+ if (ctx.state === 'suspended') ctx.resume();
+ nextNote = ctx.currentTime + 0.05; step = 0;
+ timer = setInterval(schedule, INTERVAL);
+ running = true;
+ }
+ return running;
+ }
+
+ /** Play a one-shot alert tone only while the sequencer is running. */
+ function alarm() {
+ if (!ctx || !running) return;
+ const t = ctx.currentTime;
+ const o = ctx.createOscillator(), g = ctx.createGain();
+ o.type = 'square'; o.frequency.value = 440;
+ o.frequency.setValueAtTime(440, t);
+ o.frequency.setValueAtTime(330, t + 0.12);
+ g.gain.setValueAtTime(0.12, t);
+ g.gain.exponentialRampToValueAtTime(0.001, t + 0.3);
+ o.connect(g); g.connect(master);
+ o.start(t); o.stop(t + 0.32);
+ }
+
+ return { toggle, alarm, get on() { return running; } };
+})();
diff --git a/game/config.js b/game/config.js
new file mode 100644
index 0000000..c77ec94
--- /dev/null
+++ b/game/config.js
@@ -0,0 +1,107 @@
+/* Standard Operating Psychopathy — configuration & static data. */
+window.SOP = window.SOP || {};
+
+SOP.TILE = 26; // pixel size of one tile (base)
+SOP.TICK_MS = 250; // simulation tick
+SOP.EVAL_MS = 1000; // utility re-evaluation interval
+SOP.DAY_TICKS = 240; // ticks per TAG
+SOP.START_DAY = 3689; // days since surface collapse
+
+SOP.GRID_W = 34;
+SOP.GRID_H = 22;
+SOP.DIG_TOP = 5; // rows 0..4 stay bedrock
+SOP.LINK_RANGE = 8; // max wire length between nodes (tiles)
+
+SOP.RES = { beton: 220, metall: 80, rationen: 110, oel: 220 };
+
+SOP.MAX_POWER = 600;
+SOP.MAX_O2 = 250;
+
+SOP.NEEDS = ['stress', 'hunger', 'exhaustion', 'paranoia', 'o2'];
+
+/* Object definitions. watts>0 = consumer, watts<0 = generator. */
+SOP.OBJ = {
+ dynamo: { label: 'TRETBAR-DYNAMO', watts: -60, icon: '◉', hotkey: '1', cost: { metall: 12 },
+ hint: 'Handkurbel. −60 W solange ein Subjekt kurbelt.' },
+ lamp: { label: 'LAMPE', watts: 12, icon: '✶', hotkey: '2', cost: { metall: 4 },
+ hint: 'Beleuchtet Radius 4. Gegen Dunkel-Panik. 12 W.' },
+ bed: { label: 'PRITSCHE', watts: 0, icon: '▭', hotkey: '3', cost: { metall: 4, beton: 2 },
+ hint: 'Schlafplatz. Baut Erschöpfung ab.' },
+ dispenser: { label: 'RATIONEN-AUSGABE', watts: 5, icon: '▦', hotkey: '4', cost: { metall: 8 },
+ hint: 'Gibt 1 RATION pro Mahlzeit aus. Braucht Strom.' },
+ scrubber: { label: 'LUFT-WÄSCHER', watts: 25, icon: '≋', hotkey: '5', cost: { metall: 10, beton: 4 },
+ hint: 'Zieht Giftgas ab, gibt O₂ aus. 25 W.' },
+ generator: { label: 'NOTSTROMAGGREGAT', watts: -100, icon: '▣', hotkey: '6', cost: { metall: 20 },
+ hint: '−100 W. Verbrennt 1 ÖL alle 35 s. Öl kommt aus dem Erdreich.' },
+ door: { label: 'SCHOTT', watts: 10, icon: '╫', hotkey: '7', cost: { metall: 8, beton: 2 },
+ hint: 'Blockiert Weg, solange stromlos. Sensor kann es koppeln.' },
+ battery: { label: 'AKKU-BLOCK', watts: 0, icon: '▮', hotkey: '9', cost: { metall: 14 },
+ hint: 'Speichert Überschuss (2000), deckt Spitzen. Gegen Flackerlicht.' },
+ farm: { label: 'PILZFARM', watts: 15, icon: '✿', hotkey: '0', cost: { beton: 6, metall: 6 },
+ hint: 'Züchtet Rationen aus der Wandfeuchte. +1 RATION pro 30 s Strom.' },
+ airlock: { label: 'LUFTSCHLEUSE', watts: 0, icon: '⌂', hotkey: 'q', cost: { metall: 15, beton: 10 },
+ hint: 'Durchbruch zur Oberfläche. Startpunkt für Expeditionen & Neuzugänge. Nur an der Decke.' },
+ radio: { label: 'FUNKTURM', watts: 30, icon: '⌁', hotkey: 'f', cost: { metall: 18 },
+ hint: 'Sendet auf allen Bändern. Verdoppelt die Rate der Neuzugänge. 30 W.' },
+ sensor: { label: 'BEWEGUNGSSENSOR', watts: 5, icon: '◎', hotkey: '8', cost: { metall: 6 },
+ hint: 'Meldet Subjekte im Radius 2. Koppelbar an Schott.' },
+ gas_vent: { label: 'GAS-SCHLOT', watts: 0, icon: '▲', hotkey: '', cost: {},
+ hint: 'Leckt Giftgas. Einmauern oder waschen.' },
+};
+SOP.WALL_COST = { beton: 4 };
+SOP.BUILDABLE = ['dynamo', 'lamp', 'bed', 'dispenser', 'scrubber', 'generator', 'door', 'sensor', 'battery', 'farm', 'airlock', 'radio'];
+SOP.BATTERY_CAP = 2000;
+SOP.FARM_TICKS = 120; // powered ticks per ration grown
+
+/* Colony growth & surface operations. */
+SOP.MAX_INMATES = 6;
+SOP.EXPEDITION_TICKS = [500, 800]; // duration range while outside
+SOP.EXPEDITION_INJURY_CHANCE = 0.18;
+SOP.ARRIVAL_BASE = [2600, 3800]; // ticks until a newcomer (no radio)
+SOP.ARRIVAL_RADIO = [1300, 1900]; // ... with a powered Funkturm
+SOP.LOOT = [
+ { res: 'oel', n: [6, 14], label: 'ÖL-FÄSSER', weight: 30 },
+ { res: 'rationen', n: [5, 10], label: 'KONSERVEN', weight: 30 },
+ { res: 'metall', n: [6, 12], label: 'SCHROTT', weight: 22 },
+ { res: 'beton', n: [8, 16], label: 'TRÜMMERSTEINE', weight: 18 },
+];
+
+/* Digging outcomes. */
+SOP.DIG_TICKS = 4;
+SOP.DIG_CACHE_CHANCE = 0.30;
+SOP.DIG_GAS_CHANCE = 0.12;
+SOP.CACHES = [
+ { res: 'rationen', n: [3, 7], label: 'RATIONEN-DEPOT', weight: 35 },
+ { res: 'oel', n: [7, 12], label: 'ÖL-FLASCH', weight: 28 },
+ { res: 'metall', n: [4, 9], label: 'METALL-CACHE', weight: 22 },
+ { res: 'beton', n: [5, 12], label: 'BETON-CACHE', weight: 18 },
+];
+
+SOP.NAMES = [
+ 'SUBJEKT-402','SUBJEKT-117','SUBJEKT-774','SUBJEKT-033','SUBJEKT-666',
+ 'SUBJEKT-291','SUBJEKT-508','SUBJEKT-815','SUBJEKT-149','SUBJEKT-904',
+];
+
+SOP.TRAITS = {
+ Pyromane: 'Leitet bei Stress Kurzschlüsse ein.',
+ Paranoid: 'Panik in Dunkelheit. Hoher Argwohn.',
+ Befehlsfixiert: 'Arbeitet stur weiter. Ignoriert Warnlampen.',
+ Schlafwandler: 'Wandert nachts. Pennt überall.',
+};
+
+SOP.QUAKE_NAMES = ['ERDBEBEN 1', 'ERDBEBEN 2', 'DER MUSSOLINI', 'GOLDENES SPIELZEUG', 'KALTES KLARWASSER', 'MAIKÄFER FLIEG'];
+
+SOP.TICKER_LINES = [
+ 'JEDER ATEMZUG WIRD REGISTRIERT',
+ 'VERLASS DEINEN SEKTOR NICHT',
+ 'DER MUSSOLINI DREHT SICH',
+ 'KALTES KLARWASSER IST KEIN SPIEL',
+ 'GOLDENES SPIELZEUG WIRD KONFISZIERT',
+ 'ARBEIT MACHT ATEM',
+ 'GEBORGENHEIT IST PFLICHT',
+ 'HALTE DEIN SCHOTT GESCHLOSSEN',
+ 'DIE OBERFLÄCHE IST KEIN ORT MEHR',
+ 'EIN NEUES DEUTSCHES WUNDER: DIE WÄSCHER',
+ 'ANGST IST ENERGIE. SPAREN SIE DAMIT',
+ 'WIR WOLLEN WOLLEN. SIE WOLLEN AUCH',
+];
diff --git a/game/index.html b/game/index.html
new file mode 100644
index 0000000..68a1731
--- /dev/null
+++ b/game/index.html
@@ -0,0 +1,136 @@
+
+
+
+
+ Standard Operating Psychopathy — Sektor 4
+
+
+
+
+
+
+
Standard Operating Psychopathy
+
Sektor 4 // Bunker-Überwachung // Monitor 07-B
+
+
+
Tag —
+
Netz —
+
Luft —
+
Vorrat —
+
Subjekte 0
+
+
+ Ansicht:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Systemstatus
+
Stromnetz
+
+ Detailwerte im Kopfbalken. Defizit = Verbraucher dunkel.
+
+
+
+
+
Aktenverwaltung
+
+
+
+
+
+
+
+
+ Autosicherung alle 5 Minuten. Export = Datei-Download.
+
+
+
+
+
Bauhof
+
+
+
+
+
+
Subjekt-Inspektor
+
Subjekt im Raster anklicken, um affektive und konative Ströme zu überwachen.
+
+
+
+
Knoten-Inspektor
+
Nur im CROSSLINK-Modus.
+
+
+
+
Ereignisprotokoll
+
+
+
+
+
+
+
◤ DURCHSAGE ◢
+
+
+
+
+
+
+
Standard Operating Psychopathy
+
Sektor 4 — Handbuch für Schichtleiter
+
Die Oberfläche ist erledigt. Sie überwachen einen Bunker mit drei Subjekten.
+ Die Subjekte bewerten ihre Bedürfnisse selbst und handeln danach — Ihre Aufgabe
+ ist das Netz: Strom legen, Luft waschen, Grabungsaufträge erteilen, Schotten schalten.
+ Eine Luftschleuse in der Decke öffnet den Weg nach oben: Expeditionen holen
+ Öl und Konserven, neue Subjekte finden den Sektor. Der Funkturm ruft sie schneller.
+ Ihre Akte wird gesichert — lokal und als Datei.
+
+ 1–8, 9, 0 Module bauen · W Wand · X Grabungsauftrag · ESC Abbruch
+ V Physisch ↔ Crosslink · LEER Pause · M Ton · F5 Sichern
+ Crosslink: zwei Knoten anklicken = Leitung (max. 8 Felder).
+ Sensor + Schott koppeln: Schott öffnet bei Bewegung.
+ Notstromaggregat verbrennt ÖL — Öl liegt im Erdreich. Graben hält das Netz am Leben.
+ Luftschleuse (Q) an die Decke setzen: Expeditionen zur Oberfläche (Beute!)
+ und Neuzugänge für den Sektor. Der Funkturm beschleunigt die Ankunft neuer Subjekte.
+
+
WARNUNG: Hoher Stress führt bei geeigneten Profilen zu Kurzschlüssen im wahrsten Sinne.
+
+ JEDER ATEMZUG WIRD REGISTRIERT
+
+
+
+
+
+
+
+
+
Akte geschlossen
+
Alle Subjekte ausgefallen — Sektor 4 stillgelegt
+
+
+ DIE OBERFLÄCHE IST KEIN ORT MEHR
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/game/main.js b/game/main.js
new file mode 100644
index 0000000..f8f2188
--- /dev/null
+++ b/game/main.js
@@ -0,0 +1,600 @@
+/* ===========================================================================
+ MAIN — orchestration: game loop, input, events, day cycle, save/load,
+ surface expeditions, and colony growth.
+ =========================================================================== */
+window.SOP = window.SOP || {};
+
+SOP.Main = (() => {
+ const world = SOP.World;
+ const UI = SOP.UI;
+ const R = SOP.Render;
+
+ const SAVE_KEY = 'sop-sektor4-akte';
+
+ let ticks = 0;
+ let started = false, paused = false, gameOver = false;
+ let simInterval = null;
+ let state = {
+ selected: null, // selected inmate
+ selDevice: null, // selected device (crosslink)
+ buildKind: null, // 'wall' | object kind | 'dig' | null
+ linkFrom: null, // device id while wiring
+ ghost: null, // {x, y, kind}
+ };
+ let nextQuakeTick = 260;
+ let nextArrivalTick = 2200;
+ let stats = { caches: 0, meals: 0, repairs: 0, sabotages: 0, quakes: 0, expeditions: 0, arrivals: 0 };
+
+ /** Return the in-game calendar day derived from elapsed simulation ticks. */
+ function day() { return SOP.START_DAY + Math.floor(ticks / SOP.DAY_TICKS); }
+
+ /* ---------------- SETUP ---------------- */
+ /** Generate the starting colony, bind controls, and start rendering the intro. */
+ function setup() {
+ world.generate();
+
+ // the cast
+ const traits = ['Pyromane', 'Paranoid', 'Befehlsfixiert'];
+ const spots = [[7, 9], [10, 8], [13, 11]];
+ const pool = SOP.NAMES.filter(n => n !== 'SUBJEKT-402').sort(() => Math.random() - 0.5);
+ const inmates = spots.map((s, i) =>
+ new SOP.InmateAI(i === 0 ? 'SUBJEKT-402' : pool[i - 1], traits[i], s[0], s[1]));
+ world.inmates = inmates;
+
+ UI.initBuildMenu(kind => { state.buildKind = kind; state.linkFrom = null; });
+ UI.setTicker();
+ UI.log('SCHICHT ERÖFFNET. DREI SUBJEKTE REGISTRIERT.', 'ok');
+ UI.log('AUFTRAGSLAGE: GRABUNG LÄUFT. STROM HANDGEMACHT.', 'dim');
+
+ bindInput();
+ UI.showIntro(() => {
+ beginShift();
+ UI.log('DURCHSAGE: DIE SCHICHT BEGINNT.', 'ok');
+ });
+
+ requestAnimationFrame(frame);
+ }
+
+ /** Start the shift and toggle audio; opts.interval=false suppresses the tick timer. */
+ function beginShift(opts) {
+ started = true;
+ if (SOP.Audio && SOP.Audio.toggle) SOP.Audio.toggle(); // motorik loop (user gesture)
+ if (!opts || opts.interval !== false) {
+ if (!simInterval) simInterval = setInterval(simTick, SOP.TICK_MS);
+ }
+ }
+
+ /* ---------------- SIMULATION TICK ---------------- */
+ /** Advance an active, unpaused shift by one tick, processing events and autosave. */
+ function simTick() {
+ if (!started || paused || gameOver) return;
+ ticks++;
+
+ world.tick(handleWorldEvent);
+
+ // expedition returns
+ for (const inm of world.inmates) {
+ if (!inm.dead && inm.away && ticks >= inm.away.returnTick) returnFromExpedition(inm);
+ }
+
+ for (const inm of world.inmates) {
+ if (inm.dead || inm.away) continue;
+ // boarding failsafe: path impossible → abandon the expedition
+ if (inm.boarding && !inm.goal) {
+ inm.boarding = false;
+ UI.log('EXPEDITION ABGEBROCHEN: SCHLEUSE NICHT ERREICHBAR.', 'alert');
+ continue;
+ }
+ if (ticks % 4 === 0 && !inm.boarding) inm.evaluateDrives(world); // 4 ticks = 1 s
+ inm.tick(world, handleInmateEvent);
+ }
+
+ // newcomer at the airlock
+ if (ticks >= nextArrivalTick) {
+ const arrived = tryArrival();
+ if (arrived) {
+ scheduleNextArrival();
+ } else {
+ // stand blocked or colony full — peek again soon
+ const full = world.inmates.filter(i => !i.dead).length >= SOP.MAX_INMATES;
+ nextArrivalTick = ticks + (full ? 2400 : 120 + Math.floor(Math.random() * 180));
+ }
+ }
+
+ // random seismic event
+ if (ticks >= nextQuakeTick) {
+ quake();
+ nextQuakeTick = ticks + 380 + Math.floor(Math.random() * 260);
+ }
+
+ // autosave every ~5 minutes of sim time
+ if (ticks % 1200 === 0 && !gameOver) saveGame(true);
+
+ // game over check
+ if (world.inmates.every(i => i.dead)) endGame();
+ }
+
+ /** Log generator fuel consumption and farm harvest events from the world. */
+ function handleWorldEvent(ev) {
+ if (ev.type === 'burn') UI.log('NOTSTROMAGGREGAT VERFEUERT 1 ÖL.', 'dim');
+ if (ev.type === 'harvest') UI.log('PILZFARM: 1 RATION GEERNTET.', 'dim');
+ }
+
+ /** Apply inmate events to statistics, alerts, stress, and expedition boarding. */
+ function handleInmateEvent(ev) {
+ switch (ev.type) {
+ case 'meal':
+ stats.meals++;
+ break;
+ case 'cache':
+ stats.caches++;
+ UI.log(`${ev.inmate.name} BIRGT ${ev.label} (+${ev.n})`, 'ok');
+ break;
+ case 'gasburst':
+ UI.alert(`GAS-SCHLOT FREIGELEGT BEI ${ev.x}/${ev.y}. LUFT WASCHEN ODER MAUERN.`);
+ R.shake(400);
+ world.inmates.forEach(i => { if (!i.dead && !i.away) { i.affective.stress = Math.min(100, i.affective.stress + 8); i.affective.paranoia = Math.min(100, i.affective.paranoia + 10); } });
+ break;
+ case 'sabotage':
+ stats.sabotages++;
+ UI.alert(`${ev.inmate.name}: PSYCHOTISCHER SCHUB. LEITUNG GEKAPPT (${SOP.OBJ[ev.dev.kind].label}).`);
+ R.shake(300);
+ world.inmates.forEach(i => { if (!i.dead && !i.away && i !== ev.inmate) i.affective.stress = Math.min(100, i.affective.stress + 12); });
+ break;
+ case 'repair':
+ stats.repairs++;
+ UI.log(`${ev.inmate.name} REPARIERT ${SOP.OBJ[ev.dev.kind].label}.`, 'ok');
+ break;
+ case 'board': {
+ const inm = ev.inmate;
+ inm.boarding = false;
+ inm.goal = null;
+ inm.path = [];
+ const dur = SOP.EXPEDITION_TICKS[0] +
+ Math.floor(Math.random() * (SOP.EXPEDITION_TICKS[1] - SOP.EXPEDITION_TICKS[0]));
+ inm.away = { returnTick: ticks + dur, started: ticks };
+ inm.currentAction = { name: 'AUSSERHAUS', score: 0 };
+ UI.log(`${inm.name} IST AUSSERHAUS. RÜCKKEHR IN ~${Math.round(dur * SOP.TICK_MS / 1000)} S.`, 'wire');
+ break;
+ }
+ }
+ }
+
+ /* ---------------- EXPEDITIONS ---------------- */
+ /** Return a walkable tile beside dev, or null; optionally ignore inmate occupancy. */
+ function adjacentStand(dev, ignoreInmates) {
+ for (const [dx, dy] of [[0, 1], [1, 0], [-1, 0], [0, -1]]) {
+ const x = dev.x + dx, y = dev.y + dy;
+ if (!world.walkable(x, y)) continue;
+ if (!ignoreInmates && world.inmates.some(i => !i.dead && !i.away && i.tx === x && i.ty === y)) continue;
+ return { x, y };
+ }
+ return null;
+ }
+
+ /** Assign the named eligible inmate to board the airlock during an active shift. */
+ function startExpedition(name) {
+ if (gameOver || !started) return;
+ const air = world.devices.find(d => d.kind === 'airlock');
+ if (!air) { UI.log('KEINE LUFTSCHLEUSE VORHANDEN.', 'alert'); return; }
+ const inm = world.inmates.find(i => i.name === name && !i.dead && !i.away && !i.boarding);
+ if (!inm) return;
+ if (!adjacentStand(air)) { UI.log('SCHLEUSE NICHT ERREICHBAR — ZUGANG FREIMACHEN.', 'alert'); return; }
+ inm.sleeping = false;
+ inm.boarding = true;
+ inm.path = [];
+ inm.goal = { kind: 'device', dev: air, act: 'expedition' };
+ inm.currentAction = { name: 'EXPEDITION', score: 999 };
+ inm.thought = 'Raus. Nur kurz. Nur mit Maske.';
+ UI.log(`${inm.name}: GANG ZUR OBERFLÄCHE. MASKE SITZT.`, 'wire');
+ }
+
+ /** Return two or three weighted loot rolls with inclusive random resource quantities. */
+ function rollLoot() {
+ const totalW = SOP.LOOT.reduce((a, c) => a + c.weight, 0);
+ const n = 2 + (Math.random() < 0.4 ? 1 : 0);
+ const out = [];
+ for (let i = 0; i < n; i++) {
+ let roll = Math.random() * totalW, c = SOP.LOOT[0];
+ for (const cand of SOP.LOOT) { roll -= cand.weight; if (roll <= 0) { c = cand; break; } }
+ out.push({ res: c.res, label: c.label, n: c.n[0] + Math.floor(Math.random() * (c.n[1] - c.n[0] + 1)) });
+ }
+ return out;
+ }
+
+ /** Bring an inmate home with loot and possible injury, or defer if the gate is blocked. */
+ function returnFromExpedition(inm) {
+ const air = world.devices.find(d => d.kind === 'airlock');
+ const spot = air ? adjacentStand(air) : null;
+ if (!spot) { inm.away.returnTick = ticks + 40; return; } // gate blocked — wait outside
+ stats.expeditions++;
+ inm.tx = spot.x; inm.ty = spot.y; inm.px = spot.x; inm.py = spot.y;
+ inm.away = null;
+ const gains = rollLoot();
+ for (const g of gains) world.res[g.res] = (world.res[g.res] || 0) + g.n;
+ UI.log(`${inm.name} ZURÜCK VON DER OBERFLÄCHE: ${gains.map(g => '+' + g.n + ' ' + g.label).join(', ')}.`, 'ok');
+ if (Math.random() < SOP.EXPEDITION_INJURY_CHANCE) {
+ inm.hp = Math.max(5, inm.hp - 35);
+ inm.affective.stress = Math.min(100, inm.affective.stress + 25);
+ UI.alert(`${inm.name}: VERLETZUNG AUF DER OBERFLÄCHE. REVIER NOTWENDIG.`);
+ } else {
+ inm.affective.stress = Math.min(100, inm.affective.stress + 8);
+ }
+ inm.affective.o2 = Math.min(100, inm.affective.o2 + 12); // thin air up there
+ inm.affective.exhaustion = Math.min(100, inm.affective.exhaustion + 15);
+ }
+
+ /* ---------------- COLONY GROWTH ---------------- */
+ /** Add a newcomer when the airlock and colony capacity permit; return success. */
+ function tryArrival() {
+ if (gameOver) return false;
+ const air = world.devices.find(d => d.kind === 'airlock');
+ if (!air) return false;
+ const present = world.inmates.filter(i => !i.dead);
+ if (present.length >= SOP.MAX_INMATES) return false;
+ const spot = adjacentStand(air, true); // a brief overlap at the gate is fine
+ if (!spot) return false;
+ const used = new Set(world.inmates.map(i => i.name));
+ const pool = SOP.NAMES.filter(n => !used.has(n));
+ const name = pool.length
+ ? pool[Math.floor(Math.random() * pool.length)]
+ : 'SUBJEKT-' + Math.floor(100 + Math.random() * 900);
+ const traitKeys = Object.keys(SOP.TRAITS);
+ const trait = traitKeys[Math.floor(Math.random() * traitKeys.length)];
+ const nu = new SOP.InmateAI(name, trait, spot.x, spot.y);
+ nu.affective.hunger = 55 + Math.random() * 25; // arrived hungry
+ nu.affective.stress = 30 + Math.random() * 20; // the surface does that
+ world.inmates.push(nu);
+ stats.arrivals++;
+ UI.log(`NEUZUGANG AN DER SCHLEUSE: ${name} (${trait.toUpperCase()}). AKTE ERÖFFNET.`, 'ok');
+ UI.setTicker(`AKTUELLE DURCHSAGE: ${name} IST DEM SEKTOR 4 ZUGETEILT WORDEN`);
+ return true;
+ }
+
+ /** Choose the next arrival tick using the shorter range when a radio is powered. */
+ function scheduleNextArrival() {
+ const radio = world.devices.find(d =>
+ d.kind === 'radio' && d.powered && !d.broken && d.enabled !== false);
+ const range = radio ? SOP.ARRIVAL_RADIO : SOP.ARRIVAL_BASE;
+ nextArrivalTick = ticks + range[0] + Math.floor(Math.random() * (range[1] - range[0]));
+ }
+
+ /* ---------------- SAVE / LOAD ---------------- */
+ /** Return localStorage, or null if browser access throws. */
+ function storage() { try { return window.localStorage; } catch (e) { return null; } }
+
+ /** Return a versioned snapshot of the world, inmates, timers, and statistics. */
+ function buildSaveData() {
+ return {
+ v: 1,
+ savedAt: Date.now(),
+ ticks, nextQuakeTick, nextArrivalTick,
+ stats: Object.assign({}, stats),
+ world: world.serialize(),
+ inmates: world.inmates.map(i => i.serialize()),
+ };
+ }
+
+ /** Save the current snapshot to localStorage and return success; silent suppresses logs. */
+ function saveGame(silent) {
+ const st = storage();
+ if (!st) { if (!silent) UI.log('STORAGE BLOCKIERT. NUTZE EXPORT.', 'alert'); return false; }
+ try {
+ st.setItem(SAVE_KEY, JSON.stringify(buildSaveData()));
+ if (!silent) UI.log('AKTE GESICHERT (LOKAL).', 'dim');
+ return true;
+ } catch (e) {
+ if (!silent) UI.log('SICHERUNG FEHLGESCHLAGEN. NUTZE EXPORT.', 'alert');
+ return false;
+ }
+ }
+
+ /** Restore a version-1 snapshot and resume play; return false on format or load errors. */
+ function loadGame(data) {
+ try {
+ if (!data || data.v !== 1) { UI.log('AKTE UNLESBAR (FALSCHES FORMAT).', 'alert'); return false; }
+ world.loadFrom(data.world);
+ const inmates = data.inmates.map(d => SOP.InmateAI.fromData(d));
+ const ids = new Set(inmates.map(i => i.id));
+ for (const d of world.devices) {
+ if (d.operatedBy != null && !ids.has(d.operatedBy)) d.operatedBy = null;
+ }
+ world.inmates = inmates;
+ ticks = data.ticks;
+ nextQuakeTick = data.nextQuakeTick;
+ nextArrivalTick = data.nextArrivalTick;
+ const s = data.stats || {};
+ for (const k of Object.keys(stats)) {
+ stats[k] = Number.isFinite(s[k]) ? s[k] : 0;
+ }
+ state.selected = null; state.selDevice = null;
+ state.buildKind = null; state.linkFrom = null; state.ghost = null;
+ UI.clearBuildSelection();
+ gameOver = false;
+ document.getElementById('overlay-over').classList.remove('show');
+ document.getElementById('overlay-intro').classList.remove('show');
+ paused = false;
+ const pb = document.getElementById('btn-pause');
+ pb.classList.remove('pause-on'); pb.textContent = '❚❚ PAUSE';
+ if (!started) beginShift();
+ UI.log(`AKTE GELADEN — TAG ${day()}. DIE SCHICHT GEHT WEITER.`, 'ok');
+ return true;
+ } catch (e) {
+ if (typeof console !== 'undefined') console.error('LOAD ERROR:', e);
+ UI.log('LADEN FEHLGESCHLAGEN.', 'alert');
+ return false;
+ }
+ }
+
+ /** Download the current snapshot as JSON and log export success or failure. */
+ function exportSave() {
+ try {
+ const blob = new Blob([JSON.stringify(buildSaveData())], { type: 'application/json' });
+ const a = document.createElement('a');
+ a.href = URL.createObjectURL(blob);
+ a.download = 'sop-sektor4-akte.json';
+ document.body.appendChild(a);
+ a.click();
+ a.remove();
+ setTimeout(() => URL.revokeObjectURL(a.href), 2000);
+ UI.log('AKTE EXPORTIERT.', 'dim');
+ } catch (e) {
+ UI.log('EXPORT FEHLGESCHLAGEN.', 'alert');
+ }
+ }
+
+ /** Read a File as text, parse its JSON, and attempt to restore the saved game. */
+ function importSave(file) {
+ const r = new FileReader();
+ r.onload = () => {
+ try { loadGame(JSON.parse(r.result)); }
+ catch (e) { UI.log('AKTE UNLESBAR.', 'alert'); }
+ };
+ r.readAsText(file);
+ }
+
+ /* ---------------- EVENTS ---------------- */
+ /** Break up to two devices and apply earthquake stress, alerts, and screen shake. */
+ function quake() {
+ const name = SOP.QUAKE_NAMES[Math.floor(Math.random() * SOP.QUAKE_NAMES.length)];
+ stats.quakes++;
+ R.shake(800);
+ UI.alert(`${name} — STRUKTURSCHADEN IM SEKTOR.`);
+ UI.setTicker(`AKUTMELDUNG: ${name} ERSCHÜTTERT SEKTOR 4`);
+ // damage 1–2 random devices
+ const fragile = world.devices.filter(d => d.kind !== 'gas_vent' && !d.broken);
+ const hits = 1 + (Math.random() < 0.4 ? 1 : 0);
+ for (let i = 0; i < hits && fragile.length; i++) {
+ const idx = Math.floor(Math.random() * fragile.length);
+ const d = fragile.splice(idx, 1)[0];
+ d.broken = true;
+ UI.log(`DEFEKT: ${SOP.OBJ[d.kind].label} BEI ${d.x}/${d.y}.`, 'alert');
+ }
+ world.inmates.forEach(i => {
+ if (i.dead || i.away) return;
+ i.affective.stress = Math.min(100, i.affective.stress + 12);
+ i.affective.paranoia = Math.min(100, i.affective.paranoia + (i.trait === 'Paranoid' ? 22 : 8));
+ i.sleeping = false;
+ });
+ if (SOP.Audio && SOP.Audio.on) SOP.Audio.alarm();
+ }
+
+ /** Stop simulation advancement and show the final statistics with a restart action. */
+ function endGame() {
+ gameOver = true;
+ const daysWorked = Math.floor(ticks / SOP.DAY_TICKS);
+ UI.showGameOver(`
+
`;
+ if (away.length) {
+ for (const i of away) {
+ const eta = Math.max(0, Math.round((i.away.returnTick - (ticksNow || 0)) * SOP.TICK_MS / 1000));
+ html += `
${i.name}AUSSERHAUS · ~${eta} S
`;
+ }
+ }
+ if (candidates.length) {
+ html += `
+ `;
+ } else if (!away.length) {
+ html += `