Server Bootstrap: add client bootstrap configurator flow

Source/Client/AsyncTime/SetMapTime.cs

@@ -205,11 +205,15 @@ public static TimeSnapshot Current()
         {
             if (map == null) return null;
 
-            TimeSnapshot prev = Current();
-
             var tickManager = Find.TickManager;
+            if (tickManager == null) return null;
+
+            TimeSnapshot prev = Current();
             var mapComp = map.AsyncTime();
 
+            if (mapComp == null)
+                return prev;
+
             tickManager.ticksGameInt = mapComp.mapTicks;
             tickManager.slower = mapComp.slower;
             tickManager.CurTimeSpeed = mapComp.DesiredTimeSpeed;

Source/Client/Comp/BootstrapCoordinator.cs

@@ -0,0 +1,42 @@
+using Verse;
+
+namespace Multiplayer.Client.Comp
+{
+    /// <summary>
+    /// Runs during bootstrap to detect when the new game has fully entered Playing and a map exists.
+    /// Keeps the save trigger logic reliable even when the bootstrap window may not receive regular updates.
+    /// </summary>
+    public class BootstrapCoordinator : GameComponent
+    {
+        private int nextCheckTick;
+        private const int CheckIntervalTicks = 60; // ~1s
+
+        public BootstrapCoordinator(Game game)
+        {
+        }
+
+        public override void GameComponentTick()
+        {
+            base.GameComponentTick();
+
+            var win = BootstrapConfiguratorWindow.Instance;
+            if (win == null)
+                return;
+
+            // Throttle checks
+            if (Find.TickManager != null && Find.TickManager.TicksGame < nextCheckTick)
+                return;
+
+            if (Find.TickManager != null)
+                nextCheckTick = Find.TickManager.TicksGame + CheckIntervalTicks;
+
+            win.BootstrapCoordinatorTick();
+        }
+
+        public override void ExposeData()
+        {
+            base.ExposeData();
+            Scribe_Values.Look(ref nextCheckTick, "mp_bootstrap_nextCheckTick", 0);
+        }
+    }
+}

Source/Client/MultiplayerStatic.cs

@@ -78,6 +78,7 @@ static MultiplayerStatic()
             MpConnectionState.SetImplementation(ConnectionStateEnum.ClientJoining, typeof(ClientJoiningState));
             MpConnectionState.SetImplementation(ConnectionStateEnum.ClientLoading, typeof(ClientLoadingState));
             MpConnectionState.SetImplementation(ConnectionStateEnum.ClientPlaying, typeof(ClientPlayingState));
+            MpConnectionState.SetImplementation(ConnectionStateEnum.ClientBootstrap, typeof(ClientBootstrapState));
 
             MultiplayerData.CollectCursorIcons();
 

Source/Client/Networking/State/ClientBaseState.cs

@@ -4,12 +4,13 @@
 
 namespace Multiplayer.Client;
 
+[PacketHandlerClass]
 public abstract class ClientBaseState(ConnectionBase connection) : MpConnectionState(connection)
 {
     protected MultiplayerSession Session => Multiplayer.session;
 
     [TypedPacketHandler]
-    public void HandleDisconnected(ServerDisconnectPacket packet)
+    public virtual void HandleDisconnected(ServerDisconnectPacket packet)
     {
         ConnectionStatusListeners.TryNotifyAll_Disconnected(SessionDisconnectInfo.From(packet.reason, new ByteReader(packet.data)));
         Multiplayer.StopMultiplayer();

Source/Client/Networking/State/ClientBootstrapState.cs

@@ -0,0 +1,45 @@
+using Multiplayer.Common;
+using Multiplayer.Common.Networking.Packet;
+using RimWorld;
+using Verse;
+
+namespace Multiplayer.Client;
+
+/// <summary>
+/// Client connection state used while configuring a bootstrap server.
+/// The server is in ServerBootstrap and expects upload packets; the client must keep the connection alive
+/// and handle bootstrap completion / disconnect packets.
+/// </summary>
+[PacketHandlerClass]
+public class ClientBootstrapState(ConnectionBase connection) : ClientBaseState(connection)
+{
+    [TypedPacketHandler]
+    public void HandleBootstrap(ServerBootstrapPacket packet)
+    {
+        // The server sends this again when entering ServerBootstrapState.StartState().
+        // We already have the bootstrap info from ClientJoiningState; just ignore it.
+    }
+
+    [TypedPacketHandler]
+    public override void HandleDisconnected(ServerDisconnectPacket packet)
+    {
+        // If bootstrap completed successfully, show success message before closing the window
+        if (packet.reason == MpDisconnectReason.BootstrapCompleted)
+        {
+            OnMainThread.Enqueue(() => Messages.Message(
+                "Bootstrap configuration completed. The server will now shut down; please restart it manually to start normally.",
+                MessageTypeDefOf.PositiveEvent, false));
+        }
+
+        // Close the bootstrap configurator window now that the process is complete
+        OnMainThread.Enqueue(() =>
+        {
+            var window = Find.WindowStack.WindowOfType<BootstrapConfiguratorWindow>();
+            if (window != null)
+                Find.WindowStack.TryRemove(window);
+        });
+
+        // Let the base class handle the disconnect
+        base.HandleDisconnected(packet);
+    }
+}

Source/Client/Networking/State/ClientJoiningState.cs

@@ -2,18 +2,27 @@
 using HarmonyLib;
 using Multiplayer.Client.Networking;
 using Multiplayer.Common;
+using Multiplayer.Common.Networking.Packet;
 using System.Linq;
 using RimWorld;
 using Verse;
 
 namespace Multiplayer.Client
 {
+    [PacketHandlerClass]
     public class ClientJoiningState : ClientBaseState
     {
         public ClientJoiningState(ConnectionBase connection) : base(connection)
         {
         }
 
+        [TypedPacketHandler]
+        public void HandleBootstrap(ServerBootstrapPacket packet)
+        {
+            Multiplayer.session.serverIsInBootstrap = packet.bootstrap;
+            Multiplayer.session.serverBootstrapSettingsMissing = packet.settingsMissing;
+        }
+
         public override void StartState()
         {
             connection.Send(Packets.Client_Protocol, MpVersion.Protocol);
@@ -132,6 +141,13 @@ void Complete()
 
                 void StartDownloading()
                 {
+                    if (Multiplayer.session.serverIsInBootstrap)
+                    {
+                        connection.ChangeState(ConnectionStateEnum.ClientBootstrap);
+                        Find.WindowStack.Add(new BootstrapConfiguratorWindow(connection));
+                        return;
+                    }
+
                     connection.Send(Packets.Client_WorldRequest);
                     connection.ChangeState(ConnectionStateEnum.ClientLoading);
                 }

Source/Client/Networking/State/ClientPlayingState.cs

@@ -9,6 +9,7 @@
 
 namespace Multiplayer.Client
 {
+    [PacketHandlerClass]
     public class ClientPlayingState : ClientBaseState
     {
         public ClientPlayingState(ConnectionBase connection) : base(connection)

Source/Client/Networking/State/ClientSteamState.cs

@@ -3,6 +3,7 @@
 
 namespace Multiplayer.Client
 {
+    [PacketHandlerClass]
     public class ClientSteamState : MpConnectionState
     {
         public ClientSteamState(ConnectionBase connection) : base(connection)

Source/Client/OnMainThread.cs

@@ -27,6 +27,10 @@ public void Update()
             {
                 Multiplayer.session?.netClient?.PollEvents();
             }
+            catch (InvalidOperationException e) when (e.Message == "Queue empty." || e.Message == "Coda vuota.")
+            {
+                // LiteNetLib can throw here during reconnect/disconnect teardown when its event queue races empty.
+            }
             catch (Exception e)
             {
                 Log.Error($"Exception handling network events: {e}");

Source/Client/Patches/BootstrapMapInitPatch.cs

@@ -0,0 +1,21 @@
+using HarmonyLib;
+using Verse;
+
+namespace Multiplayer.Client
+{
+    [HarmonyPatch(typeof(MapComponentUtility), nameof(MapComponentUtility.FinalizeInit))]
+    static class BootstrapMapInitPatch
+    {
+        static void Postfix(Map map)
+        {
+            if (BootstrapConfiguratorWindow.AwaitingBootstrapMapInit &&
+                BootstrapConfiguratorWindow.Instance != null)
+            {
+                OnMainThread.Enqueue(() =>
+                {
+                    BootstrapConfiguratorWindow.Instance.OnBootstrapMapInitialized();
+                });
+            }
+        }
+    }
+}

Source/Client/Patches/BootstrapRootPlayPatch.cs

@@ -0,0 +1,22 @@
+using HarmonyLib;
+using Verse;
+
+namespace Multiplayer.Client
+{
+    /// <summary>
+    /// Root_Play.Start is called when the game fully transitions into Playing.
+    /// This is a reliable signal for arming the bootstrap map init detection.
+    /// </summary>
+    [HarmonyPatch(typeof(Root_Play), nameof(Root_Play.Start))]
+    static class BootstrapRootPlayPatch
+    {
+        static void Postfix()
+        {
+            var inst = BootstrapConfiguratorWindow.Instance;
+            if (inst == null)
+                return;
+
+            inst.TryArmAwaitingBootstrapMapInit_FromRootPlay();
+        }
+    }
+}

Source/Client/Patches/BootstrapRootPlayUpdatePatch.cs

@@ -0,0 +1,29 @@
+using HarmonyLib;
+using Verse;
+
+namespace Multiplayer.Client
+{
+    /// <summary>
+    /// Root_Play.Update runs through the whole transition from MapInitializing to Playing.
+    /// Arms the map-init trigger as soon as a map exists and ProgramState is Playing.
+    /// </summary>
+    [HarmonyPatch(typeof(Root_Play), nameof(Root_Play.Update))]
+    static class BootstrapRootPlayUpdatePatch
+    {
+        private static int nextCheckFrame;
+        private const int CheckEveryFrames = 10;
+
+        static void Postfix()
+        {
+            var win = BootstrapConfiguratorWindow.Instance;
+            if (win == null)
+                return;
+
+            if (UnityEngine.Time.frameCount < nextCheckFrame)
+                return;
+            nextCheckFrame = UnityEngine.Time.frameCount + CheckEveryFrames;
+
+            win.TryArmAwaitingBootstrapMapInit_FromRootPlayUpdate();
+        }
+    }
+}

Source/Client/Patches/BootstrapStartedNewGamePatch.cs

@@ -0,0 +1,28 @@
+using HarmonyLib;
+using RimWorld;
+using Verse;
+
+namespace Multiplayer.Client
+{
+    /// <summary>
+    /// When the vanilla flow finishes generating the new game, this fires once the map and pawns are ready.
+    /// Backup signal to kick the bootstrap save pipeline in case FinalizeInit was missed or delayed.
+    /// </summary>
+    [HarmonyPatch(typeof(GameComponentUtility), nameof(GameComponentUtility.StartedNewGame))]
+    public static class BootstrapStartedNewGamePatch
+    {
+        static void Postfix()
+        {
+            var window = BootstrapConfiguratorWindow.Instance;
+            if (window == null)
+                return;
+
+            BootstrapConfiguratorWindow.AwaitingBootstrapMapInit = true;
+
+            OnMainThread.Enqueue(() =>
+            {
+                window.OnBootstrapMapInitialized();
+            });
+        }
+    }
+}

Source/Client/Session/Autosaving.cs

@@ -39,14 +39,24 @@ public static void SaveGameToFile_Overwrite(string fileNameNoExtension, bool cur
 
         try
         {
-            new FileInfo(Path.Combine(Multiplayer.ReplaysDir, $"{fileNameNoExtension}.zip")).Delete();
-            Replay.ForSaving(fileNameNoExtension).WriteData(
+            // Ensure the replays directory exists even when not connected to a server
+            Directory.CreateDirectory(Multiplayer.ReplaysDir);
+
+            var tmp = new FileInfo(Path.Combine(Multiplayer.ReplaysDir, $"{fileNameNoExtension}.tmp.zip"));
+            Replay.ForSaving(tmp).WriteData(
                 currentReplay ?
                     Multiplayer.session.dataSnapshot :
                     SaveLoad.CreateGameDataSnapshot(SaveLoad.SaveGameData(), false)
             );
+
+            var dst = new FileInfo(Path.Combine(Multiplayer.ReplaysDir, $"{fileNameNoExtension}.zip"));
+            if (!dst.Exists) dst.Open(FileMode.Create).Close();
+            tmp.Replace(dst.FullName, null);
+
             Messages.Message("MpGameSaved".Translate(fileNameNoExtension), MessageTypeDefOf.SilentInput, false);
-            Multiplayer.session.lastSaveAt = Time.realtimeSinceStartup;
+            // In bootstrap/offline mode there may be no active session
+            if (Multiplayer.session != null)
+                Multiplayer.session.lastSaveAt = Time.realtimeSinceStartup;
         }
         catch (Exception e)
         {

Source/Client/Session/MultiplayerSession.cs

@@ -61,6 +61,10 @@ public class MultiplayerSession : IConnectionStatusListener
         public int port;
         public CSteamID? steamHost;
 
+        // Set during handshake (see Server_Bootstrap packet) to indicate the server is waiting for configuration/upload.
+        public bool serverIsInBootstrap;
+        public bool serverBootstrapSettingsMissing;
+
         public void Stop()
         {
             if (client != null)