Desync fixes, multifaction routing, and failure surfacing

Source/Client/AsyncTime/AsyncTimeComp.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using HarmonyLib;
 using Multiplayer.Client.Comp;
+using Multiplayer.Client.Desyncs;
 using Multiplayer.Client.Factions;
 using Multiplayer.Client.Patches;
 using Multiplayer.Client.Saving;
@@ -64,18 +65,17 @@ public TimeSpeed DesiredTimeSpeed
 
         public int TickableId => map.uniqueID;
 
-        public int GameStartAbsTick
-        {
-            get
-            {
-                if (gameStartAbsTickMap == 0)
-                {
-                    gameStartAbsTickMap = Find.TickManager?.gameStartAbsTick ?? 0;
-                }
-
-                return gameStartAbsTickMap;
-            }
-        }
+        // Pure: this is read from UI-reachable context installs
+        // (TimeSnapshot.GetAndSetFromMap), and a read that wrote the ambient
+        // global into the scribed field made render order and viewer identity
+        // inputs to TicksAbs - an RNG seed in pawn think trees
+        // (RandSeedForHour), wind and sky glow - so a render bug could become
+        // a desync and a save diff. The scribed field is resolved once in
+        // FinalizeInit instead; the fallback covers reads before that point
+        // without writing anything.
+        public int GameStartAbsTick => gameStartAbsTickMap != 0
+            ? gameStartAbsTickMap
+            : Find.TickManager?.gameStartAbsTick ?? 0;
 
         public Map map;
         public int mapTicks;
@@ -95,7 +95,31 @@ public int GameStartAbsTick
 
         public Queue<ScheduledCommand> cmds = new();
 
-        public int CurrentPlayerCount { get; private set; }
+        private int cachedPlayerCount;
+        private int cachedPlayerCountVersion = -1;
+
+        // Derived from the synced view table on demand, never incremented.
+        // The version gate makes the count self-healing: comps recreated by a
+        // reload start stale and re-derive on first read, so there is no
+        // window where a viewed map sits at the no-viewer rate.
+        public int CurrentPlayerCount
+        {
+            get
+            {
+                var gameComp = Multiplayer.GameComp;
+                if (cachedPlayerCountVersion != gameComp.playerViewsVersion)
+                {
+                    cachedPlayerCount = 0;
+                    foreach (var viewedMapId in gameComp.playerViewedMaps.Values)
+                        if (viewedMapId == map.uniqueID)
+                            cachedPlayerCount++;
+                    cachedPlayerCountVersion = gameComp.playerViewsVersion;
+                }
+
+                return cachedPlayerCount;
+            }
+        }
+
         public int VTR => CurrentPlayerCount > 0 ? VTRSync.MinimumVtr : VTRSync.MaximumVtr;
 
         public AsyncTimeComp(Map map, int gameStartAbsTick = 0)
@@ -174,7 +198,17 @@ public void UpdateManagers()
             map.glowGrid.GlowGridUpdate_First();
         }
 
-        private TimeSnapshot? prevTime;
+        // Contexts nest on the same comp by design (the quest brackets in
+        // MultiplayerAsyncQuest run inside Tick(), SetContextForAccept inside
+        // ExecuteCmd), so the restore state is a stack like the Rand and
+        // faction state around it: a single field let an inner bracket clobber
+        // the outer snapshot, leaking the inner clock for the rest of the frame.
+        private readonly Stack<TimeSnapshot?> prevTimes = new();
+
+        // Expected faction stack depth per nested bracket, recorded at
+        // PreContext exit - PostContext unwinds any entries stranded above it
+        // by an exception before doing its own pop (see UnwindFactionStack)
+        private readonly Stack<int> prevFactionDepths = new();
 
         public void PreContext()
         {
@@ -184,7 +218,9 @@ public void PreContext()
                     : Multiplayer.WorldComp.spectatorFaction,
                 force: true);
 
-            prevTime = TimeSnapshot.GetAndSetFromMap(map);
+            prevFactionDepths.Push(FactionContext.stack.Count);
+
+            prevTimes.Push(TimeSnapshot.GetAndSetFromMap(map));
 
             Rand.PushState();
             Rand.StateCompressed = randState;
@@ -195,11 +231,19 @@ public void PreContext()
 
         public void PostContext()
         {
-            prevTime?.Set();
+            if (prevTimes.Count == 0)
+                Log.Error($"MP: unbalanced PostContext on {this}");
+            else
+                prevTimes.Pop()?.Set();
 
             randState = Rand.StateCompressed;
             Rand.PopState();
 
+            if (prevFactionDepths.Count == 0)
+                Log.Error($"MP: unbalanced faction depth on {this}");
+            else
+                FactionExtensions.UnwindFactionStack(map, prevFactionDepths.Pop(), $"map {map.uniqueID} bracket");
+
             map.PopFaction();
         }
 
@@ -208,18 +252,24 @@ public void ExposeData()
             Scribe_Values.Look(ref mapTicks, "mapTicks");
             Scribe_Values.Look(ref timeSpeedInt, "timeSpeed");
 
-            Scribe_Values.Look(ref gameStartAbsTickMap, "gameStartAbsTickMap");
+            Scribe_Values.Look(ref gameStartAbsTickMap, "gameStartAbsTickMap", 0);
 
             Scribe_Custom.LookULong(ref randState, "randState", 1);
         }
 
-        public int IncreasePlayerCount() => CurrentPlayerCount += 1;
-        // This should never go below 0, this is just defensive programming. Hopefully not needed anymore, but
-        // nevertheless still left.
-        public int DecreasePlayerCount() => CurrentPlayerCount = Math.Max(0, CurrentPlayerCount - 1);
-
         public void FinalizeInit()
         {
+            // Only saves predating the per-map field (3bfa487) and the
+            // comp-missing error path in SavingPatches can still hold 0 here.
+            // Both are load-time, and this runs at a fixed point of the load
+            // path on every client (Map.FinalizeLoading -> Map.FinalizeInit ->
+            // MapComponentUtility.FinalizeInit), where the ambient
+            // gameStartAbsTick is the scribed global - the correct value for
+            // those saves. Normal play never constructs a comp with 0
+            // (MapSetup always passes a non-zero source).
+            if (gameStartAbsTickMap == 0)
+                gameStartAbsTickMap = Find.TickManager?.gameStartAbsTick ?? 0;
+
             cmds = new Queue<ScheduledCommand>(
                 Multiplayer.session.dataSnapshot?.MapCmds.GetValueSafe(map.uniqueID) ?? new List<ScheduledCommand>()
             );
@@ -290,7 +340,7 @@ public void ExecuteCmd(ScheduledCommand cmd)
             }
             catch (Exception e)
             {
-                MpLog.Error($"Map cmd exception ({cmdType}): {e}");
+                SimulationFailures.Handle($"Map cmd exception ({cmdType})", e);
             }
             finally
             {

Source/Client/AsyncTime/AsyncTimePatches.cs

@@ -3,6 +3,7 @@
 using System.Reflection;
 using HarmonyLib;
 using Multiplayer.Client.Factions;
+using Multiplayer.Client.Util;
 using RimWorld;
 using RimWorld.Planet;
 using Verse;
@@ -50,26 +51,87 @@ static IEnumerable<MethodBase> TargetMethods()
         static bool Prefix() => Multiplayer.Client == null || !MapUpdateMarker.updating;
     }
 
+    // Season notifications. The old patch pushed Multiplayer.RealPlayerFaction
+    // and that client's own faction's map clock into a method that runs in the
+    // synced world tick and writes scribed state (lastSeason) - per-client
+    // inputs in the deterministic sim. Under async, clients' chosen maps cross
+    // season boundaries at different world ticks and lastSeason diverges (the
+    // "summer arrived twice" desync); a spectating client diverged even in
+    // single-faction games. Replaced with a per-faction pass over synced state
+    // only: each ownable player faction, in deterministic order, gets its
+    // season computed from ITS min-timezone home map's async clock, with its
+    // own scribed lastSeason (FactionWorldData) and its letters routed by the
+    // pushed context. Identical inputs on every client by construction.
     [HarmonyPatch(typeof(DateNotifier), nameof(DateNotifier.DateNotifierTick))]
     static class DateNotifierPatch
     {
-        static void Prefix(DateNotifier __instance, ref int? __state)
+        static bool Prefix(DateNotifier __instance)
         {
-            if (Multiplayer.Client == null && Multiplayer.RealPlayerFaction != null) return;
+            if (Multiplayer.Client == null)
+                return true;
 
-            Map map = __instance.FindPlayerHomeWithMinTimezone();
-            if (map == null) return;
+            foreach (var kv in Multiplayer.WorldComp.factionData)
+            {
+                var faction = Find.FactionManager.GetById(kv.Key);
+                if (!QuestFactionOwnership.IsOwnablePlayerFaction(faction))
+                    continue;
+
+                ((Map)null).PushFaction(faction);
+                try
+                {
+                    TickForFaction(__instance, kv.Value);
+                }
+                finally
+                {
+                    FactionExtensions.PopFaction();
+                }
+            }
 
-            __state = Find.TickManager.TicksGame;
-            FactionContext.Push(Multiplayer.RealPlayerFaction);
-            Find.TickManager.DebugSetTicksGame(map.AsyncTime().mapTicks);
+            return false;
         }
 
-        static void Finalizer(int? __state)
+        // Vanilla DateNotifierTick body (1.6.4871) against per-faction state,
+        // under the faction's context and its map's clock
+        static void TickForFaction(DateNotifier notifier, FactionWorldData data)
         {
-            if (!__state.HasValue) return;
-            Find.TickManager.DebugSetTicksGame(__state.Value);
-            FactionContext.Pop();
+            // First run on an existing save: adopt the global pre-fix state so
+            // the transition already seen isn't re-announced
+            if (data.lastSeason == Season.Undefined && notifier.lastSeason != Season.Undefined)
+                data.lastSeason = notifier.lastSeason;
+
+            Map map = notifier.FindPlayerHomeWithMinTimezone();
+
+            int prevTicks = Find.TickManager.TicksGame;
+            if (map != null)
+                Find.TickManager.DebugSetTicksGame(map.AsyncTime().mapTicks);
+
+            try
+            {
+                float latitude = map != null ? Find.WorldGrid.LongLatOf(map.Tile).y : 0f;
+                float longitude = map != null ? Find.WorldGrid.LongLatOf(map.Tile).x : 0f;
+                Season season = GenDate.Season(Find.TickManager.TicksAbs, latitude, longitude);
+
+                if (season == data.lastSeason ||
+                    (data.lastSeason != Season.Undefined && season == data.lastSeason.GetPreviousSeason()))
+                    return;
+
+                if (data.lastSeason != Season.Undefined && notifier.AnyPlayerHomeSeasonsAreMeaningful())
+                {
+                    if (GenDate.YearsPassed == 0 && season == Season.Summer &&
+                        notifier.AnyPlayerHomeAvgTempIsLowInWinter())
+                        Find.LetterStack.ReceiveLetter("LetterLabelFirstSummerWarning".Translate(),
+                            "FirstSummerWarning".Translate(), LetterDefOf.NeutralEvent);
+                    else if (GenDate.DaysPassed > 5)
+                        Messages.Message("MessageSeasonBegun".Translate(season.Label()).CapitalizeFirst(),
+                            MessageTypeDefOf.NeutralEvent);
+                }
+
+                data.lastSeason = season;
+            }
+            finally
+            {
+                Find.TickManager.DebugSetTicksGame(prevTicks);
+            }
         }
     }
 
@@ -149,6 +211,7 @@ static void Postfix(ref bool __result)
             if (Multiplayer.Client == null) return;
             if (WorldRendererUtility.WorldSelected) return;
             if (FactionCreator.generatingMap) return;
+            if (Find.CurrentMap == null) return;
 
             var asyncTime = Find.CurrentMap.AsyncTime();
             var timeSpeed = Multiplayer.IsReplay ? TickPatch.replayTimeSpeed : asyncTime.DesiredTimeSpeed;