Isolate RNG in PowerNet battery energy distribution

.github/workflows/alpha-notes.md

@@ -12,4 +12,24 @@
      - Linux: `~/.steam/steam/steamapps/common/RimWorld/Mods`
 3. Extract the zip file into the `Mods` folder.
    * You should have a `Multiplayer` folder in the `Mods` folder (`Mods/Multiplayer`)
-   * Make sure you do not have this directory structure: `Mods/Multiplayer-beta/Multiplayer`. If you do, move the `Multiplayer` folder to the parent directory.
+   * Make sure you do not have this directory structure: `Mods/Multiplayer-beta/Multiplayer`. If you do, move the `Multiplayer` folder to the parent directory.
+
+#### Standalone server
+
+Download `Server-beta.zip` if you want to host a dedicated standalone server for testing.
+
+**Setup**
+1. Download and extract `Server-beta.zip`.
+2. Open the folder for your platform:
+   - `Server/Windows`
+   - `Server/Linux`
+3. Start the server using:
+   - Windows: `Server.exe`
+   - Linux: `./Server.sh`
+4. The server will start and wait for the first connection.
+
+**First-time configuration (bootstrap)**
+No manual configuration files are required.
+The **first player to connect** via the Multiplayer mod client will be prompted to perform the initial setup:
+they can configure the game world, scenario, and other options directly from within RimWorld.
+Subsequent players connect to the already-running session.

.github/workflows/build-beta.yml

@@ -34,13 +34,31 @@ jobs:
     - name: Build Mod
       run: dotnet build ${{ env.SLN_PATH }} --configuration Release --no-restore
 
+    - name: Publish Server (Windows)
+      run: dotnet publish ${{ env.SLN_PATH }}Server/Server.csproj --configuration Release --runtime win-x64 --self-contained false -p:UseAppHost=true -o output/Server/Windows
+
+    - name: Publish Server (Linux)
+      run: dotnet publish ${{ env.SLN_PATH }}Server/Server.csproj --configuration Release --runtime linux-x64 --self-contained false -p:UseAppHost=true -o output/Server/Linux
+
+    - name: Add Server Launchers
+      run: |
+        cat > output/Server/Linux/Server.sh <<'EOF'
+        #!/usr/bin/env bash
+        set -euo pipefail
+        SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+        exec dotnet "$SCRIPT_DIR/Server.dll" "$@"
+        EOF
+
+        chmod +x output/Server/Linux/Server.sh
+
     - name: Package files
       run: |
         sed -i "s/<name>\(.*\)<\/name>\$/<name>\1 [Continuous]<\/name>/" About/About.xml
         mkdir -p output/Multiplayer
         mv About/ Assemblies/ AssembliesCustom/ Defs/ Languages/ Textures/ output/Multiplayer
         cd output/
         zip -r ../Multiplayer-beta.zip Multiplayer/
+        zip -r ../Server-beta.zip Server/
         cd ../
 
     - name: Upload Mod Artifacts
@@ -57,5 +75,5 @@ jobs:
     - name: Upload new release
       run: |
         gh release create --target "${{ github.sha }}" --title "Continuous" --notes-file ".github/workflows/alpha-notes.md" --draft "continuous"
-        gh release upload "continuous" Multiplayer-beta.zip
+        gh release upload "continuous" Multiplayer-beta.zip Server-beta.zip
         gh release edit "continuous" --draft=false

.gitignore

@@ -81,6 +81,7 @@ ipch/
 *.opensdf
 *.sdf
 *.cachefile
+*.lscache
 *.VC.db
 *.VC.VC.opendb
 

Source/ChatCommandContracts/ChatCommandAttributes.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace Multiplayer.Common;
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+public sealed class ChatCommandAttribute(string name, params string[] aliases) : Attribute
+{
+    public string Name { get; } = name;
+    public string[] Aliases { get; } = aliases;
+    public string Usage { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public bool RequiresHost { get; set; }
+}
+
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+public sealed class ChatArgumentAttribute(string name) : Attribute
+{
+    public string Name { get; } = name;
+    public string Description { get; set; } = string.Empty;
+}
+
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+public sealed class ChatRestAttribute : Attribute;

Source/ChatCommandContracts/ChatCommandContracts.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <LangVersion>12</LangVersion>
+    <RootNamespace>Multiplayer.Common</RootNamespace>
+    <AssemblyName>MultiplayerChatCommandContracts</AssemblyName>
+  </PropertyGroup>
+
+</Project>

Source/Client/AsyncTime/AsyncWorldTimeComp.cs

@@ -216,6 +216,9 @@ public void ExecuteCmd(ScheduledCommand cmd)
 
             if (cmdType == CommandType.CreateJoinPoint)
             {
+                if (Multiplayer.session?.ConnectedToStandaloneServer == true && !TickPatch.currentExecutingCmdIssuedBySelf)
+                    return;
+
                 LongEventHandler.QueueLongEvent(CreateJoinPointAndSendIfHost, "MpCreatingJoinPoint", false, null);
             }
 
@@ -273,11 +276,26 @@ public void ExecuteCmd(ScheduledCommand cmd)
 
     private static void CreateJoinPointAndSendIfHost()
     {
-        Multiplayer.session.dataSnapshot = SaveLoad.CreateGameDataSnapshot(SaveLoad.SaveAndReload(), Multiplayer.GameComp.multifaction);
+        Multiplayer.session.dataSnapshot = SaveLoad.SaveReloadAndCreateSnapshot(
+            Multiplayer.GameComp.multifaction,
+            ReloadOptimizationMode.ForJoinPointSnapshot
+        );
 
-        if (!TickPatch.Simulating && !Multiplayer.IsReplay &&
-            (Multiplayer.LocalServer != null || Multiplayer.arbiterInstance))
-            SaveLoad.SendGameData(Multiplayer.session.dataSnapshot, true);
+        if (!TickPatch.Simulating && !Multiplayer.IsReplay)
+        {
+            if (Multiplayer.session?.ConnectedToStandaloneServer == true)
+            {
+                // Standalone: every client uploads world data + individual snapshots
+                SaveLoad.SendGameData(Multiplayer.session.dataSnapshot, true);
+                SaveLoad.SendStandaloneMapSnapshots(Multiplayer.session.dataSnapshot);
+                SaveLoad.SendStandaloneWorldSnapshot(Multiplayer.session.dataSnapshot);
+            }
+            else if (Multiplayer.LocalServer != null || Multiplayer.arbiterInstance)
+            {
+                // Hosted: only host/arbiter uploads world data
+                SaveLoad.SendGameData(Multiplayer.session.dataSnapshot, true);
+            }
+        }
     }
 
     public void SetTimeEverywhere(TimeSpeed speed)

Source/Client/AsyncTime/MultiplayerAsyncQuest.cs

@@ -250,7 +250,7 @@ public static void TickMapQuests(AsyncTimeComp mapAsyncTimeComp)
         /// <param name="quests">Quests to run QuestTick() on</param>
         private static void TickQuests(IEnumerable<Quest> quests)
         {
-            foreach (var quest in quests)
+            foreach (var quest in quests.ToList())
             {
                 quest.QuestTick();
             }

Source/Client/AsyncTime/StorytellerPatches.cs

@@ -131,6 +131,15 @@ static IEnumerable<IncidentTargetTagDef> Postfix(IEnumerable<IncidentTargetTagDe
     {
         foreach (var tag in tags)
         {
+            // Each map ticks its storyteller in that map's faction context. Do not let
+            // another player faction's settlement advertise itself as this map's player home.
+            if (tag == IncidentTargetTagDefOf.Map_PlayerHome &&
+                Multiplayer.Client != null &&
+                Multiplayer.GameComp.multifaction &&
+                __instance.Faction is { IsPlayer: true } faction &&
+                faction != Faction.OfPlayer)
+                continue;
+
             // Only return Map_Misc if player's faction is (heuristically) visiting the map
             // This affects multifaction where the storyteller ticks on every settlement for every faction separately
             if (tag != IncidentTargetTagDefOf.Map_Misc ||

Source/Client/ConstantTicker.cs

@@ -47,6 +47,40 @@ private static void TickNonSimulation()
 
         private static void TickAutosave()
         {
+            // When connected to a remote standalone server, the client drives
+            // the autosave timer using the interval received at connection time
+            // (from the server's TOML settings via ServerProtocolOkPacket).
+            if (Multiplayer.session?.ConnectedToStandaloneServer == true)
+            {
+                var session = Multiplayer.session;
+                if (session.autosaveInterval <= 0)
+                    return;
+
+                if (session.autosaveUnit == AutosaveUnit.Minutes)
+                {
+                    session.autosaveCounter++;
+
+                    if (session.autosaveCounter > session.autosaveInterval * TicksPerMinute)
+                    {
+                        session.autosaveCounter = 0;
+                        Autosaving.DoAutosave();
+                    }
+                }
+                else if (session.autosaveUnit == AutosaveUnit.Days)
+                {
+                    var anyMapCounterUp =
+                        Multiplayer.game.mapComps
+                        .Any(m => m.autosaveCounter > session.autosaveInterval * TicksPerIngameDay);
+
+                    if (anyMapCounterUp)
+                    {
+                        Multiplayer.game.mapComps.Do(m => m.autosaveCounter = 0);
+                        Autosaving.DoAutosave();
+                    }
+                }
+                return;
+            }
+
             if (Multiplayer.LocalServer is not { } server) return;
 
             if (server.settings.autosaveUnit == AutosaveUnit.Minutes)
@@ -60,7 +94,8 @@ private static void TickAutosave()
                     session.autosaveCounter = 0;
                     Autosaving.DoAutosave();
                 }
-            } else if (server.settings.autosaveUnit == AutosaveUnit.Days && server.settings.autosaveInterval > 0)
+            }
+            else if (server.settings.autosaveUnit == AutosaveUnit.Days && server.settings.autosaveInterval > 0)
             {
                 var anyMapCounterUp =
                     Multiplayer.game.mapComps

Source/Client/Debug/DebugActions.cs

@@ -373,6 +373,13 @@ public static void DumpAddrInfoTable()
             }
         }
 
+        [DebugAction(MultiplayerLocalCategory, "Show mod compat", allowedGameStates = AllowedGameStates.Playing)]
+        public static void ShowModCompatDialog()
+        {
+            var window = new ModCompatWindow(null, true, false, null);
+            Find.WindowStack.Add(window);
+        }
+
 #if DEBUG
 
         [DebugOutput]

Source/Client/Desyncs/DeferredStackTracing.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Reflection;
+using System.Runtime.InteropServices;
 using HarmonyLib;
 using Multiplayer.Client.Patches;
 using Multiplayer.Common;
@@ -25,6 +26,9 @@ static IEnumerable<MethodBase> TargetMethods()
 
         public static int acc;
 
+        private static bool SupportsDeferredStackTracing =>
+            RuntimeInformation.ProcessArchitecture is Architecture.X64 or Architecture.X86;
+
         public static void Postfix()
         {
             if (Native.LmfPtr == 0) return;
@@ -43,6 +47,7 @@ public static void Postfix()
 
         public static bool ShouldAddStackTraceForDesyncLog()
         {
+            if (!SupportsDeferredStackTracing) return false;
             if (Multiplayer.Client == null) return false;
             if (Multiplayer.settings.desyncTracingMode == DesyncTracingMode.None) return false;
             if (Multiplayer.game == null) return false;

Source/Client/Factions/Blueprints.cs

@@ -15,7 +15,7 @@ namespace Multiplayer.Client
     // Don't draw other factions' blueprints
     // Don't link graphics of different factions' blueprints
 
-    [HarmonyPatch(typeof(GenConstruct), nameof(GenConstruct.CanPlaceBlueprintAt))]
+    [HarmonyPatch(typeof(GenConstruct), nameof(GenConstruct.CanPlaceBlueprintAt_NewTemp))]
     static class CanPlaceBlueprintAtPatch
     {
         static MethodInfo CanPlaceBlueprintOver = AccessTools.Method(typeof(GenConstruct), nameof(GenConstruct.CanPlaceBlueprintOver));
@@ -48,7 +48,7 @@ static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> e, M
         static bool ShouldIgnore1(Thing oldThing) => oldThing.def.IsBlueprint && oldThing.Faction != Faction.OfPlayer;
     }
 
-    [HarmonyPatch(typeof(GenConstruct), nameof(GenConstruct.CanPlaceBlueprintAt))]
+    [HarmonyPatch(typeof(GenConstruct), nameof(GenConstruct.CanPlaceBlueprintAt_NewTemp))]
     static class CanPlaceBlueprintAtPatch2
     {
         static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> e, MethodBase original)

Source/Client/Factions/FactionCreator.cs

@@ -30,6 +30,15 @@ public static void SendPawn(int playerId, Pawn p)
         pawnStore.GetOrAddNew(playerId).Add(p);
     }
 
+    [SyncMethod]
+    public static void ChangeFactionColor(Faction faction, Color color)
+    {
+        if (faction is not { IsPlayer: true })
+            return;
+
+        faction.color = color;
+    }
+
     [SyncMethod]
     public static void CreateFaction(int playerId, FactionCreationData creationData)
     {
@@ -286,4 +295,3 @@ public record FactionCreationData : ISyncSimple
     public List<ThingDefCount> startingPossessions;
     public bool setupNextMapFromTickZero;
 }
-

Source/Client/Factions/FactionsWindow.cs

@@ -51,6 +51,21 @@ void DrawFactionInLastRect(Faction faction)
 
                 using (MpStyle.Set(GameFont.Medium))
                     Layouter.Label(faction.Name);
+
+                var colorRect = Layouter.Rect(20f, 20f);
+                Widgets.DrawBoxSolid(colorRect.ContractedBy(2f), faction.Color);
+                Widgets.DrawBox(colorRect);
+                Widgets.DrawHighlightIfMouseover(colorRect);
+
+                if (Widgets.ButtonInvisible(colorRect))
+                {
+                    Find.WindowStack.Add(new Dialog_ChooseFactionColor(color =>
+                    {
+                        FactionCreator.ChangeFactionColor(faction, color);
+                    }, faction.Color));
+                }
+
+                TooltipHandler.TipRegion(colorRect, "MpChangeFactionColor".Translate());
             }
             Layouter.EndHorizontal();