Add fire status ETA event, probabilistic lethality by intensity, display ETA in UI

backend/app/models.py

@@ -104,6 +104,14 @@ class FireSpreadEvent(BaseModel):
     new_intensity: float
 
 
+class FireStatusEvent(BaseModel):
+    type: Literal["fire_status"] = "fire_status"
+    radius: float
+    intensity: float
+    ticks_to_extinguish: Optional[int] = None
+    secs_to_extinguish: Optional[float] = None
+
+
 class ChatEntry(BaseModel):
     agent_id: str
     message: str

backend/app/simulation.py

@@ -1,6 +1,7 @@
 import asyncio
 import math
-from typing import Union
+import random
+from typing import Union, Optional
 
 from .models import (
     AgentModel,
@@ -11,6 +12,7 @@ from .models import (
     WaterCollectedEvent,
     FireExtinguishedEvent,
     FireSpreadEvent,
+    FireStatusEvent,
     SimulationState,
     TickResponse,
     ChatEntry,
@@ -121,6 +123,19 @@ class SimulationEngine:
         death_events = self._kill_agents_in_fire(living_agents, fire)
         events.extend(death_events)
 
+        # Add fire status event (ETA/progress) for frontend visualization
+        try:
+            status = self._compute_fire_status(living_agents, fire)
+            if status is not None:
+                events.append(FireStatusEvent(
+                    radius=status['radius'],
+                    intensity=status['intensity'],
+                    ticks_to_extinguish=status['ticks_to_extinguish'],
+                    secs_to_extinguish=status['secs_to_extinguish'],
+                ))
+        except Exception:
+            pass
+
         # 7. Check win condition
         self.state.round += 1
         living_count = len([a for a in self.state.agents if a.alive])
@@ -301,10 +316,64 @@ class SimulationEngine:
 
             dist_to_fire = math.dist((agent.x, agent.y), (fire.x, fire.y))
             
-            # Agent dies if inside fire radius
+            # Agent dies if inside fire radius.
+            # Use intensity-based lethality: high intensity => near-certain death; lower intensity => probabilistic.
             if dist_to_fire < fire.radius:
-                agent.alive = False
-                events.append(DeathEvent(model=agent.model_name))
-                events.append(MessageEvent(model=agent.model_name, content="No!!! The fire got me..."))
+                # Immediate fatality at very high intensity
+                if fire.intensity >= 90.0:
+                    lethal = True
+                else:
+                    lethal = (random.random() < (fire.intensity / 100.0))
+
+                if lethal:
+                    agent.alive = False
+                    events.append(DeathEvent(model=agent.model_name))
+                    events.append(MessageEvent(model=agent.model_name, content="No!!! The fire got me..."))
 
         return events
+
+    def _compute_fire_status(self, agents, fire) -> Optional[dict]:
+        """Estimate ticks and seconds to extinguish based on current agents with water.
+        Returns dict with radius, intensity, ticks_to_extinguish, secs_to_extinguish or None if not applicable."""
+        if not fire:
+            return None
+
+        # Count agents actively extinguishing (carrying water and near enough)
+        extinguishers = 0
+        for a in agents:
+            if a.water_collected and a.status == 'extinguishing_fire':
+                dist = math.dist((a.x, a.y), (fire.x, fire.y))
+                if dist <= fire.radius + EXTINGUISH_RANGE:
+                    extinguishers += 1
+
+        if extinguishers == 0:
+            return {
+                'radius': fire.radius,
+                'intensity': fire.intensity,
+                'ticks_to_extinguish': None,
+                'secs_to_extinguish': None,
+            }
+
+        living_count = len([a for a in agents if a.alive]) or 1
+        scale = (7.0) / (living_count + 2.0)
+        scale = max(0.5, min(2.5, scale))
+        per_agent_rate = BASE_EXTINGUISH_RATE * scale
+        per_agent_rate = max(MIN_EXTINGUISH_RATE, min(MAX_EXTINGUISH_RATE, per_agent_rate))
+
+        per_tick_reduction = extinguishers * per_agent_rate
+        if per_tick_reduction <= 0:
+            return {
+                'radius': fire.radius,
+                'intensity': fire.intensity,
+                'ticks_to_extinguish': None,
+                'secs_to_extinguish': None,
+            }
+
+        ticks = math.ceil(fire.intensity / per_tick_reduction)
+        secs = ticks * TICK_INTERVAL_SECONDS
+        return {
+            'radius': fire.radius,
+            'intensity': fire.intensity,
+            'ticks_to_extinguish': int(ticks),
+            'secs_to_extinguish': float(secs),
+        }

frontend/app/page.tsx

@@ -111,6 +111,7 @@ export default function Page() {
   const [tickHistory, setTickHistory] = useState<any[]>([])
   const [reportOpen, setReportOpen] = useState(false)
   const [reportData, setReportData] = useState<any | null>(null)
+  const [fireStatus, setFireStatus] = useState<any | null>(null)
   const [mapSize, setMapSize] = useState({ width: 1200, height: 800 })
   const wsRef = useRef<WebSocket | null>(null)
   const mapDivRef = useRef<HTMLDivElement>(null)
@@ -168,6 +169,10 @@ export default function Page() {
                     if (e.type === 'alliance_proposal') return { agent_id: e.from_model, text: '', type: 'alliance_proposal', to_model: e.to_model }
                     if (e.type === 'alliance_accept') return { agent_id: e.model_a, text: '', type: 'alliance_accept', to_model: e.model_b }
                     if (e.type === 'alliance_reject') return { agent_id: e.from_model, text: '', type: 'alliance_reject', to_model: e.to_model }
+                    if (e.type === 'fire_status') {
+                      setFireStatus({ intensity: e.intensity, radius: e.radius, ticks: e.ticks_to_extinguish, secs: e.secs_to_extinguish })
+                      return null
+                    }
                     return null
                 }).filter(Boolean)
                 setChatMessages(prevMsgs => [...prevMsgs, ...newMsgs])
@@ -249,6 +254,16 @@ export default function Page() {
         </div>
 
         <div className="p-6 border-t border-white/5">
+          {simState?.fire && (
+            <div className="mb-4 text-xs font-mono text-white/60">
+              <div>Fire Intensity: <span className="font-bold text-white">{Math.round(simState.fire.intensity)}%</span></div>
+              {fireStatus && fireStatus.secs != null ? (
+                <div>ETA to extinguish: <span className="font-bold text-white">{Math.round(fireStatus.secs)}s</span></div>
+              ) : (
+                <div>ETA to extinguish: <span className="text-white/30">—</span></div>
+              )}
+            </div>
+          )}
           {appState === "selecting" && (
             <button
               onClick={handleStart}