increase scroll speed across contest zone

src/lib/config/ConfigLoader.cpp

@@ -305,6 +305,10 @@ WorldConfig ConfigLoader::loadWorld(const std::string& path)
     cfg.artifacts.artifactChanceFormula = requireFormula(tbl["artifacts"]["artifact_chance_formula"], file, "artifacts.artifact_chance_formula");
     cfg.artifacts.artifactWinCount      = static_cast<int>(requireInt(tbl["artifacts"]["artifact_win_count"], file, "artifacts.artifact_win_count"));
 
+    cfg.scroll.panSpeedSlow_tps       = requireDouble(tbl["scroll"]["pan_speed_slow_tiles_per_second"], file, "scroll.pan_speed_slow_tiles_per_second");
+    cfg.scroll.panSpeedFast_tps       = requireDouble(tbl["scroll"]["pan_speed_fast_tiles_per_second"], file, "scroll.pan_speed_fast_tiles_per_second");
+    cfg.scroll.panRampBandWidth_tiles = static_cast<int>(requireInt(tbl["scroll"]["pan_ramp_band_width_tiles"], file, "scroll.pan_ramp_band_width_tiles"));
+
     return cfg;
 }
 

src/lib/config/WorldConfig.h

@@ -53,6 +53,14 @@ struct WorldArtifacts
     int     artifactWinCount;
 };
 
+// View pan speed (REQ-UI-SCROLL-SPEED). Presentation-only; the simulation ignores these.
+struct WorldScroll
+{
+    double panSpeedSlow_tps;        // tiles/s, used outside the contest zone
+    double panSpeedFast_tps;        // tiles/s, used inside the contest zone
+    int    panRampBandWidth_tiles;  // full width of the ramp band straddling each contest-zone boundary
+};
+
 struct WorldConfig
 {
     int heightTiles;                    // REQ-GW-HEIGHT
@@ -73,4 +81,5 @@ struct WorldConfig
     WorldWaves waves;
     WorldTargeting targeting;
     WorldArtifacts artifacts;
+    WorldScroll scroll;
 };

src/ui/GameWorldView.cpp

@@ -272,7 +272,9 @@ void GameWorldView::onFrame()
 
     // Apply held scroll
     {
-        const float delta = kScrollSpeedTilesPerSec
+        // Pan speed depends on where the view is centered (REQ-UI-SCROLL-SPEED).
+        const float viewCenterX = m_scrollXTiles + viewportWidthTiles() / 2.0f;
+        const float delta = panSpeedTilesPerSecondAt(viewCenterX)
             * static_cast<float>(elapsed) / 1000.0f;
         const float scrollBefore = m_scrollXTiles;
         if (m_scrollLeft)  { m_scrollXTiles -= delta; }
@@ -488,6 +490,39 @@ float GameWorldView::enemyStationRightEdge() const
     return rightX;
 }
 
+namespace
+{
+    // Linearly blend from valueAt0 (for x <= x0) to valueAt1 (for x >= x1), clamped
+    // outside [x0, x1]. A zero- or negative-width band collapses to a hard step at x1.
+    float lerpClamped(float valueAt0, float valueAt1, float x0, float x1, float x)
+    {
+        if (x1 <= x0) { return x < x1 ? valueAt0 : valueAt1; }
+        const float t = std::max(0.0f, std::min(1.0f, (x - x0) / (x1 - x0)));
+        return valueAt0 + (valueAt1 - valueAt0) * t;
+    }
+}
+
+float GameWorldView::panSpeedTilesPerSecondAt(float viewCenterXTiles) const
+{
+    // Slow near the asteroid/player buffer, fast across the contest zone, with a
+    // linear ramp straddling each contest-zone boundary (REQ-UI-SCROLL-SPEED). The
+    // contest zone spans from the player buffer's right edge to the enemy stations,
+    // the latter tracked live so the ramp follows the front line as it is pushed.
+    const float slow = static_cast<float>(m_config->world.scroll.panSpeedSlow_tps);
+    const float fast = static_cast<float>(m_config->world.scroll.panSpeedFast_tps);
+    const float half = static_cast<float>(m_config->world.scroll.panRampBandWidth_tiles) / 2.0f;
+    const float leftEdge  = static_cast<float>(m_config->world.regions.playerBufferWidth_tiles);
+    const float rightEdge = enemyStationRightEdge();
+
+    // Rising ramp at the left boundary (slow -> fast) and falling ramp at the right
+    // boundary (fast -> slow); their minimum yields flat-slow outside, flat-fast in
+    // the middle, and — if the bands overlap in a narrow contest zone — a single peak
+    // below the fast speed where the two ramps cross.
+    const float leftRamp  = lerpClamped(slow, fast, leftEdge  - half, leftEdge  + half, viewCenterXTiles);
+    const float rightRamp = lerpClamped(fast, slow, rightEdge - half, rightEdge + half, viewCenterXTiles);
+    return std::min(leftRamp, rightRamp);
+}
+
 void GameWorldView::clampScroll()
 {
     const float leftBound  = asteroidLeftEdge();

src/ui/GameWorldView.h

@@ -140,6 +140,8 @@ private:
 
     float    asteroidLeftEdge() const;
     float    enemyStationRightEdge() const;
+    // Horizontal pan speed at a given view-center X, in tiles/s (REQ-UI-SCROLL-SPEED).
+    float    panSpeedTilesPerSecondAt(float viewCenterXTiles) const;
     void     clampScroll();
 
     bool     isValidPlacement(BuildingType type, QPoint anchor, Rotation rot) const;
@@ -179,7 +181,6 @@ private:
     // Beam lifetime in game ticks so beams freeze with the simulation when
     // paused or slowed, instead of fading on wall-clock time (REQ-SHP-FIRING-BEAM).
     static constexpr Tick    kBeamLifetimeTicks      = secondsToTicks(0.3);
-    static constexpr float   kScrollSpeedTilesPerSec = 10.0f;
 
     Simulation*          m_sim;
     const GameConfig*    m_config;