fix: reset timer tick state on workshop ss_dead reload cycles

Hook_StartupServer fires twice per workshop addon change: once via a
genuine OnLevelShutdown -> OnStartupServer sequence, and again during
the internal ss_dead reload cycle WITHOUT a preceding OnLevelShutdown.

The previous gating (PR roflmuffin#1314) suppressed the entire second call to
TimerSystem::OnStartupServer to avoid the PlayerManager-disconnect ->
stale .NET callbacks -> SEGV chain. But that also skipped the
m_has_map_ticked/m_has_map_simulated reset. On the first frame of the
reloaded session, OnGameFrame computed universal_time delta against an
unrelated last_ticked_time, producing a large positive jump. Per-map
one-off timers (notably MatchZy's 1-second AddTimer(AutoStart)) then
fired arbitrarily late mid-match -- reproducibly aborting live matches.

Fix: OnStartupServer now takes a `levelShutdown` bool. The OnLevelEnd
fan-out (and its disconnect side-effects) stays gated on it, but the
tick-state reset is unconditional. mm_plugin tracks the genuine
LevelShutdown via s_bLevelShutdownOccurred and passes it through.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: stephanebruckert

src/core/timer_system.cpp

@@ -88,15 +88,19 @@ void TimerSystem::OnLevelEnd()
     m_has_map_ticked = false;
 }
 
-void TimerSystem::OnStartupServer()
+void TimerSystem::OnStartupServer(bool levelShutdown)
 {
-    if (m_has_map_ticked)
+    if (levelShutdown && m_has_map_ticked)
     {
         CALL_GLOBAL_LISTENER(OnLevelEnd());
 
         CSSHARP_CORE_TRACE("name={0}", "LevelShutdown");
     }
 
+    // Reset is UNCONDITIONAL -- universal_time math in OnGameFrame depends on
+    // m_has_map_ticked being false on the first frame of every new session,
+    // whether that session came in via a genuine LevelShutdown or a workshop
+    // ss_dead reload.
     m_has_map_ticked = false;
     m_has_map_simulated = false;
 }

src/core/timer_system.h

@@ -72,7 +72,14 @@ class TimerSystem : public GlobalClass
     void OnShutdown() override;
     void OnLevelEnd() override;
     void OnGameFrame(bool simulating);
-    void OnStartupServer();
+    // levelShutdown=true on a genuine OnLevelShutdown -> OnStartupServer sequence
+    // (real changelevel/shutdown). levelShutdown=false on workshop ss_dead reload
+    // cycles that fire Hook_StartupServer without OnLevelShutdown -- in that case
+    // we must NOT fire OnLevelEnd (PlayerManager disconnects still-connected
+    // players -> stale .NET callbacks -> SEGV on the next DispatchConCommand
+    // hook), but we MUST still reset the per-map tick state for universal_time
+    // math to stay correct across the cycle.
+    void OnStartupServer(bool levelShutdown);
     double CalculateNextThink(double last_think_time, float interval);
     void RunFrame();
     void RemoveMapChangeTimers();

src/mm_plugin.cpp

@@ -214,18 +214,19 @@ void CounterStrikeSharpMMPlugin::Hook_StartupServer(const GameSessionConfigurati
     globals::entitySystem->RemoveListenerEntity(&globals::entityManager.entityListener);
     globals::entitySystem->AddListenerEntity(&globals::entityManager.entityListener);
 
-    // Only fire OnLevelEnd lifecycle after a genuine loop-mode deactivation (OnLevelShutdown).
-    // Workshop addon changes trigger a second StartupServer via an internal ss_dead cycle
-    // without deactivating the loop mode; calling OnStartupServer here fires OnLevelEnd →
-    // PlayerManager disconnects still-connected players in CSS state → stale .NET callbacks
-    // → SEGV on the next DispatchConCommand hook.
-    // OnLevelShutdown (via ILoopMode::LoopShutdown post-hook in metamod-source) fires only
-    // on genuine changelevel/shutdown, not during the ss_dead reload cycle.
-    if (s_bLevelShutdownOccurred)
-    {
-        s_bLevelShutdownOccurred = false;
-        globals::timerSystem.OnStartupServer();
-    }
+    // Workshop ss_dead reload cycles fire Hook_StartupServer without a
+    // preceding OnLevelShutdown. We pass that distinction down so that:
+    //   levelShutdown=true  -> fires OnLevelEnd (PlayerManager etc.) and
+    //                          resets timer tick state. Genuine changelevel.
+    //   levelShutdown=false -> ONLY resets timer tick state. No OnLevelEnd,
+    //                          which is what avoids the PlayerManager
+    //                          disconnect -> stale .NET callbacks -> SEGV
+    //                          chain on ss_dead reloads.
+    // Tick-state reset must be unconditional so universal_time math in
+    // OnGameFrame doesn't desync across the cycle (otherwise pending one-off
+    // timers stall arbitrarily long).
+    globals::timerSystem.OnStartupServer(s_bLevelShutdownOccurred);
+    s_bLevelShutdownOccurred = false;
 
     on_activate_callback->ScriptContext().Reset();
     on_activate_callback->ScriptContext().Push(globals::getGlobalVars()->mapname.ToCStr());