-
REALPOLITIK
-
GEOPOLITICAL STRATEGY SIMULATOR
+
ASHFALL COMMAND
+
MODERN GRAND STRATEGY WARGAME
{/* Mode selection */}
diff --git a/src/components/panels/StatsPanel.tsx b/src/components/panels/StatsPanel.tsx
index 1a230f6..c106595 100644
--- a/src/components/panels/StatsPanel.tsx
+++ b/src/components/panels/StatsPanel.tsx
@@ -82,7 +82,7 @@ export function computeNationStats(
}
}
-function ModernNationBlock({ nationId, nationLabel, units, events }: { nationId: NationId; nationLabel: string; units: ViewUnit[]; events: GameEvent[] }) {
+function ModernNationBlock({ nationId, nationLabel, units, events, isPlayer }: { nationId: NationId; nationLabel: string; units: ViewUnit[]; events: GameEvent[]; isPlayer: boolean }) {
const stats = computeNationStats(units, events, nationId)
const activeUnits = stats.total - stats.destroyed
const color = getNationColor(nationId)
@@ -103,26 +103,40 @@ function ModernNationBlock({ nationId, nationLabel, units, events }: { nationId:
-
+
- {stats.offensiveMissilesMax > 0 && (
-
- )}
- {stats.samInterceptorsMax > 0 && (
-
+ {isPlayer ? (
+ <>
+ {stats.offensiveMissilesMax > 0 && (
+
+ )}
+ {stats.samInterceptorsMax > 0 && (
+
+ )}
+
+ ) : (
+ // Enemy inventories are not knowable under fog — known contacts only
+
+ EST. ORBAT: {activeUnits} {activeUnits === 1 ? 'contact' : 'contacts'}
+
)}
@@ -158,6 +172,7 @@ function ExchangeRatio({ incoming, intercepted }: { incoming: number; intercepte
export default function StatsPanel() {
const units = useGameStore(s => s.viewState.units)
const nations = useGameStore(s => s.viewState.nations)
+ const playerNation = useGameStore(s => s.viewState.playerNation)
const eventLog = useGameStore(s => s.eventLog)
return (
@@ -179,6 +194,7 @@ export default function StatsPanel() {
nationLabel={nation.name}
units={units}
events={eventLog}
+ isPlayer={nation.id === playerNation}
/>
))}
diff --git a/src/components/panels/UnitInfoPanel.tsx b/src/components/panels/UnitInfoPanel.tsx
index db42391..f4f64b9 100644
--- a/src/components/panels/UnitInfoPanel.tsx
+++ b/src/components/panels/UnitInfoPanel.tsx
@@ -44,6 +44,8 @@ export default function UnitInfoPanel({ units }: UnitInfoPanelProps) {
if (!unit) return null
const isFriendly = unit.nation === playerNation
+ const detected = unit.visibility === 'detected'
+ const identified = unit.visibility === 'identified'
// Same gate shipping.ts uses for drone interdiction
const isDroneCapable = unit.weapons.some((w) => w.weaponId.includes('shahed'))
const droneMission: DroneMission = unit.droneMission ?? 'military'
@@ -54,33 +56,47 @@ export default function UnitInfoPanel({ units }: UnitInfoPanelProps) {
onClose={() => selectUnit(null)}
style={{ position: 'absolute', top: 60, right: 12 }}
>
- {/* Status + Health */}
+ {/* Status + Health — scrubbed to placeholders below 'tracked', so don't show them */}
- {unit.status}
+ {detected ? 'contact' : unit.status}
{unit.nation.toUpperCase()} / {unit.category.replace(/_/g, ' ')}
-
+ {!detected && (
+
+ )}
+ {unit.stale && (
+
+ TRACK LOST — LAST KNOWN POSITION
+
+ )}
+
{/* Position */}
|
{unit.speed_kts > 0 &&
|
}
-
|
+ {identified &&
|
}
{unit.mine_count != null &&
|
}
{unit.radius_km != null &&
|
}
{/* Weapons */}
- {unit.weapons.length > 0 && (
+ {identified && unit.weapons.length > 0 && (
)}
+ {unit.visibility === 'tracked' && (
+
+
+ Armament
+
+
+ NO LOADOUT DATA
+
+
+ )}
{/* COMMAND section — only for friendly units */}
{isFriendly && (
diff --git a/src/components/panels/__tests__/StatsPanel.test.tsx b/src/components/panels/__tests__/StatsPanel.test.tsx
index c1b6c90..9df6817 100644
--- a/src/components/panels/__tests__/StatsPanel.test.tsx
+++ b/src/components/panels/__tests__/StatsPanel.test.tsx
@@ -1,9 +1,11 @@
import { describe, it, expect } from 'vitest'
-import { computeNationStats } from '../StatsPanel'
-import type { GameEvent } from '@/types/game'
-import type { ViewUnit } from '@/types/view'
+import { render, screen } from '@testing-library/react'
+import StatsPanel, { computeNationStats } from '../StatsPanel'
+import { useGameStore } from '@/store/game-store'
+import type { GameEvent, Nation } from '@/types/game'
+import type { GameViewState, ViewUnit } from '@/types/view'
-function makeUnit(id: string, nation: string): ViewUnit {
+function makeUnit(id: string, nation: string, overrides: Partial
= {}): ViewUnit {
return {
id,
name: id,
@@ -23,6 +25,9 @@ function makeUnit(id: string, nation: string): ViewUnit {
roe: 'weapons_free',
waypoints: [],
subordinateIds: [],
+ visibility: 'identified',
+ stale: false,
+ ...overrides,
} as ViewUnit
}
@@ -69,3 +74,64 @@ describe('computeNationStats interception rate', () => {
expect(iran.missilesIntercepted).toBe(0)
})
})
+
+function setStore(units: ViewUnit[], eventLog: GameEvent[] = []) {
+ const viewState: GameViewState = {
+ playerNation: 'usa',
+ initialized: true,
+ time: { tick: 0, timestamp: 0, speed: 0, tickIntervalMs: 100 },
+ nations: [
+ { id: 'usa', name: 'United States' } as Nation,
+ { id: 'iran', name: 'Iran' } as Nation,
+ ],
+ units,
+ missiles: [],
+ supplyLines: [],
+ shippingLanes: [],
+ events: [],
+ pendingEventCount: 0,
+ satelliteDetectedUnitIds: [],
+ warSupport: {},
+ gameOver: null,
+ objectives: [],
+ }
+ useGameStore.setState({ viewState, eventLog, visualTimestamp: 0, lastUpdateRealMs: 0, visualRate: 0 })
+}
+
+describe('StatsPanel under fog of war', () => {
+ const offensive = { weaponId: 'tomahawk', count: 5, maxCount: 10, reloadTimeSec: 60 }
+ const sam = { weaponId: 'pac3_mse', count: 8, maxCount: 16, reloadTimeSec: 60 }
+
+ it('labels the enemy unit count as Contacts, own side stays Active', () => {
+ setStore([
+ makeUnit('usa_base', 'usa'),
+ makeUnit('iran_c1', 'iran', { visibility: 'detected', stale: true }),
+ makeUnit('iran_c2', 'iran', { visibility: 'tracked' }),
+ ])
+ render()
+ expect(screen.getByText('Active')).toBeTruthy()
+ expect(screen.getByText('Contacts')).toBeTruthy()
+ expect(screen.getByText(/EST\. ORBAT: 2 contacts/)).toBeTruthy()
+ })
+
+ it('replaces enemy inventory bars with the contact summary even when loadout data exists', () => {
+ setStore([
+ makeUnit('usa_base', 'usa', { weapons: [offensive, sam] }),
+ makeUnit('iran_id', 'iran', { weapons: [offensive, sam] }),
+ ])
+ render()
+ expect(screen.getAllByText('Offensive Missiles')).toHaveLength(1)
+ expect(screen.getAllByText('SAM Interceptors')).toHaveLength(1)
+ expect(screen.getByText(/EST\. ORBAT: 1 contact/)).toBeTruthy()
+ })
+
+ it('keeps observed fired / shot-down counters for both sides', () => {
+ setStore(
+ [makeUnit('usa_base', 'usa'), makeUnit('iran_tel', 'iran', { visibility: 'tracked' })],
+ [launched('iran_tel', 'usa_base', 1)],
+ )
+ render()
+ expect(screen.getAllByText('Fired (offensive)')).toHaveLength(2)
+ expect(screen.getAllByText('Shot down (AD)')).toHaveLength(2)
+ })
+})
diff --git a/src/components/panels/__tests__/UnitInfoPanel.test.tsx b/src/components/panels/__tests__/UnitInfoPanel.test.tsx
new file mode 100644
index 0000000..322f838
--- /dev/null
+++ b/src/components/panels/__tests__/UnitInfoPanel.test.tsx
@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import UnitInfoPanel from '../UnitInfoPanel'
+import { useGameStore } from '@/store/game-store'
+import { useUIStore } from '@/store/ui-store'
+import type { GameViewState, ViewUnit } from '@/types/view'
+
+function makeUnit(overrides: Partial & Pick): ViewUnit {
+ return {
+ name: overrides.id,
+ nation: 'iran',
+ category: 'ship',
+ position: { lat: 26, lng: 56 },
+ heading: 0,
+ speed_kts: 0,
+ status: 'ready',
+ health: 100,
+ maxHealth: 100,
+ logistics: 100,
+ supplyStocks: [],
+ weapons: [],
+ pointDefense: [],
+ sensors: [],
+ roe: 'weapons_tight',
+ waypoints: [],
+ subordinateIds: [],
+ visibility: 'identified',
+ stale: false,
+ ...overrides,
+ } as ViewUnit
+}
+
+function setup(unit: ViewUnit) {
+ const viewState = {
+ playerNation: 'usa',
+ initialized: true,
+ time: { tick: 0, timestamp: 0, speed: 0, tickIntervalMs: 100 },
+ nations: [],
+ units: [unit],
+ missiles: [],
+ supplyLines: [],
+ shippingLanes: [],
+ events: [],
+ pendingEventCount: 0,
+ satelliteDetectedUnitIds: [],
+ warSupport: {},
+ gameOver: null,
+ objectives: [],
+ } as GameViewState
+ useGameStore.setState({ viewState })
+ useUIStore.setState({ selectedUnitId: unit.id, selectedUnitIds: new Set([unit.id]) })
+ return render()
+}
+
+describe('UnitInfoPanel fog of war', () => {
+ it('shows TRACK LOST banner and hides condition data for stale detected contacts', () => {
+ setup(makeUnit({ id: 'c1', name: 'Surface contact', visibility: 'detected', stale: true }))
+ expect(screen.getByText(/TRACK LOST/)).toBeTruthy()
+ expect(screen.getByText('contact')).toBeTruthy()
+ expect(screen.queryByText('HEALTH')).toBeNull()
+ expect(screen.queryByText('ROE')).toBeNull()
+ expect(screen.queryByText('Armament')).toBeNull()
+ })
+
+ it('shows condition but NO LOADOUT DATA for tracked contacts', () => {
+ setup(makeUnit({
+ id: 'c2',
+ name: 'IRIS Sahand',
+ visibility: 'tracked',
+ status: 'damaged',
+ health: 62,
+ speed_kts: 18,
+ }))
+ expect(screen.getByText('HEALTH')).toBeTruthy()
+ expect(screen.getByText('SPEED')).toBeTruthy()
+ expect(screen.getByText('NO LOADOUT DATA')).toBeTruthy()
+ expect(screen.queryByText(/TRACK LOST/)).toBeNull()
+ expect(screen.queryByText('ROE')).toBeNull()
+ })
+
+ it('shows everything for identified units', () => {
+ setup(makeUnit({
+ id: 'c3',
+ name: 'IRIS Jamaran',
+ weapons: [{ weaponId: 'noor_ashm', count: 4, maxCount: 8, reloadTimeSec: 60 }],
+ }))
+ expect(screen.getByText('HEALTH')).toBeTruthy()
+ expect(screen.getByText('ROE')).toBeTruthy()
+ expect(screen.getByText('Armament')).toBeTruthy()
+ expect(screen.queryByText('NO LOADOUT DATA')).toBeNull()
+ })
+})
diff --git a/src/engine/__tests__/attack-planner.test.ts b/src/engine/__tests__/attack-planner.test.ts
index ad288d4..c808d39 100644
--- a/src/engine/__tests__/attack-planner.test.ts
+++ b/src/engine/__tests__/attack-planner.test.ts
@@ -33,6 +33,8 @@ function toViewUnit(u: Unit): ViewUnit {
radius_km: u.radius_km,
mine_count: u.mine_count,
droneMission: u.droneMission,
+ visibility: 'identified',
+ stale: false,
}
}
diff --git a/src/engine/game-engine.ts b/src/engine/game-engine.ts
index 2d1edae..119e8b6 100644
--- a/src/engine/game-engine.ts
+++ b/src/engine/game-engine.ts
@@ -24,6 +24,8 @@ import { findNavalRoute } from './systems/route-planner'
import type { SatellitePass } from '@/types/game'
import { processShipping, resetShippingState } from './systems/shipping'
import { shippingLanes as defaultShippingLanes } from '@/data/shipping/shipping-lanes'
+import { processVisibility, resetVisibilityState, getViewVisibility, contactDisplayName, type ViewVisibility } from './systems/visibility'
+import { processWarSupport, resetWarSupportState, offerCeasefire, acceptCeasefire, resign, getWarSupport, getObjectives } from './systems/war-support'
const TICK_MS = 1_000 // 1 tick = 1 game second (real-time at 1x)
const SCENARIO_START = new Date('2026-06-15T06:00:00Z').getTime()
@@ -170,6 +172,12 @@ export class GameEngine {
// Espionage: HUMINT reveals + SIGINT multiplier
this.lastEspionageResult = processEspionage(state, this.rng)
+ // Fog of war: fold radar/satellite/HUMINT/ELINT pictures into per-nation contacts
+ processVisibility(state, this.sensorNetwork, this.lastEspionageResult, this.elevationGrid)
+
+ // Political will: war-support drains, ceasefire logic, capitulation, objectives
+ processWarSupport(state)
+
// Cap pendingEvents to prevent unbounded growth during fast-forward
if (state.pendingEvents.length > 2000) {
state.pendingEvents.splice(0, state.pendingEvents.length - 2000)
@@ -268,9 +276,15 @@ export class GameEngine {
break
}
case 'CEASE_FIRE': {
- const player = state.playerNation
- state.nations[player].atWar = state.nations[player].atWar.filter(n => n !== cmd.target)
- state.nations[cmd.target].atWar = state.nations[cmd.target].atWar.filter(n => n !== player)
+ acceptCeasefire(state, state.playerNation, cmd.target)
+ break
+ }
+ case 'OFFER_CEASEFIRE': {
+ offerCeasefire(state, state.playerNation, cmd.target)
+ break
+ }
+ case 'RESIGN': {
+ resign(state)
break
}
case 'SET_HEADING': {
@@ -297,18 +311,27 @@ export class GameEngine {
const events = [...state.pendingEvents]
state.pendingEvents = [] // one-shot delivery
+ const units: ViewUnit[] = []
+ for (const u of state.units.values()) {
+ const vis = getViewVisibility(state, state.playerNation, u)
+ if (vis) units.push(toViewUnit(u, vis))
+ }
+
return {
playerNation: state.playerNation,
initialized: state.initialized,
time: { ...state.time },
nations: Object.values(state.nations),
- units: Array.from(state.units.values()).map(toViewUnit),
+ units,
missiles: Array.from(state.missiles.values()),
supplyLines: Array.from(state.supplyLines.values()),
shippingLanes: Array.from(state.shippingLanes.values()),
events,
pendingEventCount: state.events.length,
satelliteDetectedUnitIds: Array.from(getSatelliteDetections(state.playerNation, state.time.tick)),
+ warSupport: getWarSupport(state),
+ gameOver: state.gameOver ?? null,
+ objectives: getObjectives(state),
}
}
@@ -321,6 +344,9 @@ export class GameEngine {
time: s.time,
nations: s.nations,
attackCounters: s.attackCounters ?? {},
+ visibility: s.visibility ?? {},
+ warStatus: s.warStatus ?? {},
+ gameOver: s.gameOver ?? null,
units: Array.from(s.units.entries()),
missiles: Array.from(s.missiles.entries()),
supplyLines: Array.from(s.supplyLines.entries()),
@@ -360,6 +386,9 @@ export class GameEngine {
events: raw.events ?? [],
pendingEvents: [],
attackCounters: raw.attackCounters ?? {},
+ visibility: raw.visibility ?? {},
+ warStatus: raw.warStatus ?? {},
+ gameOver: raw.gameOver ?? undefined,
}
// Backfill shipping lanes for old saves that didn't have them
if (!raw.shippingLanes || raw.shippingLanes.length === 0) {
@@ -404,6 +433,8 @@ export class GameEngine {
resetDroneAIState()
resetSatelliteState()
resetShippingState()
+ resetVisibilityState()
+ resetWarSupportState()
}
/** Set up satellite constellations for each nation */
@@ -500,31 +531,37 @@ export class GameEngine {
}
}
-function toViewUnit(u: Unit): ViewUnit {
+function toViewUnit(u: Unit, vis: ViewVisibility): ViewUnit {
+ // Scrub by contact quality: 'detected' hides everything but the contact itself,
+ // 'tracked' shows identity and condition but not loadout. Own units are 'identified'.
+ const identified = vis.level === 'identified'
+ const trackedPlus = identified || vis.level === 'tracked'
return {
id: u.id,
- name: u.name,
+ name: trackedPlus ? u.name : contactDisplayName(u.category),
nation: u.nation,
category: u.category,
- position: { ...u.position },
- heading: u.heading,
- speed_kts: u.speed_kts,
- status: u.status,
- health: u.health,
- maxHealth: u.maxHealth,
- logistics: u.logistics,
- supplyStocks: u.supplyStocks.map(s => ({ ...s })),
- weapons: u.weapons.map(w => ({ ...w })),
- pointDefense: u.pointDefense.map(pd => ({ ...pd })),
- sensors: u.sensors.map(s => ({ ...s })),
+ position: { ...vis.position },
+ heading: trackedPlus ? u.heading : 0,
+ speed_kts: trackedPlus ? u.speed_kts : 0,
+ status: trackedPlus ? u.status : 'ready',
+ health: trackedPlus ? u.health : 100,
+ maxHealth: trackedPlus ? u.maxHealth : 100,
+ logistics: identified ? u.logistics : 0,
+ supplyStocks: identified ? u.supplyStocks.map(s => ({ ...s })) : [],
+ weapons: identified ? u.weapons.map(w => ({ ...w })) : [],
+ pointDefense: identified ? u.pointDefense.map(pd => ({ ...pd })) : [],
+ sensors: identified ? u.sensors.map(s => ({ ...s })) : [],
roe: u.roe,
- waypoints: u.waypoints.map(w => ({ ...w })),
- parentId: u.parentId,
- subordinateIds: [...u.subordinateIds],
- readiness: u.readiness,
- readinessTimer: u.readinessTimer,
+ waypoints: identified ? u.waypoints.map(w => ({ ...w })) : [],
+ parentId: identified ? u.parentId : undefined,
+ subordinateIds: identified ? [...u.subordinateIds] : [],
+ readiness: identified ? u.readiness : undefined,
+ readinessTimer: identified ? u.readinessTimer : undefined,
radius_km: u.radius_km,
- mine_count: u.mine_count,
- droneMission: u.droneMission,
+ mine_count: identified ? u.mine_count : undefined,
+ droneMission: identified ? u.droneMission : undefined,
+ visibility: vis.level,
+ stale: vis.stale,
}
}
diff --git a/src/engine/systems/__tests__/visibility.test.ts b/src/engine/systems/__tests__/visibility.test.ts
new file mode 100644
index 0000000..3cf89a2
--- /dev/null
+++ b/src/engine/systems/__tests__/visibility.test.ts
@@ -0,0 +1,390 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { processVisibility, resetVisibilityState, getViewVisibility } from '../visibility'
+import { processSatellites, resetSatelliteState } from '../satellites'
+import { ElevationGrid } from '../elevation'
+import type { EspionageResult } from '../espionage'
+import type { GameState, NationId, SatellitePass, Sensor, Unit, UnitId } from '@/types/game'
+
+// ── Helpers ─────────────────────────────────────────────────────
+
+function makeUnit(overrides: Partial & { id: string; nation: NationId }): Unit {
+ return {
+ name: overrides.id,
+ category: 'ship',
+ position: { lat: 27, lng: 52 },
+ heading: 0,
+ speed_kts: 0,
+ maxSpeed_kts: 0,
+ health: 100,
+ maxHealth: 100,
+ hardness: 100,
+ logistics: 0,
+ supplyStocks: [],
+ weapons: [],
+ pointDefense: [],
+ sensors: [],
+ roe: 'weapons_tight' as const,
+ status: 'ready' as const,
+ waypoints: [],
+ subordinateIds: [],
+ ...overrides,
+ } as Unit
+}
+
+function radar(range_km: number, antenna_height_m = 15): Sensor {
+ return { type: 'radar', range_km, detection_prob: 0.9, antenna_height_m }
+}
+
+function makeState(units: Unit[], tick = 60): GameState {
+ return {
+ playerNation: 'usa',
+ initialized: true,
+ time: { tick, timestamp: 1_000_000, speed: 1, tickIntervalMs: 100 },
+ nations: {
+ usa: {
+ id: 'usa', name: 'USA',
+ economy: { gdp_billions: 28000, military_budget_billions: 886, military_budget_pct_gdp: 3.2, oil_revenue_billions: 0, sanctions_impact: 0, war_cost_per_day_millions: 0, reserves_billions: 800 },
+ relations: { usa: 100, iran: -60 }, atWar: ['iran'],
+ },
+ iran: {
+ id: 'iran', name: 'Iran',
+ economy: { gdp_billions: 400, military_budget_billions: 25, military_budget_pct_gdp: 6.3, oil_revenue_billions: 50, sanctions_impact: 0.3, war_cost_per_day_millions: 0, reserves_billions: 120 },
+ relations: { usa: -60, iran: 100 }, atWar: ['usa'],
+ },
+ },
+ units: new Map(units.map(u => [u.id, u])),
+ missiles: new Map(),
+ supplyLines: new Map(),
+ shippingLanes: new Map(),
+ events: [],
+ pendingEvents: [],
+ }
+}
+
+function runEval(state: GameState, tick: number, espionage: EspionageResult | null = null, grid: ElevationGrid | null = null): void {
+ state.time.tick = tick
+ processVisibility(state, null, espionage, grid)
+}
+
+function contact(state: GameState, observer: string, unitId: UnitId) {
+ return state.visibility?.[observer]?.[unitId]
+}
+
+function espionageWith(opts: { humint?: Record; sigint?: Record }): EspionageResult {
+ return {
+ humintRevealed: new Map(Object.entries(opts.humint ?? {})),
+ sigintMultiplier: new Map(Object.entries(opts.sigint ?? {})),
+ }
+}
+
+/** Build a minimal ElevationGrid (same binary format as elevation.test.ts) */
+function makeGrid(
+ latMin: number, latMax: number, lngMin: number, lngMax: number,
+ resolution: number, elevations: number[][],
+): ElevationGrid {
+ const rows = elevations.length
+ const cols = elevations[0].length
+ const buffer = new ArrayBuffer(20 + rows * cols * 4)
+ const header = new Float32Array(buffer, 0, 5)
+ header[0] = latMin
+ header[1] = latMax
+ header[2] = lngMin
+ header[3] = lngMax
+ header[4] = resolution
+ const data = new Float32Array(buffer, 20, rows * cols)
+ for (let r = 0; r < rows; r++) {
+ for (let c = 0; c < cols; c++) {
+ data[r * cols + c] = elevations[r][c]
+ }
+ }
+ return new ElevationGrid(buffer)
+}
+
+beforeEach(() => {
+ resetVisibilityState()
+ resetSatelliteState()
+})
+
+// At lat 27, 1 degree of longitude ≈ 99 km
+
+// ── Tests ───────────────────────────────────────────────────────
+
+describe('radar acquisition', () => {
+ it('tracks enemy units in radar range, identifies within 60% of range', () => {
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irFar = makeUnit({ id: 'ir_far', nation: 'iran', position: { lat: 27, lng: 52.7 } }) // ~69 km
+ const irNear = makeUnit({ id: 'ir_near', nation: 'iran', position: { lat: 27, lng: 52.2 } }) // ~20 km
+ const irOut = makeUnit({ id: 'ir_out', nation: 'iran', position: { lat: 27, lng: 54 } }) // ~198 km
+ const state = makeState([usRadar, irFar, irNear, irOut])
+
+ runEval(state, 60)
+
+ expect(contact(state, 'usa', 'ir_far')?.level).toBe('tracked')
+ expect(contact(state, 'usa', 'ir_near')?.level).toBe('identified')
+ expect(contact(state, 'usa', 'ir_out')).toBeUndefined()
+ expect(getViewVisibility(state, 'usa', irOut)).toBeNull()
+ })
+
+ it('only evaluates sources on game-minute ticks', () => {
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.5 } })
+ const state = makeState([usRadar, irShip])
+
+ runEval(state, 61)
+ expect(contact(state, 'usa', 'ir_ship')).toBeUndefined()
+
+ runEval(state, 120)
+ expect(contact(state, 'usa', 'ir_ship')?.level).toBe('identified')
+ })
+
+ it('builds pictures for both nations', () => {
+ const usShip = makeUnit({ id: 'us_ship', nation: 'usa', sensors: [radar(100)] })
+ const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.7 }, sensors: [radar(100)] })
+ const state = makeState([usShip, irShip])
+
+ runEval(state, 60)
+
+ expect(contact(state, 'usa', 'ir_ship')?.level).toBe('tracked')
+ expect(contact(state, 'iran', 'us_ship')?.level).toBe('tracked')
+ expect(contact(state, 'usa', 'us_ship')).toBeUndefined()
+ expect(contact(state, 'iran', 'ir_ship')).toBeUndefined()
+ })
+
+ it('terrain blocks line of sight', () => {
+ // 3000 m ridge at lng 52.4-52.6, flat elsewhere
+ const elevations = Array.from({ length: 20 }, () =>
+ Array.from({ length: 30 }, (_, c) => (c >= 14 && c <= 16 ? 3000 : 0)),
+ )
+ const grid = makeGrid(26, 28, 51, 54, 0.1, elevations)
+
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irBlocked = makeUnit({ id: 'ir_blocked', nation: 'iran', position: { lat: 27, lng: 53 } })
+ const irControl = makeUnit({ id: 'ir_control', nation: 'iran', position: { lat: 27, lng: 52.3 } })
+ const state = makeState([usRadar, irBlocked, irControl])
+
+ runEval(state, 60, null, grid)
+
+ expect(contact(state, 'usa', 'ir_blocked')).toBeUndefined()
+ expect(contact(state, 'usa', 'ir_control')?.level).toBe('identified')
+ })
+})
+
+describe('decay', () => {
+ it('decays tracked → detected → unseen with frozen last-known position', () => {
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.7 } })
+ const state = makeState([usRadar, irShip])
+
+ runEval(state, 60)
+ expect(contact(state, 'usa', 'ir_ship')?.level).toBe('tracked')
+ expect(getViewVisibility(state, 'usa', irShip)?.stale).toBe(false)
+
+ // Track lost: ship sails out of radar range
+ irShip.position = { lat: 27, lng: 60 }
+
+ runEval(state, 660) // 10 game-min after last seen
+ const c = contact(state, 'usa', 'ir_ship')
+ expect(c?.level).toBe('detected')
+ expect(c?.lastKnownPosition.lng).toBe(52.7)
+ const view = getViewVisibility(state, 'usa', irShip)
+ expect(view?.stale).toBe(true)
+ expect(view?.position.lng).toBe(52.7)
+
+ runEval(state, 2400) // still inside the 30-min detected window
+ expect(contact(state, 'usa', 'ir_ship')?.level).toBe('detected')
+
+ runEval(state, 2460) // 40 game-min after last seen
+ expect(contact(state, 'usa', 'ir_ship')).toBeUndefined()
+ expect(getViewVisibility(state, 'usa', irShip)).toBeNull()
+ })
+
+ it('keeps a refreshed track alive without decay', () => {
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.7 } })
+ const state = makeState([usRadar, irShip])
+
+ runEval(state, 60)
+ runEval(state, 1200)
+ expect(contact(state, 'usa', 'ir_ship')?.level).toBe('tracked')
+ expect(contact(state, 'usa', 'ir_ship')?.lastSeenTick).toBe(1200)
+ })
+
+ it('airbase stays identified forever once identified', () => {
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irBase = makeUnit({ id: 'ir_base', nation: 'iran', category: 'airbase', position: { lat: 27, lng: 52.2 } })
+ const state = makeState([usRadar, irBase])
+
+ runEval(state, 60)
+ expect(contact(state, 'usa', 'ir_base')?.level).toBe('identified')
+
+ usRadar.position = { lat: 10, lng: 40 }
+ runEval(state, 60_000)
+ const c = contact(state, 'usa', 'ir_base')
+ expect(c?.level).toBe('identified')
+ expect(c?.pinned).toBe(true)
+ })
+
+ it('stationary sam_site pins at detected, moved sam_site decays to unseen', () => {
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irSam = makeUnit({ id: 'ir_sam', nation: 'iran', category: 'sam_site', position: { lat: 27, lng: 52.7 } })
+ const state = makeState([usRadar, irSam])
+
+ runEval(state, 60)
+ expect(contact(state, 'usa', 'ir_sam')?.level).toBe('tracked')
+
+ usRadar.position = { lat: 10, lng: 40 }
+ runEval(state, 3060) // long past the mobile unseen threshold
+ const c = contact(state, 'usa', 'ir_sam')
+ expect(c?.level).toBe('detected')
+ expect(c?.pinned).toBe(true)
+
+ irSam.position = { lat: 27, lng: 53.5 }
+ runEval(state, 3120)
+ expect(contact(state, 'usa', 'ir_sam')).toBeUndefined()
+ })
+})
+
+describe('satellites', () => {
+ function makeSatellite(overrides: Partial & { id: string; nation: NationId }): SatellitePass {
+ return {
+ type: 'optical',
+ swathWidth_km: 50,
+ revisitInterval_sec: 3600,
+ lastPassTick: 0,
+ groundTrack: { startLat: 30, startLng: 50, endLat: 36, endLng: 56 },
+ ...overrides,
+ }
+ }
+
+ it('radar satellite pass produces a detected contact with stale position', () => {
+ const irUnit = makeUnit({ id: 'ir_unit', nation: 'iran', position: { lat: 33, lng: 53 } })
+ const state = makeState([irUnit], 3600)
+ state.nations.usa.satellites = [makeSatellite({ id: 'usa_radar_sat', nation: 'usa', type: 'radar_sat', swathWidth_km: 200 })]
+
+ processSatellites(state)
+ processVisibility(state, null, null, null)
+
+ expect(contact(state, 'usa', 'ir_unit')?.level).toBe('detected')
+ const view = getViewVisibility(state, 'usa', irUnit)
+ expect(view?.stale).toBe(true)
+ expect(view?.position.lat).toBe(33)
+ })
+
+ it('optical satellite pass produces a tracked contact', () => {
+ const irUnit = makeUnit({ id: 'ir_unit', nation: 'iran', position: { lat: 33, lng: 53 } })
+ const state = makeState([irUnit], 3600)
+ state.nations.usa.satellites = [makeSatellite({ id: 'usa_optical', nation: 'usa', type: 'optical' })]
+
+ processSatellites(state)
+ processVisibility(state, null, null, null)
+
+ expect(contact(state, 'usa', 'ir_unit')?.level).toBe('tracked')
+ })
+})
+
+describe('espionage sources', () => {
+ it('HUMINT identifies a unit and stays sticky for 30 game-min before decaying', () => {
+ const irHq = makeUnit({ id: 'ir_hq', nation: 'iran', category: 'missile_battery', position: { lat: 30, lng: 55 } })
+ const state = makeState([irHq])
+
+ runEval(state, 3600, espionageWith({ humint: { usa: ['ir_hq'] } }))
+ expect(contact(state, 'usa', 'ir_hq')?.level).toBe('identified')
+
+ runEval(state, 5340) // 29 min later, no new espionage — still sticky
+ expect(contact(state, 'usa', 'ir_hq')?.level).toBe('identified')
+ expect(contact(state, 'usa', 'ir_hq')?.lastSeenTick).toBe(5340)
+
+ runEval(state, 6000) // sticky expired at 5400, identified hold expired at 5940
+ expect(contact(state, 'usa', 'ir_hq')?.level).toBe('tracked')
+ })
+
+ it('ELINT detects enemy radar emitters at range scaled by the SIGINT multiplier', () => {
+ const usEw = makeUnit({ id: 'us_ew', nation: 'usa', sensors: [radar(50)] })
+ const irSam = makeUnit({ id: 'ir_sam', nation: 'iran', category: 'sam_site', position: { lat: 27, lng: 53.75 }, sensors: [radar(100)] }) // ~173 km
+ const state = makeState([usEw, irSam])
+
+ runEval(state, 60, espionageWith({ sigint: { usa: 1.5, iran: 1.5 } }))
+ expect(contact(state, 'usa', 'ir_sam')).toBeUndefined() // 100 × 1.5 = 150 km < 173
+
+ runEval(state, 120, espionageWith({ sigint: { usa: 2.0, iran: 1.5 } }))
+ const c = contact(state, 'usa', 'ir_sam')
+ expect(c?.level).toBe('detected') // 100 × 2.0 = 200 km ≥ 173
+ expect(getViewVisibility(state, 'usa', irSam)?.stale).toBe(true)
+ expect(contact(state, 'iran', 'us_ew')).toBeUndefined() // 50 × 1.5 = 75 km < 173
+ })
+
+ it('non-emitting units are not ELINT-detectable', () => {
+ const usEw = makeUnit({ id: 'us_ew', nation: 'usa', sensors: [radar(50)] })
+ const irSilent = makeUnit({ id: 'ir_silent', nation: 'iran', position: { lat: 27, lng: 53 } })
+ const state = makeState([usEw, irSilent])
+
+ runEval(state, 60, espionageWith({ sigint: { usa: 2.0 } }))
+ expect(contact(state, 'usa', 'ir_silent')).toBeUndefined()
+ })
+})
+
+describe('event-driven reveals', () => {
+ it('missile launch reveals the launcher at tracked on the launch tick', () => {
+ const irTel = makeUnit({ id: 'ir_tel', nation: 'iran', category: 'missile_battery', position: { lat: 29, lng: 53 } })
+ const usBase = makeUnit({ id: 'us_base', nation: 'usa', category: 'airbase' })
+ const state = makeState([irTel, usBase], 61)
+ state.events.push({ type: 'MISSILE_LAUNCHED', missileId: 'm_1', launcherId: 'ir_tel', targetId: 'us_base', weaponName: 'Zolfaghar', tick: 61 })
+
+ processVisibility(state, null, null, null)
+
+ const c = contact(state, 'usa', 'ir_tel')
+ expect(c?.level).toBe('tracked')
+ expect(c?.lastSeenTick).toBe(61)
+ expect(contact(state, 'iran', 'ir_tel')).toBeUndefined()
+ })
+
+ it('launch plume does not downgrade a fresh identified contact', () => {
+ const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100)] })
+ const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.2 } })
+ const state = makeState([usRadar, irShip])
+
+ runEval(state, 60)
+ expect(contact(state, 'usa', 'ir_ship')?.level).toBe('identified')
+
+ state.time.tick = 61
+ state.events.push({ type: 'MISSILE_LAUNCHED', missileId: 'm_1', launcherId: 'ir_ship', targetId: 'us_radar', weaponName: 'Noor', tick: 61 })
+ processVisibility(state, null, null, null)
+
+ const c = contact(state, 'usa', 'ir_ship')
+ expect(c?.level).toBe('identified')
+ expect(c?.lastSeenTick).toBe(60)
+ })
+
+ it('mine contact identifies the minefield permanently', () => {
+ const irMines = makeUnit({ id: 'ir_mines', nation: 'iran', category: 'minefield', position: { lat: 26.5, lng: 56 } })
+ const usShip = makeUnit({ id: 'us_ship', nation: 'usa', position: { lat: 26.5, lng: 56 } })
+ const state = makeState([irMines, usShip], 61)
+ state.events.push({ type: 'MINE_CONTACT', minefieldId: 'ir_mines', targetId: 'us_ship', damage: 35, tick: 61 })
+
+ processVisibility(state, null, null, null)
+ const c = contact(state, 'usa', 'ir_mines')
+ expect(c?.level).toBe('identified')
+ expect(c?.pinned).toBe(true)
+
+ runEval(state, 60_000)
+ expect(contact(state, 'usa', 'ir_mines')?.level).toBe('identified')
+ })
+})
+
+describe('getViewVisibility', () => {
+ it('excludes enemy units with no contact entry (fog-on)', () => {
+ const usShip = makeUnit({ id: 'us_ship', nation: 'usa' })
+ const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 28, lng: 55 } })
+ const state = makeState([usShip, irShip])
+
+ expect(getViewVisibility(state, 'usa', irShip)).toBeNull()
+ })
+
+ it('always reports own units identified with live position', () => {
+ const usShip = makeUnit({ id: 'us_ship', nation: 'usa' })
+ const state = makeState([usShip])
+
+ const view = getViewVisibility(state, 'usa', usShip)
+ expect(view).toEqual({ level: 'identified', stale: false, position: usShip.position })
+ })
+})
diff --git a/src/engine/systems/__tests__/war-support.test.ts b/src/engine/systems/__tests__/war-support.test.ts
new file mode 100644
index 0000000..0641c5e
--- /dev/null
+++ b/src/engine/systems/__tests__/war-support.test.ts
@@ -0,0 +1,273 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+ processWarSupport,
+ resetWarSupportState,
+ offerCeasefire,
+ acceptCeasefire,
+ resign,
+ getWarSupport,
+ getObjectives,
+} from '../war-support'
+import type { GameEvent, GameState, NationId, ShippingLane, Unit, UnitCategory } from '@/types/game'
+
+function makeUnit(overrides: Partial & { id: string; nation: NationId }): Unit {
+ return {
+ name: overrides.id,
+ category: 'ship',
+ position: { lat: 27, lng: 52 },
+ heading: 0,
+ speed_kts: 0,
+ maxSpeed_kts: 0,
+ health: 100,
+ maxHealth: 100,
+ hardness: 100,
+ logistics: 0,
+ supplyStocks: [],
+ weapons: [],
+ pointDefense: [],
+ sensors: [],
+ roe: 'weapons_tight' as const,
+ status: 'ready' as const,
+ waypoints: [],
+ subordinateIds: [],
+ ...overrides,
+ } as Unit
+}
+
+function hormuz(status: ShippingLane['status']): ShippingLane {
+ return {
+ id: 'hormuz',
+ name: 'Strait of Hormuz',
+ path: [[56, 26], [57, 26.5]],
+ baseThroughput_mbd: 21,
+ currentThroughput_mbd: status === 'open' ? 21 : status === 'reduced' ? 10 : 0,
+ suppressionFactor: status === 'open' ? 0 : status === 'reduced' ? 0.5 : 1,
+ status,
+ }
+}
+
+function makeState(units: Unit[], opts: { atWar?: boolean; tick?: number } = {}): GameState {
+ const atWar = opts.atWar ?? true
+ return {
+ playerNation: 'usa',
+ initialized: true,
+ time: { tick: opts.tick ?? 0, timestamp: 1_000_000, speed: 1, tickIntervalMs: 100 },
+ nations: {
+ usa: {
+ id: 'usa', name: 'USA',
+ economy: { gdp_billions: 28000, military_budget_billions: 886, military_budget_pct_gdp: 3.2, oil_revenue_billions: 0, sanctions_impact: 0, war_cost_per_day_millions: 300, reserves_billions: 800, oilPrice_per_barrel: 80 },
+ relations: { usa: 100, iran: -60 }, atWar: atWar ? ['iran'] : [],
+ },
+ iran: {
+ id: 'iran', name: 'Iran',
+ economy: { gdp_billions: 400, military_budget_billions: 25, military_budget_pct_gdp: 6.3, oil_revenue_billions: 50, sanctions_impact: 0.3, war_cost_per_day_millions: 50, reserves_billions: 120, oilPrice_per_barrel: 80 },
+ relations: { usa: -60, iran: 100 }, atWar: atWar ? ['usa'] : [],
+ },
+ },
+ units: new Map(units.map(u => [u.id, u])),
+ missiles: new Map(),
+ supplyLines: new Map(),
+ shippingLanes: new Map([['hormuz', hormuz('open')]]),
+ events: [],
+ pendingEvents: [],
+ }
+}
+
+function destroyUnit(state: GameState, unitId: string): void {
+ const unit = state.units.get(unitId)!
+ unit.status = 'destroyed'
+ const event: GameEvent = { type: 'UNIT_DESTROYED', unitId, tick: state.time.tick }
+ state.events.push(event)
+ state.pendingEvents.push(event)
+}
+
+/** Advance to the next minute boundary and evaluate */
+function evalAt(state: GameState, tick: number): void {
+ state.time.tick = tick
+ processWarSupport(state)
+}
+
+function lossUnit(category: UnitCategory, id: string, nation: NationId): Unit {
+ return makeUnit({ id, nation, category })
+}
+
+beforeEach(() => {
+ resetWarSupportState()
+})
+
+describe('war support drains', () => {
+ it('drains the victim by category weight when a unit is destroyed', () => {
+ const state = makeState([lossUnit('carrier_group', 'cvn', 'usa'), lossUnit('ship', 'boat', 'iran')])
+ evalAt(state, 0)
+ destroyUnit(state, 'cvn')
+ evalAt(state, 60)
+ const support = getWarSupport(state)
+ expect(support.usa).toBeLessThanOrEqual(88)
+ expect(support.iran).toBeGreaterThan(support.usa)
+ })
+
+ it('caps kill gains at +10 total', () => {
+ const units: Unit[] = [lossUnit('ship', 'us1', 'usa')]
+ for (let i = 0; i < 30; i++) units.push(lossUnit('missile_battery', `tel${i}`, 'iran'))
+ const state = makeState(units)
+ evalAt(state, 0)
+ for (let i = 0; i < 30; i++) destroyUnit(state, `tel${i}`)
+ evalAt(state, 60)
+ expect(getWarSupport(state).usa).toBeGreaterThan(99.9)
+ expect(getWarSupport(state).iran).toBeLessThan(60)
+ })
+
+ it('drains slowly from war duration alone', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')])
+ evalAt(state, 0)
+ for (let t = 60; t <= 3600 * 10; t += 60) evalAt(state, t)
+ const support = getWarSupport(state)
+ expect(support.usa).toBeLessThan(100)
+ expect(support.usa).toBeGreaterThan(95)
+ })
+
+ it('does not drain at peace', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')], { atWar: false })
+ evalAt(state, 0)
+ for (let t = 60; t <= 3600; t += 60) evalAt(state, t)
+ expect(getWarSupport(state).usa).toBe(100)
+ })
+})
+
+describe('war termination', () => {
+ it('emits WAR_SUPPORT_CRITICAL once when crossing the threshold', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')])
+ evalAt(state, 0)
+ state.warStatus!.iran.warSupport = 34
+ state.warStatus!.iran.warStartTick = 0
+ evalAt(state, 60)
+ state.time.tick = 120
+ evalAt(state, 120)
+ const criticals = state.events.filter(e => e.type === 'WAR_SUPPORT_CRITICAL' && e.nation === 'iran')
+ expect(criticals).toHaveLength(1)
+ })
+
+ it('capitulation at 0 ends the war, sets gameOver victory for the player, holds fire', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa'), lossUnit('ship', 'ir1', 'iran')])
+ evalAt(state, 0)
+ state.warStatus!.iran.warSupport = 0.001
+ evalAt(state, 60)
+ expect(state.gameOver).toBeTruthy()
+ expect(state.gameOver!.outcome).toBe('victory')
+ expect(state.gameOver!.loser).toBe('iran')
+ expect(state.nations.usa.atWar).toHaveLength(0)
+ expect(state.nations.iran.atWar).toHaveLength(0)
+ expect(state.units.get('us1')!.roe).toBe('hold_fire')
+ expect(state.units.get('ir1')!.roe).toBe('hold_fire')
+ expect(state.events.some(e => e.type === 'WAR_ENDED' && e.outcome === 'capitulation')).toBe(true)
+ })
+
+ it('freezes war support after the war ends', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')])
+ evalAt(state, 0)
+ state.warStatus!.iran.warSupport = 0.001
+ evalAt(state, 60)
+ const after = getWarSupport(state)
+ for (let t = 120; t <= 3600; t += 60) evalAt(state, t)
+ expect(getWarSupport(state)).toEqual(after)
+ })
+
+ it('resign ends the war as a player defeat', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')])
+ evalAt(state, 0)
+ resign(state)
+ expect(state.gameOver!.outcome).toBe('defeat')
+ expect(state.gameOver!.loser).toBe('usa')
+ })
+
+ it('includes frozen stats in the gameOver report', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa'), lossUnit('ship', 'ir1', 'iran')])
+ evalAt(state, 0)
+ destroyUnit(state, 'ir1')
+ evalAt(state, 60)
+ resign(state)
+ const stats = state.gameOver!.stats
+ expect(stats.unitsLost.iran).toBe(1)
+ expect(stats.unitsLost.usa).toBe(0)
+ expect(stats.durationTicks).toBeGreaterThan(0)
+ })
+})
+
+describe('ceasefire', () => {
+ it('AI accepts when its support is lower than the offerer plus margin', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')])
+ evalAt(state, 0)
+ state.warStatus!.iran.warSupport = 50
+ state.warStatus!.usa.warSupport = 80
+ offerCeasefire(state, 'usa', 'iran')
+ expect(state.gameOver?.outcome).toBe('ceasefire')
+ expect(state.nations.usa.atWar).toHaveLength(0)
+ })
+
+ it('rejects when the target is winning, with a re-offer cooldown', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa'), makeUnit({ id: 'tel', nation: 'iran', category: 'missile_battery', weapons: [{ weaponId: 'fateh110', count: 12, maxCount: 12, reloadTimeSec: 60 }] })])
+ evalAt(state, 0)
+ state.warStatus!.iran.warSupport = 95
+ state.warStatus!.usa.warSupport = 40
+ offerCeasefire(state, 'usa', 'iran')
+ expect(state.gameOver).toBeUndefined()
+ expect(state.events.some(e => e.type === 'CEASEFIRE_REJECTED')).toBe(true)
+
+ state.warStatus!.iran.warSupport = 10
+ state.time.tick = 120
+ offerCeasefire(state, 'usa', 'iran')
+ expect(state.gameOver).toBeUndefined()
+ })
+
+ it('accepting a standing offer during war produces a ceasefire gameOver', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')])
+ evalAt(state, 0)
+ acceptCeasefire(state, 'usa', 'iran')
+ expect(state.gameOver?.outcome).toBe('ceasefire')
+ })
+
+ it('acceptCeasefire at peace is a no-op', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')], { atWar: false })
+ acceptCeasefire(state, 'usa', 'iran')
+ expect(state.gameOver).toBeUndefined()
+ })
+})
+
+describe('objectives', () => {
+ it('returns empty at peace', () => {
+ const state = makeState([lossUnit('ship', 'us1', 'usa')], { atWar: false })
+ processWarSupport(state)
+ expect(getObjectives(state)).toEqual([])
+ })
+
+ it('USA objectives track battery kills', () => {
+ const state = makeState([
+ lossUnit('carrier_group', 'cvn', 'usa'),
+ lossUnit('missile_battery', 'tel1', 'iran'),
+ lossUnit('missile_battery', 'tel2', 'iran'),
+ ])
+ evalAt(state, 0)
+ const before = getObjectives(state).find(o => o.id === 'destroy_missile_force')!
+ expect(before.progress).toBe(0)
+
+ destroyUnit(state, 'tel1')
+ evalAt(state, 60)
+ const after = getObjectives(state).find(o => o.id === 'destroy_missile_force')!
+ expect(after.progress).toBeCloseTo(0.5)
+ const carrier = getObjectives(state).find(o => o.id === 'preserve_carrier')!
+ expect(carrier.status).toBe('good')
+ })
+
+ it('freezes objectives once the war is decided', () => {
+ const state = makeState([
+ lossUnit('carrier_group', 'cvn', 'usa'),
+ lossUnit('missile_battery', 'tel1', 'iran'),
+ ])
+ evalAt(state, 0)
+ resign(state)
+ const frozen = getObjectives(state)
+ destroyUnit(state, 'tel1')
+ evalAt(state, 120)
+ expect(getObjectives(state)).toEqual(frozen)
+ })
+})
diff --git a/src/engine/systems/ai.ts b/src/engine/systems/ai.ts
index 413b15c..c37be3f 100644
--- a/src/engine/systems/ai.ts
+++ b/src/engine/systems/ai.ts
@@ -1,9 +1,10 @@
-import type { GameState, NationId } from '@/types/game'
+import type { GameState, NationId, Position, Unit } from '@/types/game'
import type { Command } from '@/types/commands'
import type { SeededRNG } from '../utils/rng'
import { weaponSpecs } from '@/data/weapons/missiles'
import { haversine, bearing } from '../utils/geo'
import { processDroneSwarm, getDroneAmmo } from './drone-ai'
+import { WAR_SUPPORT_CRITICAL_THRESHOLD } from './war-support'
type AIPhase = 'PEACETIME' | 'ALERT' | 'DEFENSIVE' | 'OFFENSIVE' | 'ATTRITION'
@@ -11,6 +12,9 @@ type AIPhase = 'PEACETIME' | 'ALERT' | 'DEFENSIVE' | 'OFFENSIVE' | 'ATTRITION'
const ALERT_DURATION_TICKS = 60
/** At war this long without escalating via retaliation → initiate OFFENSIVE anyway */
const OFFENSIVE_AFTER_WAR_TICKS = 1800
+/** Shahed-armed batteries retasked to choke the Hormuz lane while Iran is at war */
+const INTERDICTION_NATION: NationId = 'iran'
+const MAX_INTERDICTION_BATTERIES = 2
interface AIState {
phase: AIPhase
@@ -22,6 +26,8 @@ interface AIState {
lastSeenAttackCounter: number
/** Tick when this nation entered its current war (-1 = at peace) */
warStartTick: number
+ /** Shipping-interdiction batteries already tasked this war (assign once, don't thrash) */
+ interdictionAssigned: boolean
}
const aiStates = new Map()
@@ -42,6 +48,7 @@ function getAIState(nation: NationId, state: GameState): AIState {
// Seed at the current counter so a loaded save doesn't replay its whole attack history
lastSeenAttackCounter: state.attackCounters?.[nation] ?? 0,
warStartTick: -1,
+ interdictionAssigned: false,
}
aiStates.set(nation, s)
}
@@ -121,6 +128,20 @@ export function processAI(state: GameState, rng: SeededRNG): Command[] {
// Phase transitions
updatePhase(ai, state, nation.id)
+ // Collapsing war support: sue for peace and stand down offensive operations
+ const warStatus = state.warStatus?.[nation.id]
+ if (nation.atWar.length > 0 && warStatus && warStatus.warSupport <= WAR_SUPPORT_CRITICAL_THRESHOLD) {
+ if (!warStatus.ceasefireOffered) {
+ warStatus.ceasefireOffered = true
+ const event = { type: 'CEASEFIRE_OFFERED' as const, by: nation.id, tick: state.time.tick }
+ state.events.push(event)
+ state.pendingEvents.push(event)
+ }
+ if (ai.phase === 'OFFENSIVE' || ai.phase === 'ATTRITION') ai.phase = 'DEFENSIVE'
+ }
+
+ updateDroneInterdiction(ai, state, nation.id, commands)
+
// Generate commands based on phase
switch (ai.phase) {
case 'PEACETIME':
@@ -194,7 +215,10 @@ function updatePhase(ai: AIState, state: GameState, nationId: NationId): void {
if (!atWar) {
ai.warStartTick = -1
ai.salvosLaunched = 0
- ai.phase = ai.attacksReceived > 0 ? 'ALERT' : 'PEACETIME'
+ // Drop unanswered attacks too — a leftover count would re-arm units to
+ // weapons_free right after a ceasefire set everyone to hold_fire
+ ai.attacksReceived = 0
+ ai.phase = 'PEACETIME'
return
}
@@ -318,3 +342,48 @@ function countDestroyedUnits(state: GameState, nationId: NationId): number {
}
return count
}
+
+function minDistToLanePath(position: Position, path: [number, number][]): number {
+ let min = Infinity
+ for (const [lng, lat] of path) {
+ const d = haversine(position, { lat, lng })
+ if (d < min) min = d
+ }
+ return min
+}
+
+/** Drone interdiction doctrine: at war, task the shahed batteries nearest Hormuz with
+ * shipping interdiction (once per war); revert them to military strikes at peace. */
+function updateDroneInterdiction(ai: AIState, state: GameState, nationId: NationId, commands: Command[]): void {
+ if (nationId !== INTERDICTION_NATION) return
+
+ if (state.nations[nationId].atWar.length === 0) {
+ ai.interdictionAssigned = false
+ for (const unit of state.units.values()) {
+ if (unit.nation === nationId && unit.droneMission === 'shipping_interdiction') {
+ commands.push({ type: 'SET_DRONE_MISSION', unitId: unit.id, mission: 'military' })
+ }
+ }
+ return
+ }
+
+ if (ai.interdictionAssigned) return
+ const lane = state.shippingLanes.get('hormuz')
+ if (!lane) return
+
+ const candidates: { unit: Unit; dist: number }[] = []
+ for (const unit of state.units.values()) {
+ if (unit.nation !== nationId || unit.status === 'destroyed') continue
+ if (unit.category !== 'missile_battery') continue
+ if (unit.droneMission === 'shipping_interdiction') continue
+ if (!unit.weapons.some(w => w.count > 0 && w.weaponId.includes('shahed'))) continue
+ candidates.push({ unit, dist: minDistToLanePath(unit.position, lane.path) })
+ }
+ if (candidates.length === 0) return
+
+ candidates.sort((a, b) => a.dist - b.dist)
+ for (const { unit } of candidates.slice(0, MAX_INTERDICTION_BATTERIES)) {
+ commands.push({ type: 'SET_DRONE_MISSION', unitId: unit.id, mission: 'shipping_interdiction' })
+ }
+ ai.interdictionAssigned = true
+}
diff --git a/src/engine/systems/detection.ts b/src/engine/systems/detection.ts
index 6adb48e..889a97c 100644
--- a/src/engine/systems/detection.ts
+++ b/src/engine/systems/detection.ts
@@ -15,7 +15,7 @@ function radarHorizon(antennaHeightM: number, targetHeightM: number): number {
}
/** Check line-of-sight between two points using elevation grid */
-function hasLineOfSight(
+export function hasLineOfSight(
radarPos: Position, radarAltM: number,
targetLat: number, targetLng: number, targetAltM: number,
grid: ElevationGrid,
diff --git a/src/engine/systems/satellites.ts b/src/engine/systems/satellites.ts
index db22b49..c4a5ef5 100644
--- a/src/engine/systems/satellites.ts
+++ b/src/engine/systems/satellites.ts
@@ -8,7 +8,7 @@ import type { GameState, NationId, UnitId, Position } from '@/types/game'
const satelliteDetections = new Map>()
/** How many ticks a satellite detection remains visible before fading */
-const DETECTION_FADE_TICKS = 60
+export const DETECTION_FADE_TICKS = 60
/** Reset module-level state (call on save/load) */
export function resetSatelliteState(): void {
@@ -87,7 +87,7 @@ export function processSatellites(state: GameState): UnitId[] {
* for the theater scale (~2000 km). For short/medium distances in the
* Middle East theater this is accurate to within a few percent.
*/
-function pointToLineDistKm(
+export function pointToLineDistKm(
point: Position,
lineStart: Position,
lineEnd: Position,
diff --git a/src/engine/systems/visibility.ts b/src/engine/systems/visibility.ts
new file mode 100644
index 0000000..e1cdfe2
--- /dev/null
+++ b/src/engine/systems/visibility.ts
@@ -0,0 +1,372 @@
+import type {
+ GameState,
+ Nation,
+ NationId,
+ Position,
+ Unit,
+ UnitCategory,
+ UnitId,
+ VisibilityContact,
+ VisibilityLevel,
+} from '@/types/game'
+import type { ElevationGrid } from './elevation'
+import type { SensorNetwork } from './sensor-network'
+import type { EspionageResult } from './espionage'
+import { hasLineOfSight } from './detection'
+import { getSatelliteDetections, pointToLineDistKm, DETECTION_FADE_TICKS } from './satellites'
+import { haversine } from '../utils/geo'
+
+/**
+ * Fog of war. Maintains state.visibility — per observing nation, a contact map over
+ * enemy units — from radar coverage, satellites, HUMINT, ELINT and combat events.
+ * Full source evaluation runs once per game-minute; event-driven reveals (launch
+ * plumes, mine contacts) apply on the tick they happen.
+ * Design: docs/plans/game-loop-v2.md §1.
+ */
+
+const EVAL_INTERVAL_TICKS = 60
+const IDENTIFIED_DECAY_TICKS = 600
+const TRACKED_DECAY_TICKS = 600
+const DETECTED_DECAY_TICKS = 1800
+const HUMINT_STICKY_TICKS = 1800
+const RADAR_IDENTIFY_FRACTION = 0.6
+const DEFAULT_SIGINT_MULTIPLIER = 1.5
+const DEFAULT_ANTENNA_HEIGHT_M = 15
+const TARGET_HEIGHT_M = 10
+
+const LEVEL_RANK: Record = { unseen: 0, detected: 1, tracked: 2, identified: 3 }
+
+interface ContactMeta {
+ /** Level at lastSeenTick — decay thresholds are cumulative from this anchor */
+ anchor: VisibilityLevel
+ /** HUMINT reveals keep the contact identified until this tick */
+ humintUntil: number
+}
+
+const metaByObserver = new Map>()
+
+function metaFor(observer: string): Map {
+ let m = metaByObserver.get(observer)
+ if (!m) {
+ m = new Map()
+ metaByObserver.set(observer, m)
+ }
+ return m
+}
+
+export function processVisibility(
+ state: GameState,
+ _network: SensorNetwork | null,
+ espionage: EspionageResult | null,
+ grid: ElevationGrid | null,
+): void {
+ if (state.time.tick % EVAL_INTERVAL_TICKS === 0) {
+ evaluateSources(state, espionage, grid)
+ }
+ applyEventReveals(state)
+}
+
+export function resetVisibilityState(): void {
+ metaByObserver.clear()
+}
+
+// ---------------------------------------------------------------------------
+// Per-minute source evaluation
+// ---------------------------------------------------------------------------
+
+function evaluateSources(state: GameState, espionage: EspionageResult | null, grid: ElevationGrid | null): void {
+ const tick = state.time.tick
+ state.visibility ??= {}
+
+ for (const nation of Object.values(state.nations)) {
+ const contacts = (state.visibility[nation.id as string] ??= {})
+ const meta = metaFor(nation.id as string)
+
+ const ownRadars: Unit[] = []
+ const ownSensorUnits: Unit[] = []
+ for (const u of state.units.values()) {
+ if (u.nation !== nation.id || u.status === 'destroyed' || u.sensors.length === 0) continue
+ ownSensorUnits.push(u)
+ if (u.sensors.some(s => s.type === 'radar' && s.range_km > 0)) ownRadars.push(u)
+ }
+
+ const humint = espionage?.humintRevealed.get(nation.id)
+ if (humint) {
+ for (const unitId of humint) {
+ const m = meta.get(unitId)
+ if (m) m.humintUntil = tick + HUMINT_STICKY_TICKS
+ else meta.set(unitId, { anchor: 'unseen', humintUntil: tick + HUMINT_STICKY_TICKS })
+ }
+ }
+ const sigintMultiplier = espionage?.sigintMultiplier.get(nation.id) ?? DEFAULT_SIGINT_MULTIPLIER
+ const satDetections = getSatelliteDetections(nation.id, tick)
+
+ for (const unit of state.units.values()) {
+ if (unit.nation === nation.id) continue
+
+ let best: VisibilityLevel = 'unseen'
+ if (unit.status !== 'destroyed') {
+ best = radarContactLevel(ownRadars, unit, grid)
+ if (satDetections.has(unit.id)) {
+ best = maxLevel(best, satelliteContactLevel(nation, unit, tick))
+ }
+ if ((meta.get(unit.id)?.humintUntil ?? 0) > tick) {
+ best = 'identified'
+ }
+ if (best === 'unseen' && isElintDetected(ownSensorUnits, unit, sigintMultiplier)) {
+ best = 'detected'
+ }
+ }
+
+ const contact = contacts[unit.id]
+ if (!contact) {
+ if (best !== 'unseen') contacts[unit.id] = newContact(meta, unit, best, tick)
+ continue
+ }
+
+ const anchor = anchorOf(contact, meta.get(unit.id))
+ const floor = decayFloor(unit, contact, anchor)
+ let decayed = decayedLevel(anchor, tick - contact.lastSeenTick)
+ if (LEVEL_RANK[decayed] < LEVEL_RANK[floor]) decayed = floor
+
+ if (best !== 'unseen' && LEVEL_RANK[best] >= LEVEL_RANK[decayed]) {
+ refreshContact(contact, meta, unit, best, tick)
+ } else if (decayed === 'unseen') {
+ delete contacts[unit.id]
+ meta.delete(unit.id)
+ } else {
+ contact.level = decayed
+ contact.pinned = floor !== 'unseen'
+ }
+ }
+ }
+}
+
+function radarContactLevel(ownRadars: Unit[], target: Unit, grid: ElevationGrid | null): VisibilityLevel {
+ let best: VisibilityLevel = 'unseen'
+ for (const radar of ownRadars) {
+ let range = 0
+ let antennaHeight = DEFAULT_ANTENNA_HEIGHT_M
+ for (const s of radar.sensors) {
+ if (s.type === 'radar' && s.range_km > range) {
+ range = s.range_km
+ antennaHeight = s.antenna_height_m ?? DEFAULT_ANTENNA_HEIGHT_M
+ }
+ }
+ const dist = haversine(radar.position, target.position)
+ if (dist > range) continue
+ if (grid) {
+ const radarAltM = grid.getElevation(radar.position.lat, radar.position.lng) + antennaHeight
+ const targetAltM = grid.getElevation(target.position.lat, target.position.lng) + TARGET_HEIGHT_M
+ if (!hasLineOfSight(radar.position, radarAltM, target.position.lat, target.position.lng, targetAltM, grid)) {
+ continue
+ }
+ }
+ if (dist <= range * RADAR_IDENTIFY_FRACTION) return 'identified'
+ best = 'tracked'
+ }
+ return best
+}
+
+function satelliteContactLevel(nation: Nation, unit: Unit, tick: number): VisibilityLevel {
+ for (const sat of nation.satellites ?? []) {
+ if (sat.type !== 'optical') continue
+ if (tick - sat.lastPassTick > DETECTION_FADE_TICKS) continue
+ const start = { lat: sat.groundTrack.startLat, lng: sat.groundTrack.startLng }
+ const end = { lat: sat.groundTrack.endLat, lng: sat.groundTrack.endLng }
+ if (pointToLineDistKm(unit.position, start, end) <= sat.swathWidth_km / 2) return 'tracked'
+ }
+ return 'detected'
+}
+
+function isElintDetected(ownSensorUnits: Unit[], emitter: Unit, sigintMultiplier: number): boolean {
+ let radarRange = 0
+ for (const s of emitter.sensors) {
+ if (s.type === 'radar' && s.range_km > radarRange) radarRange = s.range_km
+ }
+ if (radarRange <= 0) return false
+ const elintRange = radarRange * sigintMultiplier
+ for (const own of ownSensorUnits) {
+ if (haversine(own.position, emitter.position) <= elintRange) return true
+ }
+ return false
+}
+
+// ---------------------------------------------------------------------------
+// Event-driven reveals — applied every tick on the tick they happen
+// ---------------------------------------------------------------------------
+
+function applyEventReveals(state: GameState): void {
+ const tick = state.time.tick
+ const events = state.events
+ for (let i = events.length - 1; i >= 0; i--) {
+ const e = events[i]
+ if (e.tick !== tick) break
+ if (e.type === 'MISSILE_LAUNCHED') {
+ const launcher = state.units.get(e.launcherId)
+ if (!launcher) continue
+ for (const nation of Object.values(state.nations)) {
+ if (nation.id !== launcher.nation) {
+ revealContact(state, nation.id as string, launcher, 'tracked')
+ }
+ }
+ } else if (e.type === 'MINE_CONTACT') {
+ const minefield = state.units.get(e.minefieldId)
+ const target = state.units.get(e.targetId)
+ if (minefield && target && target.nation !== minefield.nation) {
+ revealContact(state, target.nation as string, minefield, 'identified')
+ }
+ }
+ }
+}
+
+function revealContact(state: GameState, observer: string, unit: Unit, level: VisibilityLevel): void {
+ const tick = state.time.tick
+ state.visibility ??= {}
+ const contacts = (state.visibility[observer] ??= {})
+ const meta = metaFor(observer)
+
+ const contact = contacts[unit.id]
+ if (!contact) {
+ contacts[unit.id] = newContact(meta, unit, level, tick)
+ return
+ }
+ const anchor = anchorOf(contact, meta.get(unit.id))
+ const floor = decayFloor(unit, contact, anchor)
+ let decayed = decayedLevel(anchor, tick - contact.lastSeenTick)
+ if (LEVEL_RANK[decayed] < LEVEL_RANK[floor]) decayed = floor
+ if (LEVEL_RANK[level] >= LEVEL_RANK[decayed]) {
+ refreshContact(contact, meta, unit, level, tick)
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Contact bookkeeping
+// ---------------------------------------------------------------------------
+
+function newContact(meta: Map, unit: Unit, level: VisibilityLevel, tick: number): VisibilityContact {
+ const contact: VisibilityContact = {
+ level,
+ lastSeenTick: tick,
+ lastKnownPosition: { ...unit.position },
+ }
+ setAnchor(meta, unit.id, level)
+ contact.pinned = decayFloor(unit, contact, level) !== 'unseen'
+ return contact
+}
+
+function refreshContact(
+ contact: VisibilityContact,
+ meta: Map,
+ unit: Unit,
+ level: VisibilityLevel,
+ tick: number,
+): void {
+ contact.level = level
+ contact.lastSeenTick = tick
+ contact.lastKnownPosition = { ...unit.position }
+ setAnchor(meta, unit.id, level)
+ contact.pinned = decayFloor(unit, contact, level) !== 'unseen'
+}
+
+function setAnchor(meta: Map, unitId: UnitId, level: VisibilityLevel): void {
+ const m = meta.get(unitId)
+ if (m) m.anchor = level
+ else meta.set(unitId, { anchor: level, humintUntil: 0 })
+}
+
+function anchorOf(contact: VisibilityContact, m: ContactMeta | undefined): VisibilityLevel {
+ // After save/load the meta map is empty — fall back to the loaded level
+ return m && m.anchor !== 'unseen' ? m.anchor : contact.level
+}
+
+function maxLevel(a: VisibilityLevel, b: VisibilityLevel): VisibilityLevel {
+ return LEVEL_RANK[a] >= LEVEL_RANK[b] ? a : b
+}
+
+// ---------------------------------------------------------------------------
+// Decay
+// ---------------------------------------------------------------------------
+
+function decayedLevel(anchor: VisibilityLevel, age: number): VisibilityLevel {
+ if (anchor === 'identified') {
+ if (age < IDENTIFIED_DECAY_TICKS) return 'identified'
+ if (age < IDENTIFIED_DECAY_TICKS + TRACKED_DECAY_TICKS) return 'tracked'
+ if (age < IDENTIFIED_DECAY_TICKS + TRACKED_DECAY_TICKS + DETECTED_DECAY_TICKS) return 'detected'
+ return 'unseen'
+ }
+ if (anchor === 'tracked') {
+ if (age < TRACKED_DECAY_TICKS) return 'tracked'
+ if (age < TRACKED_DECAY_TICKS + DETECTED_DECAY_TICKS) return 'detected'
+ return 'unseen'
+ }
+ if (anchor === 'detected') {
+ return age < DETECTED_DECAY_TICKS ? 'detected' : 'unseen'
+ }
+ return 'unseen'
+}
+
+/** Lowest level this contact may decay to — fixed sites don't walk away */
+function decayFloor(unit: Unit, contact: VisibilityContact, anchor: VisibilityLevel): VisibilityLevel {
+ const everIdentified = contact.level === 'identified' || anchor === 'identified'
+ switch (unit.category) {
+ case 'airbase':
+ case 'naval_base':
+ return everIdentified ? 'identified' : 'detected'
+ case 'minefield':
+ return everIdentified ? 'identified' : 'unseen'
+ case 'sam_site': {
+ const p = contact.lastKnownPosition
+ const moved = unit.position.lng !== p.lng || unit.position.lat !== p.lat
+ return moved ? 'unseen' : 'detected'
+ }
+ default:
+ return 'unseen'
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Snapshot queries
+// ---------------------------------------------------------------------------
+
+export interface ViewVisibility {
+ level: VisibilityLevel
+ stale: boolean
+ /** Position to show the observer (lastKnownPosition when the live track is lost) */
+ position: Position
+}
+
+/**
+ * How `observer` currently sees `unit`. Returns null when the unit should be excluded
+ * from the observer's snapshot entirely (level 'unseen').
+ */
+export function getViewVisibility(state: GameState, observer: NationId, unit: Unit): ViewVisibility | null {
+ if (unit.nation === observer) {
+ return { level: 'identified', stale: false, position: unit.position }
+ }
+ const contact = state.visibility?.[observer as string]?.[unit.id]
+ if (!contact || contact.level === 'unseen') return null
+ const live = contact.level === 'tracked' || contact.level === 'identified'
+ return {
+ level: contact.level,
+ stale: !live,
+ position: live ? unit.position : contact.lastKnownPosition,
+ }
+}
+
+const CONTACT_NAMES: Record = {
+ airbase: 'Unknown installation',
+ naval_base: 'Unknown installation',
+ sam_site: 'Unknown emitter',
+ missile_battery: 'Unknown vehicle group',
+ aircraft: 'Air contact',
+ ship: 'Surface contact',
+ submarine: 'Submerged contact',
+ carrier_group: 'Surface group',
+ minefield: 'Suspected minefield',
+}
+
+/** Generic display name for a low-confidence contact */
+export function contactDisplayName(category: UnitCategory): string {
+ return CONTACT_NAMES[category] ?? 'Unknown contact'
+}
diff --git a/src/engine/systems/war-support.ts b/src/engine/systems/war-support.ts
new file mode 100644
index 0000000..3113842
--- /dev/null
+++ b/src/engine/systems/war-support.ts
@@ -0,0 +1,476 @@
+import type { GameEvent, GameState, NationId, UnitCategory, WarStats } from '@/types/game'
+import type { ObjectiveStatus } from '@/types/view'
+import { weaponSpecs } from '@/data/weapons/missiles'
+
+/**
+ * War support (political will) and war termination: drains from losses, duration and
+ * economic pain; capitulation at 0; ceasefire offers/acceptance; scenario objectives;
+ * the GameOverReport for the debrief screen. Design: docs/plans/game-loop-v2.md §2.
+ */
+
+// ─── Tuning (design §2) ─────────────────────────────────────────
+export const WAR_SUPPORT_CRITICAL_THRESHOLD = 35
+
+const EVAL_INTERVAL_TICKS = 60
+const TICKS_PER_HOUR = 3_600
+const HORMUZ_LANE_ID = 'hormuz'
+
+const UNIT_LOSS_DRAIN: Record = {
+ carrier_group: 12,
+ naval_base: 6,
+ airbase: 6,
+ ship: 4,
+ submarine: 4,
+ sam_site: 2,
+ missile_battery: 1.5,
+ aircraft: 1,
+ minefield: 0.5,
+}
+const WAR_DURATION_DRAIN_PER_HOUR = 0.15
+const LOW_RESERVES_FRACTION = 0.25
+const LOW_RESERVES_DRAIN_PER_HOUR = 0.3
+const OIL_PRICE_DRAIN_THRESHOLD = 110
+const OIL_PRICE_DRAIN_PER_HOUR = 0.2
+const HORMUZ_BLOCKED_DRAIN_PER_HOUR = 0.2
+const KILL_GAIN = 0.5
+const KILL_GAIN_CAP = 10
+const CEASEFIRE_ACCEPT_MARGIN = 10
+const CEASEFIRE_LOW_STOCK_FRACTION = 0.25
+const CEASEFIRE_REOFFER_COOLDOWN_TICKS = 6 * TICKS_PER_HOUR
+const OBJECTIVE_GOOD_THRESHOLD = 0.66
+const OBJECTIVE_CONTESTED_THRESHOLD = 0.33
+
+// ─── Module-level state — must be resettable for save/load ──────
+
+interface WarBaselines {
+ reservesAtStart: Record
+ offensiveStockAtStart: Record
+ iranBatteries: number
+ usaNavalUnits: number
+}
+
+let seeded = false
+let lastSeenEvent: GameEvent | null = null
+let stats: WarStats = emptyStats()
+let baselines: WarBaselines | null = null
+let killGains: Record = {}
+let criticalEmitted: Record = {}
+let lastRejectionTick: Record = {}
+let cachedObjectives: ObjectiveStatus[] = []
+let cachedObjectivesBucket = -1
+let frozenObjectives: ObjectiveStatus[] | null = null
+
+function emptyStats(): WarStats {
+ return {
+ durationTicks: 0,
+ unitsLost: {},
+ missilesFired: {},
+ missilesIntercepted: {},
+ oilPeak: 0,
+ hormuzReducedTicks: 0,
+ hormuzBlockedTicks: 0,
+ }
+}
+
+export function resetWarSupportState(): void {
+ seeded = false
+ lastSeenEvent = null
+ stats = emptyStats()
+ baselines = null
+ killGains = {}
+ criticalEmitted = {}
+ lastRejectionTick = {}
+ cachedObjectives = []
+ cachedObjectivesBucket = -1
+ frozenObjectives = null
+}
+
+// ─── Event watermark over state.events ──────────────────────────
+
+// A loaded save's warStatus already accounts for its event history; a fresh game
+// (no warStatus yet) must count everything emitted since init.
+function seedWatermark(state: GameState): void {
+ seeded = true
+ if (state.warStatus !== undefined && state.events.length > 0) {
+ lastSeenEvent = state.events[state.events.length - 1]
+ }
+}
+
+// The 2000-event cap only ever splices a prefix, so if the watermark object is gone
+// everything older is gone with it and the whole remaining array is unseen.
+function takeNewEvents(state: GameState): GameEvent[] {
+ const events = state.events
+ let start = 0
+ if (lastSeenEvent) {
+ for (let i = events.length - 1; i >= 0; i--) {
+ if (events[i] === lastSeenEvent) {
+ start = i + 1
+ break
+ }
+ }
+ }
+ const fresh = events.slice(start)
+ if (events.length > 0) lastSeenEvent = events[events.length - 1]
+ return fresh
+}
+
+function emit(state: GameState, event: GameEvent): void {
+ state.events.push(event)
+ if (state.events.length > 2000) {
+ state.events.splice(0, state.events.length - 2000)
+ }
+ state.pendingEvents.push(event)
+}
+
+// ─── Helpers ────────────────────────────────────────────────────
+
+function clampSupport(value: number): number {
+ return Math.min(100, Math.max(0, value))
+}
+
+function clamp01(value: number): number {
+ return Math.min(1, Math.max(0, value))
+}
+
+function isNavalCategory(category: UnitCategory): boolean {
+ return category === 'ship' || category === 'submarine' || category === 'carrier_group'
+}
+
+function countOffensiveMissiles(state: GameState, nationId: string): number {
+ let total = 0
+ for (const unit of state.units.values()) {
+ if (unit.nation !== nationId || unit.status === 'destroyed') continue
+ for (const w of unit.weapons) {
+ const spec = weaponSpecs[w.weaponId]
+ if (spec && spec.type !== 'sam') total += w.count
+ }
+ }
+ return total
+}
+
+function ensureBaselines(state: GameState): void {
+ if (baselines) return
+ const reservesAtStart: Record = {}
+ const offensiveStockAtStart: Record = {}
+ for (const nation of Object.values(state.nations)) {
+ reservesAtStart[nation.id] = nation.economy.reserves_billions
+ offensiveStockAtStart[nation.id] = countOffensiveMissiles(state, nation.id)
+ }
+ let iranBatteries = 0
+ let usaNavalUnits = 0
+ for (const unit of state.units.values()) {
+ if (unit.status === 'destroyed') continue
+ if (unit.nation === 'iran' && unit.category === 'missile_battery') iranBatteries++
+ if (unit.nation === 'usa' && isNavalCategory(unit.category)) usaNavalUnits++
+ }
+ baselines = { reservesAtStart, offensiveStockAtStart, iranBatteries, usaNavalUnits }
+}
+
+function detectWarStarts(state: GameState): void {
+ for (const nation of Object.values(state.nations)) {
+ if (nation.atWar.length === 0) continue
+ const ws = (state.warStatus ??= {})
+ const status = (ws[nation.id] ??= { warSupport: 100 })
+ if (status.warStartTick == null) {
+ status.warStartTick = state.time.tick
+ ensureBaselines(state)
+ }
+ }
+}
+
+// ─── Per-minute evaluation ──────────────────────────────────────
+
+export function processWarSupport(state: GameState): void {
+ if (!seeded) seedWatermark(state)
+ detectWarStarts(state)
+ if (state.time.tick % EVAL_INTERVAL_TICKS !== 0) return
+ evaluate(state)
+}
+
+function evaluate(state: GameState): void {
+ const tick = state.time.tick
+ const newEvents = takeNewEvents(state)
+ const ws = (state.warStatus ??= {})
+
+ for (const e of newEvents) {
+ switch (e.type) {
+ case 'MISSILE_LAUNCHED': {
+ const nation = state.units.get(e.launcherId)?.nation
+ if (nation) stats.missilesFired[nation] = (stats.missilesFired[nation] ?? 0) + 1
+ break
+ }
+ case 'MISSILE_INTERCEPTED': {
+ const nation = state.units.get(e.interceptorId)?.nation
+ if (nation) stats.missilesIntercepted[nation] = (stats.missilesIntercepted[nation] ?? 0) + 1
+ break
+ }
+ case 'POINT_DEFENSE_KILL': {
+ const nation = state.units.get(e.unitId)?.nation
+ if (nation) stats.missilesIntercepted[nation] = (stats.missilesIntercepted[nation] ?? 0) + 1
+ break
+ }
+ case 'UNIT_DESTROYED': {
+ const unit = state.units.get(e.unitId)
+ if (!unit) break
+ stats.unitsLost[unit.nation] = (stats.unitsLost[unit.nation] ?? 0) + 1
+ const victim = state.nations[unit.nation]
+ if (!victim || victim.atWar.length === 0) break
+ const status = (ws[unit.nation] ??= { warSupport: 100 })
+ status.warSupport = clampSupport(status.warSupport - UNIT_LOSS_DRAIN[unit.category])
+ for (const enemyId of victim.atWar) {
+ const gained = killGains[enemyId] ?? 0
+ const gain = Math.min(KILL_GAIN, KILL_GAIN_CAP - gained)
+ if (gain <= 0) continue
+ killGains[enemyId] = gained + gain
+ const enemyStatus = (ws[enemyId] ??= { warSupport: 100 })
+ enemyStatus.warSupport = clampSupport(enemyStatus.warSupport + gain)
+ }
+ break
+ }
+ }
+ }
+
+ const lane = state.shippingLanes.get(HORMUZ_LANE_ID)
+ let anyWar = false
+ for (const nation of Object.values(state.nations)) {
+ if (nation.atWar.length === 0) continue
+ anyWar = true
+ const status = (ws[nation.id] ??= { warSupport: 100 })
+ let drainPerHour = WAR_DURATION_DRAIN_PER_HOUR
+ const startReserves = baselines?.reservesAtStart[nation.id]
+ if (startReserves != null && startReserves > 0 &&
+ nation.economy.reserves_billions < startReserves * LOW_RESERVES_FRACTION) {
+ drainPerHour += LOW_RESERVES_DRAIN_PER_HOUR
+ }
+ if (nation.id === 'usa' && (nation.economy.oilPrice_per_barrel ?? 0) > OIL_PRICE_DRAIN_THRESHOLD) {
+ drainPerHour += OIL_PRICE_DRAIN_PER_HOUR
+ }
+ if (nation.id === 'iran' && lane?.status === 'blocked') {
+ drainPerHour += HORMUZ_BLOCKED_DRAIN_PER_HOUR
+ }
+ status.warSupport = clampSupport(status.warSupport - drainPerHour * (EVAL_INTERVAL_TICKS / TICKS_PER_HOUR))
+ }
+
+ if (anyWar) {
+ const oil = Object.values(state.nations)[0]?.economy.oilPrice_per_barrel
+ if (oil != null) stats.oilPeak = Math.max(stats.oilPeak, oil)
+ if (lane?.status === 'blocked') stats.hormuzBlockedTicks += EVAL_INTERVAL_TICKS
+ else if (lane?.status === 'reduced') stats.hormuzReducedTicks += EVAL_INTERVAL_TICKS
+ }
+
+ for (const nation of Object.values(state.nations)) {
+ if (nation.atWar.length === 0) continue
+ const status = ws[nation.id]
+ if (!status) continue
+ if (status.warSupport <= WAR_SUPPORT_CRITICAL_THRESHOLD) {
+ if (!criticalEmitted[nation.id]) {
+ criticalEmitted[nation.id] = true
+ emit(state, { type: 'WAR_SUPPORT_CRITICAL', nation: nation.id, support: status.warSupport, tick })
+ }
+ } else {
+ criticalEmitted[nation.id] = false
+ }
+ if (status.warSupport <= 0) {
+ endWar(state, 'capitulation', nation.id, [nation.id, ...nation.atWar])
+ break
+ }
+ }
+}
+
+// ─── War termination ────────────────────────────────────────────
+
+function endWar(
+ state: GameState,
+ outcome: 'capitulation' | 'ceasefire',
+ loser: NationId | undefined,
+ participants: NationId[],
+): void {
+ const tick = state.time.tick
+ const involved = [...new Set(participants)]
+
+ if (!state.gameOver) frozenObjectives = computeObjectives(state)
+
+ let warStart = Infinity
+ for (const id of involved) {
+ const start = state.warStatus?.[id]?.warStartTick
+ if (start != null && start < warStart) warStart = start
+ }
+ const durationTicks = Number.isFinite(warStart) ? tick - warStart : 0
+
+ for (const id of involved) {
+ const nation = state.nations[id]
+ if (nation) nation.atWar = nation.atWar.filter(other => !involved.includes(other))
+ const status = state.warStatus?.[id]
+ if (status) {
+ status.ceasefireOffered = false
+ status.warStartTick = undefined
+ }
+ delete killGains[id]
+ delete criticalEmitted[id]
+ }
+
+ for (const unit of state.units.values()) {
+ if (involved.includes(unit.nation)) unit.roe = 'hold_fire'
+ }
+
+ emit(state, { type: 'WAR_ENDED', outcome, loser, tick })
+
+ if (!state.gameOver) {
+ state.gameOver = {
+ outcome: outcome === 'ceasefire' ? 'ceasefire' : loser === state.playerNation ? 'defeat' : 'victory',
+ loser,
+ endTick: tick,
+ stats: freezeStats(durationTicks, involved),
+ }
+ }
+
+ baselines = null
+}
+
+function freezeStats(durationTicks: number, involved: NationId[]): WarStats {
+ const fill = (record: Record): Record => {
+ const out: Record = {}
+ for (const id of involved) out[id] = record[id] ?? 0
+ for (const [key, value] of Object.entries(record)) out[key] = value
+ return out
+ }
+ return {
+ durationTicks,
+ unitsLost: fill(stats.unitsLost),
+ missilesFired: fill(stats.missilesFired),
+ missilesIntercepted: fill(stats.missilesIntercepted),
+ oilPeak: stats.oilPeak,
+ hormuzReducedTicks: stats.hormuzReducedTicks,
+ hormuzBlockedTicks: stats.hormuzBlockedTicks,
+ }
+}
+
+/** Player (or AI) puts a ceasefire offer on the table; the other side decides */
+export function offerCeasefire(state: GameState, by: NationId, target: NationId): void {
+ const offerer = state.nations[by]
+ const decider = state.nations[target]
+ if (!offerer || !decider) return
+ if (!offerer.atWar.includes(target)) return
+
+ const tick = state.time.tick
+ const lastRejection = lastRejectionTick[by]
+ if (lastRejection != null && tick - lastRejection < CEASEFIRE_REOFFER_COOLDOWN_TICKS) return
+
+ ensureBaselines(state)
+ const support = getWarSupport(state)
+ const stockNow = countOffensiveMissiles(state, target)
+ const stockAtStart = baselines?.offensiveStockAtStart[target] ?? stockNow
+ const lowStock = stockNow < stockAtStart * CEASEFIRE_LOW_STOCK_FRACTION
+ const accepts = support[target] < support[by] + CEASEFIRE_ACCEPT_MARGIN || lowStock
+
+ if (accepts) {
+ endWar(state, 'ceasefire', undefined, [by, target])
+ } else {
+ lastRejectionTick[by] = tick
+ emit(state, { type: 'CEASEFIRE_REJECTED', by: target, tick })
+ }
+}
+
+/** Accept a standing offer (or mutually stand down) — ends the war between the two nations */
+export function acceptCeasefire(state: GameState, by: NationId, target: NationId): void {
+ const a = state.nations[by]
+ const b = state.nations[target]
+ if (!a || !b) return
+ if (a.atWar.includes(target) || b.atWar.includes(by)) {
+ endWar(state, 'ceasefire', undefined, [by, target])
+ return
+ }
+ a.atWar = a.atWar.filter(n => n !== target)
+ b.atWar = b.atWar.filter(n => n !== by)
+}
+
+/** Player gives up — immediate defeat */
+export function resign(state: GameState): void {
+ const player = state.playerNation
+ const nation = state.nations[player]
+ if (!nation) return
+ endWar(state, 'capitulation', player, [player, ...nation.atWar])
+}
+
+/** Current war support per nation id (defaults to 100 before any war) */
+export function getWarSupport(state: GameState): Record {
+ const out: Record = {}
+ for (const id of Object.keys(state.nations)) {
+ out[id] = state.warStatus?.[id]?.warSupport ?? 100
+ }
+ return out
+}
+
+// ─── Objectives ─────────────────────────────────────────────────
+
+/** Scenario objectives for the player's side (empty at peace; frozen once the war is decided) */
+export function getObjectives(state: GameState): ObjectiveStatus[] {
+ if (state.gameOver) return frozenObjectives ?? []
+ const bucket = Math.floor(state.time.tick / EVAL_INTERVAL_TICKS)
+ if (bucket !== cachedObjectivesBucket) {
+ cachedObjectivesBucket = bucket
+ cachedObjectives = computeObjectives(state)
+ }
+ return cachedObjectives
+}
+
+function computeObjectives(state: GameState): ObjectiveStatus[] {
+ const player = state.playerNation
+ if (player !== 'usa' && player !== 'iran') return []
+ const nation = state.nations[player]
+ const warStartTick = state.warStatus?.[player]?.warStartTick
+ if (!nation || nation.atWar.length === 0 || warStartTick == null) return []
+ ensureBaselines(state)
+
+ const warTicks = Math.max(1, state.time.tick - warStartTick)
+ let aliveIranBatteries = 0
+ let aliveUsaNaval = 0
+ let usaCarrierLost = false
+ for (const unit of state.units.values()) {
+ const destroyed = unit.status === 'destroyed'
+ if (unit.nation === 'iran' && unit.category === 'missile_battery' && !destroyed) aliveIranBatteries++
+ if (unit.nation === 'usa' && isNavalCategory(unit.category) && !destroyed) aliveUsaNaval++
+ if (unit.nation === 'usa' && unit.category === 'carrier_group' && destroyed) usaCarrierLost = true
+ }
+ const initialIranBatteries = baselines?.iranBatteries ?? aliveIranBatteries
+ const initialUsaNaval = baselines?.usaNavalUnits ?? aliveUsaNaval
+
+ if (player === 'usa') {
+ const openShare = clamp01(1 - stats.hormuzBlockedTicks / warTicks)
+ const batteriesKilled = Math.max(0, initialIranBatteries - aliveIranBatteries)
+ const batteryProgress = initialIranBatteries > 0 ? clamp01(batteriesKilled / initialIranBatteries) : 1
+ return [
+ objective('hormuz_open', 'Keep Hormuz open', openShare,
+ `Open ${Math.round(openShare * 100)}% of the war`),
+ objective('destroy_missile_force', "Destroy Iran's strategic missile force", batteryProgress,
+ `${batteriesKilled}/${initialIranBatteries} batteries destroyed`),
+ objective('preserve_carrier', 'Preserve the carrier group', usaCarrierLost ? 0 : 1,
+ usaCarrierLost ? 'Carrier group lost' : 'Carrier group intact'),
+ ]
+ }
+
+ const closedShare = clamp01((stats.hormuzBlockedTicks + stats.hormuzReducedTicks) / warTicks)
+ const navalKilled = Math.max(0, initialUsaNaval - aliveUsaNaval)
+ const attritionProgress = initialUsaNaval > 0 ? clamp01(navalKilled / initialUsaNaval) : 1
+ const preserveProgress = initialIranBatteries > 0 ? clamp01(aliveIranBatteries / initialIranBatteries) : 1
+ return [
+ objective('close_strait', 'Close the Strait', closedShare,
+ `Disrupted ${Math.round(closedShare * 100)}% of the war`),
+ objective('attrit_us_fleet', 'Attrit the US fleet', attritionProgress,
+ `${navalKilled}/${initialUsaNaval} US naval units destroyed`),
+ objective('preserve_strategic', 'Preserve strategic forces', preserveProgress,
+ `${aliveIranBatteries}/${initialIranBatteries} batteries surviving`),
+ ]
+}
+
+function objective(id: string, label: string, progress: number, detail: string): ObjectiveStatus {
+ return {
+ id,
+ label,
+ progress,
+ status: progress >= OBJECTIVE_GOOD_THRESHOLD ? 'good'
+ : progress >= OBJECTIVE_CONTESTED_THRESHOLD ? 'contested'
+ : 'bad',
+ detail,
+ }
+}
diff --git a/src/store/__tests__/game-store.test.ts b/src/store/__tests__/game-store.test.ts
index 0073c3e..8e65d04 100644
--- a/src/store/__tests__/game-store.test.ts
+++ b/src/store/__tests__/game-store.test.ts
@@ -19,6 +19,9 @@ function makeViewState(
events: [],
pendingEventCount: 0,
satelliteDetectedUnitIds: [],
+ warSupport: {},
+ gameOver: null,
+ objectives: [],
...overrides,
}
}
diff --git a/src/store/__tests__/ui-store.test.ts b/src/store/__tests__/ui-store.test.ts
index 1ea2973..e0cee06 100644
--- a/src/store/__tests__/ui-store.test.ts
+++ b/src/store/__tests__/ui-store.test.ts
@@ -17,6 +17,10 @@ beforeEach(() => {
if (store.mapMode !== 'dark') store.cycleMapMode()
// Reset left panel
store.setLeftPanel(null)
+ useUIStore.setState({
+ mapFocus: null,
+ autoPause: { warDeclared: true, ownUnitDestroyed: true, ceasefireOffered: true },
+ })
})
// ── Selection tests ───────────────────────────────────────────────
@@ -190,6 +194,47 @@ describe('toggleIntel', () => {
})
})
+// ── Map focus tests ───────────────────────────────────────────────
+
+describe('focusMap', () => {
+ it('stores the requested focus with an incrementing nonce', () => {
+ useUIStore.getState().focusMap(56.3, 26.5, 7)
+ expect(useUIStore.getState().mapFocus).toEqual({ lng: 56.3, lat: 26.5, zoom: 7, nonce: 1 })
+
+ useUIStore.getState().focusMap(56.3, 26.5, 7)
+ expect(useUIStore.getState().mapFocus?.nonce).toBe(2)
+ })
+
+ it('allows omitting zoom', () => {
+ useUIStore.getState().focusMap(55, 25)
+ expect(useUIStore.getState().mapFocus).toMatchObject({ lng: 55, lat: 25, zoom: undefined })
+ })
+})
+
+// ── Auto-pause tests ──────────────────────────────────────────────
+
+describe('toggleAutoPause', () => {
+ it('defaults all triggers on', () => {
+ expect(useUIStore.getState().autoPause).toEqual({
+ warDeclared: true,
+ ownUnitDestroyed: true,
+ ceasefireOffered: true,
+ })
+ })
+
+ it('flips one trigger without touching the others', () => {
+ useUIStore.getState().toggleAutoPause('ownUnitDestroyed')
+ expect(useUIStore.getState().autoPause).toEqual({
+ warDeclared: true,
+ ownUnitDestroyed: false,
+ ceasefireOffered: true,
+ })
+
+ useUIStore.getState().toggleAutoPause('ownUnitDestroyed')
+ expect(useUIStore.getState().autoPause.ownUnitDestroyed).toBe(true)
+ })
+})
+
// ── Left panel tests ──────────────────────────────────────────────
describe('setLeftPanel', () => {
diff --git a/src/store/game-store.ts b/src/store/game-store.ts
index 8ff8810..6dc3d88 100644
--- a/src/store/game-store.ts
+++ b/src/store/game-store.ts
@@ -19,6 +19,9 @@ const emptyViewState: GameViewState = {
events: [],
pendingEventCount: 0,
satelliteDetectedUnitIds: [],
+ warSupport: {},
+ gameOver: null,
+ objectives: [],
}
interface GameStore {
diff --git a/src/store/ui-store.ts b/src/store/ui-store.ts
index 49868fb..8ac4fbd 100644
--- a/src/store/ui-store.ts
+++ b/src/store/ui-store.ts
@@ -4,6 +4,20 @@ import type { MapMode } from '@/styles/map-providers'
export type LeftPanel = 'orbat' | 'stats' | 'economy' | null
+export interface MapFocus {
+ lng: number
+ lat: number
+ zoom?: number
+ /** Increments per request so refocusing the same spot still triggers consumers */
+ nonce: number
+}
+
+export interface AutoPauseSettings {
+ warDeclared: boolean
+ ownUnitDestroyed: boolean
+ ceasefireOffered: boolean
+}
+
interface UIState {
// Selection
selectedUnitIds: Set
@@ -27,6 +41,12 @@ interface UIState {
// Right-side panels (independent toggles)
showIntel: boolean
+ // Camera focus request (consumed by GameMap)
+ mapFocus: MapFocus | null
+
+ // Auto-pause triggers (session-only, applied by AlertFeed)
+ autoPause: AutoPauseSettings
+
// Actions — selection
selectUnit: (id: UnitId | null) => void
toggleUnitSelection: (id: UnitId) => void
@@ -48,6 +68,12 @@ interface UIState {
// Right-side panels
toggleIntel: () => void
+
+ // Camera focus
+ focusMap: (lng: number, lat: number, zoom?: number) => void
+
+ // Auto-pause
+ toggleAutoPause: (key: keyof AutoPauseSettings) => void
}
export const useUIStore = create((set) => ({
@@ -64,6 +90,8 @@ export const useUIStore = create((set) => ({
showStats: false,
showEconomy: false,
showIntel: false,
+ mapFocus: null,
+ autoPause: { warDeclared: true, ownUnitDestroyed: true, ceasefireOffered: true },
// Selection
selectUnit: (id) => set({
@@ -98,6 +126,14 @@ export const useUIStore = create((set) => ({
toggleIntel: () => set((s) => ({ showIntel: !s.showIntel })),
+ focusMap: (lng, lat, zoom) => set((s) => ({
+ mapFocus: { lng, lat, zoom, nonce: (s.mapFocus?.nonce ?? 0) + 1 },
+ })),
+
+ toggleAutoPause: (key) => set((s) => ({
+ autoPause: { ...s.autoPause, [key]: !s.autoPause[key] },
+ })),
+
// Panels — radio group
setLeftPanel: (panel) => set({
leftPanel: panel,
diff --git a/src/types/commands.ts b/src/types/commands.ts
index 8c9f0c8..35a982a 100644
--- a/src/types/commands.ts
+++ b/src/types/commands.ts
@@ -12,3 +12,5 @@ export type Command =
| { type: 'SET_HEADING'; unitId: UnitId; heading: number }
| { type: 'SET_INTEL_BUDGET'; budget: IntelBudget }
| { type: 'SET_DRONE_MISSION'; unitId: UnitId; mission: 'military' | 'shipping_interdiction' }
+ | { type: 'OFFER_CEASEFIRE'; target: NationId }
+ | { type: 'RESIGN' }
diff --git a/src/types/game.ts b/src/types/game.ts
index c2674ac..cf98ba1 100644
--- a/src/types/game.ts
+++ b/src/types/game.ts
@@ -4,6 +4,47 @@ export type WeaponId = string
export type DetectionState = 'unknown' | 'estimated' | 'detected' | 'tracked'
+/** Fog-of-war contact quality, in escalating order */
+export type VisibilityLevel = 'unseen' | 'detected' | 'tracked' | 'identified'
+
+export interface VisibilityContact {
+ level: VisibilityLevel
+ /** Tick when any sensor last refreshed this contact */
+ lastSeenTick: number
+ /** Position captured at lastSeenTick — shown when the live track is lost */
+ lastKnownPosition: Position
+ /** True for contacts whose level can no longer decay below 'detected' (fixed sites) */
+ pinned?: boolean
+}
+
+/** Political will to keep fighting — the win/lose meter */
+export interface WarStatus {
+ /** 0-100; at 0 the nation capitulates */
+ warSupport: number
+ warStartTick?: number
+ /** Set while this nation has an unanswered ceasefire offer on the table */
+ ceasefireOffered?: boolean
+}
+
+export interface WarStats {
+ durationTicks: number
+ unitsLost: Record
+ missilesFired: Record
+ missilesIntercepted: Record
+ oilPeak: number
+ /** Game seconds the Hormuz lane spent in each non-open state */
+ hormuzReducedTicks: number
+ hormuzBlockedTicks: number
+}
+
+export interface GameOverReport {
+ outcome: 'victory' | 'defeat' | 'ceasefire'
+ /** Nation whose war support collapsed (capitulation outcomes) */
+ loser?: NationId
+ endTick: number
+ stats: WarStats
+}
+
export interface Position {
lng: number
lat: number
@@ -292,6 +333,12 @@ export interface GameState {
shippingLanes: Map
/** Cumulative missile impacts + unit losses per nation — combat writes, enemy AI reads for escalation */
attackCounters?: Record
+ /** Fog of war: contacts on ENEMY units, keyed by observing nation then unit id */
+ visibility?: Record>
+ /** Per-nation war-support / termination state */
+ warStatus?: Record
+ /** Set once the war has been resolved — the world keeps ticking but the game is decided */
+ gameOver?: GameOverReport
}
export type GameEvent =
@@ -309,3 +356,7 @@ export type GameEvent =
| { type: 'SHIPPING_LANE_STATUS_CHANGE'; laneId: string; newStatus: ShippingLane['status']; suppressionFactor: number; tick: number }
| { type: 'MINE_CONTACT'; minefieldId: UnitId; targetId: UnitId; damage: number; tick: number }
| { type: 'SUPPLY_LINE_INTERDICTED'; lineId: string; threatUnitId: UnitId; healthAfter: number; tick: number }
+ | { type: 'WAR_SUPPORT_CRITICAL'; nation: NationId; support: number; tick: number }
+ | { type: 'CEASEFIRE_OFFERED'; by: NationId; tick: number }
+ | { type: 'CEASEFIRE_REJECTED'; by: NationId; tick: number }
+ | { type: 'WAR_ENDED'; outcome: 'ceasefire' | 'capitulation'; loser?: NationId; tick: number }
diff --git a/src/types/view.ts b/src/types/view.ts
index aa55261..502d631 100644
--- a/src/types/view.ts
+++ b/src/types/view.ts
@@ -1,5 +1,6 @@
import type {
GameEvent,
+ GameOverReport,
GameTime,
Missile,
Nation,
@@ -13,10 +14,21 @@ import type {
UnitCategory,
UnitId,
UnitStatus,
+ VisibilityLevel,
WeaponLoadout,
WeaponStock,
} from './game'
+/** Live status of one scenario objective, computed engine-side for the player's nation */
+export interface ObjectiveStatus {
+ id: string
+ label: string
+ /** 0-1 progress toward the player's goal */
+ progress: number
+ status: 'good' | 'contested' | 'bad'
+ detail: string
+}
+
/** Flat, serializable snapshot sent from Worker → Main at 30fps */
export interface GameViewState {
playerNation: NationId
@@ -32,6 +44,12 @@ export interface GameViewState {
pendingEventCount: number
/** Unit IDs recently detected by satellite passes (fades after ~60 ticks) */
satelliteDetectedUnitIds: string[]
+ /** Political will per nation id, 0-100 — the win/lose meter */
+ warSupport: Record
+ /** Set once the war has been decided; the world keeps ticking afterwards */
+ gameOver: GameOverReport | null
+ /** Scenario objectives for the player's side (empty at peace) */
+ objectives: ObjectiveStatus[]
}
export interface ViewUnit {
@@ -59,4 +77,8 @@ export interface ViewUnit {
radius_km?: number
mine_count?: number
droneMission?: 'military' | 'shipping_interdiction'
+ /** Fog of war: how well the player sees this unit. Own units are always 'identified'. */
+ visibility: VisibilityLevel
+ /** True when position is a last-known fix rather than a live track */
+ stale: boolean
}