[Domain] Optimize hazard runtime field

src/application/ScenarioCanvasWidget.cpp

@@ -251,6 +251,9 @@ QString formatEnvironmentHazardTooltip(const safecrowd::domain::EnvironmentHazar
             .arg(std::max(start, hazard.endSeconds), 0, 'f', 1));
     }
     text.append(QString("\nSeverity: %1").arg(severityLabel(hazard.severity)));
+    text.append(QString("\nInfluence radius: %1m")
+        .arg(safecrowd::domain::environmentHazardRadiusMeters(hazard.severity), 0, 'f', 1));
+    text.append(QStringLiteral("\nDetection varies by agent sensitivity"));
     return text;
 }
 

src/application/SimulationCanvasWidget.cpp

@@ -87,6 +87,9 @@ QString formatEnvironmentHazardTooltip(const safecrowd::domain::EnvironmentHazar
             .arg(std::max(start, hazard.endSeconds), 0, 'f', 1));
     }
     text.append(QString("\nSeverity: %1").arg(severityLabel(hazard.severity)));
+    text.append(QString("\nInfluence radius: %1m")
+        .arg(safecrowd::domain::environmentHazardRadiusMeters(hazard.severity), 0, 'f', 1));
+    text.append(QStringLiteral("\nDetection varies by agent sensitivity"));
     return text;
 }
 
@@ -1132,8 +1135,16 @@ void SimulationCanvasWidget::drawEnvironmentHazardOverlay(QPainter& painter, con
             markerFill = QColor(100, 116, 139, 115);
         }
         QRadialGradient gradient(center, radius);
+        auto falloffColor = [&](double ratio, QColor color) {
+            const auto influence = safecrowd::domain::environmentHazardInfluenceAt(
+                hazard,
+                radiusMeters * std::clamp(ratio, 0.0, 1.0));
+            color.setAlpha(std::clamp(static_cast<int>(std::lround(static_cast<double>(color.alpha()) * influence)), 0, 255));
+            return color;
+        };
         gradient.setColorAt(0.0, core);
-        gradient.setColorAt(0.48, mid);
+        gradient.setColorAt(0.35, falloffColor(0.35, core));
+        gradient.setColorAt(0.65, falloffColor(0.65, mid));
         gradient.setColorAt(1.0, edge);
         painter.setPen(Qt::NoPen);
         painter.setBrush(gradient);

src/domain/ScenarioAuthoring.cpp

@@ -256,6 +256,17 @@ double environmentHazardRadiusMeters(ScenarioElementSeverity severity) {
     }
 }
 
+double environmentHazardInfluenceAt(const EnvironmentHazardDraft& hazard, double distanceMeters) {
+    const auto radius = environmentHazardRadiusMeters(hazard.severity);
+    if (radius <= 1e-9) {
+        return 0.0;
+    }
+
+    const auto t = std::clamp(std::max(0.0, distanceMeters) / radius, 0.0, 1.0);
+    const auto smooth = t * t * (3.0 - (2.0 * t));
+    return 1.0 - smooth;
+}
+
 double environmentHazardRoutePenaltyMeters(ScenarioElementSeverity severity) {
     switch (severity) {
     case ScenarioElementSeverity::Low:
@@ -323,13 +334,12 @@ double environmentHazardSmokeVisibilityMetersAt(const EnvironmentHazardDraft& ha
         break;
     }
 
-    const auto distance = std::max(0.0, distanceMeters);
-    if (distance >= radius) {
+    const auto influence = environmentHazardInfluenceAt(hazard, distanceMeters);
+    if (influence <= 1e-9) {
         return 3.0;
     }
 
-    const auto t = std::clamp(distance / radius, 0.0, 1.0);
-    return sourceVisibility + ((3.0 - sourceVisibility) * t);
+    return 3.0 - ((3.0 - sourceVisibility) * influence);
 }
 
 double environmentHazardSmokeSpeedMetersPerSecond(double smokeFreeSpeedMetersPerSecond, double visibilityMeters) {
@@ -367,8 +377,8 @@ double environmentHazardSpeedFactorAt(
     }
 
     const auto centerFactor = environmentHazardSpeedFactor(hazard.kind, hazard.severity);
-    const auto proximity = 1.0 - std::clamp(std::max(0.0, distanceMeters) / radius, 0.0, 1.0);
-    return 1.0 - ((1.0 - centerFactor) * proximity);
+    const auto influence = environmentHazardInfluenceAt(hazard, distanceMeters);
+    return 1.0 - ((1.0 - centerFactor) * influence);
 }
 
 EnvironmentHazardRuntimeProfile environmentHazardRuntimeProfile(const EnvironmentHazardDraft& hazard) {

src/domain/ScenarioAuthoring.h

@@ -133,6 +133,7 @@ std::vector<std::string> computeScenarioDiffKeys(const ScenarioDraft& baseline,
                                                  const ScenarioDraft& variant);
 
 double environmentHazardRadiusMeters(ScenarioElementSeverity severity);
+double environmentHazardInfluenceAt(const EnvironmentHazardDraft& hazard, double distanceMeters);
 double environmentHazardRoutePenaltyMeters(ScenarioElementSeverity severity);
 double environmentHazardSeverityWeight(ScenarioElementSeverity severity);
 double environmentHazardSpeedFactor(EnvironmentHazardKind kind, ScenarioElementSeverity severity);

src/domain/ScenarioSimulationMotionSystem.cpp

@@ -78,7 +78,15 @@ class ScenarioSimulationMotionSystem final : public engine::EngineSystem {
             ? &resources.get<ScenarioAgentSpatialIndexResource>()
             : nullptr;
 
-        routeGuidance_.apply(query, entities, layoutCache, clock.elapsedSeconds, step.derivedSeed, sharedSpatialIndex);
+        routeGuidance_.apply(
+            query,
+            entities,
+            layoutCache,
+            clock.elapsedSeconds,
+            step.derivedSeed,
+            reactions,
+            activeHazards,
+            sharedSpatialIndex);
         advanceRoutesForCurrentZones(query, activeEntities_, layoutCache);
         replanBlockedExitRoutes(query, activeEntities_, layoutCache, clock.elapsedSeconds, layoutRevision, reactions);
         advanceRoutesForWaypointProgress(query, 0.0, activeEntities_, layoutCache);
@@ -1208,7 +1216,19 @@ class ScenarioSimulationMotionSystem final : public engine::EngineSystem {
             return;
         }
 
-        for (const auto entity : entities) {
+        if (entities.empty()) {
+            hazardReplanCursor_ = 0;
+            return;
+        }
+
+        constexpr std::size_t kHazardReplanEntityBudgetPerFrame = 50;
+        if (hazardReplanCursor_ >= entities.size()) {
+            hazardReplanCursor_ = 0;
+        }
+        const auto startCursor = hazardReplanCursor_;
+        const auto visitCount = std::min<std::size_t>(entities.size(), kHazardReplanEntityBudgetPerFrame);
+        for (std::size_t offset = 0; offset < visitCount; ++offset) {
+            const auto entity = entities[(startCursor + offset) % entities.size()];
             const auto* hazardState = activeHazardState(reactions, entity.index);
             if (hazardState == nullptr) {
                 continue;
@@ -1246,6 +1266,7 @@ class ScenarioSimulationMotionSystem final : public engine::EngineSystem {
             routeGuidance_.replaceRouteWithPlan(route, plan, position.value);
             route.nextExitReplanSeconds = elapsedSeconds + kExitReplanCooldownSeconds;
         }
+        hazardReplanCursor_ = (startCursor + visitCount) % entities.size();
     }
 
     bool closureReadyForBlockedConnection(
@@ -1708,6 +1729,7 @@ class ScenarioSimulationMotionSystem final : public engine::EngineSystem {
     std::optional<ScenarioLayoutCacheResource> layoutCache_{};
     ScenarioRouteGuidanceController routeGuidance_{};
     std::vector<engine::Entity> activeEntities_{};
+    mutable std::size_t hazardReplanCursor_{0};
 };