Adds boilers

Author: katerberg

docs/PIPES.md

@@ -2,7 +2,7 @@
 
 Developer spec for the **fluid logistics** slice: ground water, boilers, mana springs, steam turrets, and typed pipe networks. Complements [`INFRASTRUCTURE.md`](INFRASTRUCTURE.md) (layers, soldiers, stairs).
 
-**Status:** Planned — not yet implemented (pipe infra exists as untyped placeholder).
+**Status:** P0–P3 in progress (water/steam preview, merge reject, boilers). Steam turrets / mana springs / magic turret mana are P4+.
 
 ---
 
@@ -27,7 +27,7 @@ flowchart TB
   subgraph mana [Mana economy]
     Pool[Shared mana pool max 20]
     MS -->|water + spring| Pool
-    Boiler[Boiler 2x1] -->|mana/sec| Pool
+    Boiler[Boiler 1x2] -->|mana/sec| Pool
     MT[Magic turret 1 mana/shot]
     Pool --> MT
   end
@@ -108,7 +108,7 @@ If placing a pipe would **4-connect** two components whose resolved fluids diffe
 
 | Property | Value |
 |----------|--------|
-| Size | **2×1** |
+| Size | **1×2** |
 | Water | Adjacent cell connected to **ground-water** network |
 | Steam | Adjacent cell connected to **steam-turret** network |
 | Mana | **~0.25/sec** while producing (tunable); **stops** at 0 mana |
@@ -258,7 +258,7 @@ interface SteamTurretState {
 | **P0** | This doc + `Player.mana` + constants stubs |
 | **P1** | `InfraCell.fluid`, seed flood-fill, preview colors, merge reject |
 | **P2** | Ground-water detection; connectivity warnings |
-| **P3** | Boiler 2×1 + `boilerExpansion` + mana drain + steam availability |
+| **P3** | Boiler 1×2 + `boilerExpansion` + mana drain + steam availability |
 | **P4** | Steam turret + charge + side blast + exterior targeting |
 | **P5** | Mana spring 2×2 + water gate + inspect warning |
 | **P6** | Magic turret 1 mana/shot |

src/config/constants.ts

@@ -53,7 +53,17 @@ export const WIZARD_DEFAULTS = {
   attackCooldown: 0.6,
 } as const;
 
-export const MAX_MANA = 10;
+/** Shared mana pool cap (spells, boilers, future springs/turrets). */
+export const MAX_MANA = 20;
+
+// Pipes / boilers / steam (PIPES.md) — stubs until later phases consume them.
+export const BOILER_MANA_PER_SEC = 0.25;
+export const MANA_SPRING_PER_SEC = 0.5;
+export const STEAM_TURRET_CHARGE_SEC = 3;
+export const STEAM_TURRET_DAMAGE = 10;
+export const MAGIC_TURRET_MANA_COST = 1;
+/** Throughput units by boilerExpansion level (0 = base, 1–2 = upgrades). */
+export const BOILER_THROUGHPUT = [3, 4, 5] as const;
 
 export const symbols = {
   wizard: '@',
@@ -88,6 +98,7 @@ export const colors = {
   infraPipe: '#4299e1',
   /** Pipe not yet connected to a water (or steam) seed. */
   infraPipeDry: '#718096',
+  infraPipeSteam: '#ed8936',
   soldier: '#68d391',
   connectivityWarn: '#ed8936',
 } as const;

src/model/blueprints.ts

@@ -75,6 +75,19 @@ export const BLUEPRINTS: Blueprint[] = [
     passable: true,
     description: 'Station soldiers here during attack. Allocate headcount from barracks in build phase.',
   },
+  {
+    id: 'boilerRoom',
+    name: 'Boiler',
+    glyph: 'H',
+    color: '#c05621',
+    size: { w: 1, h: 2 },
+    cost: 16,
+    baseHp: 22,
+    category: 'structure',
+    passable: false,
+    description:
+      '1×2 steam plant. Needs a ground-water pipe in and a steam pipe out. Drains mana while producing steam.',
+  },
 ];
 
 export const STARTING_BLUEPRINT_IDS = BLUEPRINTS.map((b) => b.id);

src/model/boilers.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+import { BOILER_MANA_PER_SEC } from '@/config/constants';
+import { getBlueprint } from './blueprints';
+import { placeInfra } from './infra';
+import { resetBoilerRuntime, tickBoilers } from './boilers';
+import { selectPipeConnectivityReport } from './pipes';
+import { createInitialState } from './game';
+import { createRoom, createTower, placeRoom } from './tower';
+
+function boilerWithPorts() {
+  const state = createInitialState('boiler0');
+  state.tower = createTower();
+  // Water column at col 4; boiler 1×2 at (5,0) covering (5,0)–(5,1); steam outlet at (6,1).
+  state.tower = placeRoom(state.tower, createRoom('g4', getBlueprint('stem')!, { col: 4, row: 0 }));
+  state.tower = placeRoom(state.tower, createRoom('w1', getBlueprint('stem')!, { col: 4, row: 1 }));
+  state.tower = placeRoom(state.tower, createRoom('boiler', getBlueprint('boilerRoom')!, { col: 5, row: 0 }));
+  state.tower = placeRoom(state.tower, createRoom('s0', getBlueprint('stem')!, { col: 6, row: 0 }));
+  state.tower = placeRoom(state.tower, createRoom('s1', getBlueprint('stem')!, { col: 6, row: 1 }));
+  state.tower = placeInfra(state.tower, { col: 4, row: 0 }, 'pipe');
+  state.tower = placeInfra(state.tower, { col: 4, row: 1 }, 'pipe');
+  state.tower = placeInfra(state.tower, { col: 6, row: 1 }, 'pipe');
+  state.phase = 'attack';
+  resetBoilerRuntime(state);
+  return state;
+}
+
+describe('tickBoilers', () => {
+  it('drains mana and marks steam available when both ports are connected', () => {
+    const state = boilerWithPorts();
+    const before = state.player.mana;
+    tickBoilers(state, 1);
+    expect(state.player.mana).toBeCloseTo(before - BOILER_MANA_PER_SEC, 5);
+    expect(state.boilerRuntime.boiler?.producing).toBe(true);
+    expect(state.boilerRuntime.boiler?.steamAvailable).toBe(true);
+  });
+
+  it('stops producing when mana is empty', () => {
+    const state = boilerWithPorts();
+    state.player.mana = 0;
+    tickBoilers(state, 1);
+    expect(state.boilerRuntime.boiler?.producing).toBe(false);
+    expect(state.boilerRuntime.boiler?.steamAvailable).toBe(false);
+  });
+
+  it('does not produce without a steam outlet', () => {
+    const state = createInitialState('boiler-dry');
+    state.tower = createTower();
+    state.tower = placeRoom(state.tower, createRoom('g4', getBlueprint('stem')!, { col: 4, row: 0 }));
+    state.tower = placeRoom(state.tower, createRoom('w1', getBlueprint('stem')!, { col: 4, row: 1 }));
+    state.tower = placeRoom(state.tower, createRoom('boiler', getBlueprint('boilerRoom')!, { col: 5, row: 0 }));
+    state.tower = placeInfra(state.tower, { col: 4, row: 0 }, 'pipe');
+    state.tower = placeInfra(state.tower, { col: 4, row: 1 }, 'pipe');
+    state.phase = 'attack';
+    resetBoilerRuntime(state);
+    const before = state.player.mana;
+    tickBoilers(state, 1);
+    expect(state.player.mana).toBe(before);
+    expect(state.boilerRuntime.boiler?.producing).toBe(false);
+  });
+});
+
+describe('selectPipeConnectivityReport', () => {
+  it('warns when a boiler lacks water', () => {
+    const state = createInitialState('pipe-warn');
+    state.tower = createTower();
+    state.tower = placeRoom(state.tower, createRoom('g5', getBlueprint('stem')!, { col: 4, row: 0 }));
+    state.tower = placeRoom(state.tower, createRoom('boiler', getBlueprint('boilerRoom')!, { col: 5, row: 0 }));
+    const report = selectPipeConnectivityReport(state);
+    expect(report.boilers.some((b) => b.roomId === 'boiler' && b.warning.includes('water'))).toBe(true);
+  });
+});

src/model/boilers.ts

@@ -0,0 +1,38 @@
+import { BOILER_MANA_PER_SEC, BOILER_THROUGHPUT } from '@/config/constants';
+import { boilerHasSteamPort, boilerHasWaterPort, isBoilerRoom } from './pipes';
+import type { GameState, Room } from './types';
+
+export function boilerThroughput(room: Room): number {
+  const expansion = room.modifications.find((m) => m.id === 'boilerExpansion');
+  const level = expansion?.level ?? 0;
+  return BOILER_THROUGHPUT[Math.min(level, BOILER_THROUGHPUT.length - 1)] ?? BOILER_THROUGHPUT[0];
+}
+
+export function resetBoilerRuntime(state: GameState): void {
+  state.boilerRuntime = {};
+  for (const room of state.tower.rooms) {
+    if (!isBoilerRoom(room)) continue;
+    state.boilerRuntime[room.id] = { producing: false, steamAvailable: false };
+  }
+}
+
+/** Drain mana and mark steam availability while water-connected and mana remains. */
+export function tickBoilers(state: GameState, dt: number): void {
+  for (const room of state.tower.rooms) {
+    if (!isBoilerRoom(room)) continue;
+
+    const waterOk = boilerHasWaterPort(state.tower, room.origin, room.size);
+    const steamOk = boilerHasSteamPort(state.tower, room.origin, room.size);
+    const producing = waterOk && steamOk && state.player.mana > 0;
+
+    if (producing) {
+      state.player.mana = Math.max(0, state.player.mana - BOILER_MANA_PER_SEC * dt);
+    }
+
+    const stillProducing = producing && state.player.mana > 0;
+    state.boilerRuntime[room.id] = {
+      producing: stillProducing,
+      steamAvailable: stillProducing,
+    };
+  }
+}

src/model/game.ts

@@ -7,6 +7,7 @@ import {
 } from '@/config/constants';
 import { sameMacroCell, macroCellOfNode } from '@/calculations/subGrid';
 import { resetSoldierCounter, stepSoldiers } from './soldiers';
+import { tickBoilers } from './boilers';
 import { STARTING_BLUEPRINT_IDS } from './blueprints';
 import { computeDamage, type Combatant } from '../calculations/combat';
 import { spawnNode } from '../calculations/exteriorGraph';
@@ -79,6 +80,7 @@ export function createInitialState(seed: string | number = 'wizard'): GameState
     blizzardZones: [],
     tornadoEnterDone: {},
     activeSpellSchool: 'fire',
+    boilerRuntime: {},
     buildBaseline: null,
   };
   resetSoldierCounter();
@@ -273,6 +275,9 @@ export function step(state: GameState, dt: number): void {
   // Room behaviors (turret rooms, slot volleys) and modifications (spikes) act on enemies this tick.
   runRoomEffects(state, dt);
 
+  // Boilers drain mana and mark steam availability.
+  tickBoilers(state, dt);
+
   // Reap dead enemies and award currency.
   const survivors: Enemy[] = [];
   for (const enemy of state.enemies) {

src/model/infraPlacement.ts

@@ -1,5 +1,6 @@
 import { getBlueprint } from './blueprints';
 import { canPlaceInfra, getInfraAt, placeInfra } from './infra';
+import { isBoilerFootprintCell, wouldMixFluids } from './pipes';
 import { canPlace, createRoom, isOccupied, placeRoom } from './tower';
 import type { Blueprint, Cell, PlacementReason, Tower } from './types';
 
@@ -35,6 +36,14 @@ export function planInfraPlacement(
     return { ok: false, reason: base.reason, needsStem: false, isToggleOff: false };
   }
 
+  if (blueprint.infraKind === 'pipe' && isBoilerFootprintCell(tower, cell.col, cell.row)) {
+    return { ok: false, reason: 'boiler_footprint', needsStem: false, isToggleOff: false };
+  }
+
+  if (blueprint.infraKind === 'pipe' && wouldMixFluids(tower, cell)) {
+    return { ok: false, reason: 'fluid_mix', needsStem: false, isToggleOff: false };
+  }
+
   if (isOccupied(tower, cell.col, cell.row)) {
     return { ok: true, reason: 'ok', needsStem: false, isToggleOff: false };
   }

src/model/modifications/boilerExpansion.ts

@@ -0,0 +1,15 @@
+import { BOILER_THROUGHPUT } from '@/config/constants';
+import { isBoilerRoom } from '@/model/pipes';
+import type { ModificationDef } from './types';
+
+export const boilerExpansion: ModificationDef = {
+  id: 'boilerExpansion',
+  name: 'Boiler Expansion',
+  glyph: '+',
+  color: '#c05621',
+  description: 'Increases steam throughput for connected turrets.',
+  mechanicsAtLevel: (level) => `Throughput ${BOILER_THROUGHPUT[level] ?? BOILER_THROUGHPUT[0]} units`,
+  maxLevel: 2,
+  cost: (level) => (level === 1 ? 14 : level === 2 ? 18 : 0),
+  canApply: (room) => isBoilerRoom(room),
+};

src/model/modifications/index.ts

@@ -1,6 +1,7 @@
 import type { Room, RoomStats, Tower } from '../types';
 import type { ModificationDef } from './types';
 import { barracksExpansion } from './barracksExpansion';
+import { boilerExpansion } from './boilerExpansion';
 import { slotExpansion } from './slotExpansion';
 import { spikes } from './spikes';
 
@@ -9,7 +10,12 @@ export type { ModificationDef, ModEffectContext } from './types';
 const DEFAULT_REFUND_RATE = 0.5;
 
 /** Every modification the game knows about. Add new types here. */
-export const MODIFICATIONS: ModificationDef[] = [spikes, barracksExpansion, slotExpansion];
+export const MODIFICATIONS: ModificationDef[] = [
+  spikes,
+  barracksExpansion,
+  slotExpansion,
+  boilerExpansion,
+];
 
 export function getModification(id: string): ModificationDef | undefined {
   return MODIFICATIONS.find((m) => m.id === id);

src/model/phases.ts

@@ -1,5 +1,7 @@
 import { prepareWaveNames } from './game';
 import { addMessage } from './messages';
+import { resetBoilerRuntime } from './boilers';
+import { lockPipeFluids } from './pipes';
 import { clearSoldiersAfterWave, deploySoldiersForWave } from './soldiers';
 import { reward } from '../calculations/economy';
 import { runWaveClearedEffects } from './modifications/effects';
@@ -32,6 +34,8 @@ export function beginWave(state: GameState): void {
   state.spawnTimer = 0;
   state.waveTimer = 0;
   state.roomEffectTimers = {};
+  state.tower = lockPipeFluids(state.tower);
+  resetBoilerRuntime(state);
   deploySoldiersForWave(state);
   refillMana(state);
   resetSpellCooldowns(state);
@@ -55,6 +59,7 @@ export function endWave(state: GameState): void {
   state.waveIndex += 1;
   state.phase = 'build';
   clearSoldiersAfterWave(state);
+  state.boilerRuntime = {};
   captureBuildBaseline(state);
   addMessage(state, `Reinforce the tower for wave ${state.levelIndex + 1}.`, 'info');
 }