Improved starting experience for multifaction (#508)

* [Multifaction] Improved start for new factions

General Updates:

- Enhanced multifaction starting experience for Core, Biotech, and Ideology to mirror single-player starts.
- Scenario selection is now available before creating a new faction.
- Correct starting gear, possessions, research, and initial dialogue are now properly generated.

Bug Fixes:

- Lost tribe factions can now be joined from the faction creation sidebar.
- Multifaction start: Map fog correctly disappears after creating a new faction map.
- Multifaction start: All scattered resources/items are now automatically forbidden after map generation (workaround in place; root cause still under investigation).
- Biotech: ExoMech Remains generate now on the map.

* [Multifaction, Async] Set start map time to zero

Before: New multi-faction async maps are generated with the latest map time (maptick) of all maps.
Issues: Potentially starting in winter, the storyteller might send incidents immediately, etc.

Now: When creating a faction, a checkbox can be selected to start the map from zero ticks.

Now: On Faction creation a checkbox can be checked to start the map from zero ticks

* [Multifaction] Improved usability of the factionsidebar

- Improved usability of factionsidebar
=> Updated layout of the faction creator and chooser
=> Added Tooltips to explain new settings and why they are sometimes disabled

- Refactored FactionSidebar.cs a bit

* Bugfix: Temp faction wasn't deleted correctly #508

I couldn’t find any way to generate the correct apparel for a "Lost Tribe" scenario start without creating a temporary faction. However, this temporary faction wasn’t deleted properly and some lingering references caused warnings during saving and loading.

* Explain program state change #508

* Created issue for forbidden workaround #508

see Issue #535

* Refactor: GameStartAbsTick init handling #508

Moved the initialization of gameStartAbsTickMap into its property getter to ensure compatibility with old save files. This approach is more robust, as it handles edge cases where the value might be zero. Additionally, it avoids accessing TickManager during object construction.

* Restrict scenario selection only for Anomaly mod #508

Updated the scenario selection logic to restrict it only when the Anomaly mod is active, instead of both Royalty and Anomaly. Adjusted the tooltip message accordingly.

* Changes suggested by Sokyran #508

Discord messages Sokyran:

I think that Find.CurrentMap == null check could be skipped here if you change WorldRendererUtility.WorldRenderedNow to WorldRendererUtility.WorldSelected. At least the null CurrentMap check wasn't needed before.
https://github.com/Tick-git/Multiplayer/blob/03f6d2b7e1c704563810abe74d6df538738c7926/Source/Client/AsyncTime/AsyncTimePatches.cs#L149-L150

Is 2 constructors needed here? The second one already includes the default value of 0, so in that they already match what they do.
https://github.com/Tick-git/Multiplayer/blob/03f6d2b7e1c704563810abe74d6df538738c7926/Source/Client/AsyncTime/AsyncTimeComp.cs#L101-L111

---------

Co-authored-by: Florian-Lipke <62646477+Florian-Lipke@users.noreply.github.com>

Author: Tick-git

Source/Client/AsyncTime/AsyncTimeComp.cs

@@ -65,8 +65,22 @@ public void SetDesiredTimeSpeed(TimeSpeed speed)
 
         public int TickableId => map.uniqueID;
 
+        public int GameStartAbsTick
+        {
+            get
+            {
+                if (gameStartAbsTickMap == 0)
+                {
+                    gameStartAbsTickMap = Find.TickManager?.gameStartAbsTick ?? 0;
+                }
+
+                return gameStartAbsTickMap;
+            }
+        }
+
         public Map map;
         public int mapTicks;
+        private int gameStartAbsTickMap;
         private TimeSpeed timeSpeedInt;
         public bool forcedNormalSpeed;
         public int eventCount;
@@ -84,9 +98,10 @@ public void SetDesiredTimeSpeed(TimeSpeed speed)
 
         public Queue<ScheduledCommand> cmds = new();
 
-        public AsyncTimeComp(Map map)
+        public AsyncTimeComp(Map map, int gameStartAbsTick = 0)
         {
             this.map = map;
+            this.gameStartAbsTickMap = gameStartAbsTick;
         }
 
         public void Tick()
@@ -198,6 +213,8 @@ public void ExposeData()
             Scribe_Values.Look(ref mapTicks, "mapTicks");
             Scribe_Values.Look(ref timeSpeedInt, "timeSpeed");
 
+            Scribe_Values.Look(ref gameStartAbsTickMap, "gameStartAbsTickMap");
+
             Scribe_Deep.Look(ref storyteller, "storyteller");
 
             Scribe_Deep.Look(ref storyWatcher, "storyWatcher");
@@ -441,5 +458,4 @@ public enum DesignatorMode : byte
         MultiCell,
         Thing
     }
-
 }

Source/Client/AsyncTime/SetMapTime.cs

@@ -180,12 +180,14 @@ public struct TimeSnapshot
         public int ticks;
         public TimeSpeed speed;
         public TimeSlower slower;
+        public int gameStartAbsTick;
 
         public void Set()
         {
             Find.TickManager.ticksGameInt = ticks;
             Find.TickManager.slower = slower;
             Find.TickManager.curTimeSpeed = speed;
+            Find.TickManager.gameStartAbsTick = gameStartAbsTick;
         }
 
         public static TimeSnapshot Current()
@@ -194,7 +196,8 @@ public static TimeSnapshot Current()
             {
                 ticks = Find.TickManager.ticksGameInt,
                 speed = Find.TickManager.curTimeSpeed,
-                slower = Find.TickManager.slower
+                slower = Find.TickManager.slower,
+                gameStartAbsTick = Find.TickManager.gameStartAbsTick
             };
         }
 
@@ -210,6 +213,7 @@ public static TimeSnapshot Current()
             tickManager.ticksGameInt = mapComp.mapTicks;
             tickManager.slower = mapComp.slower;
             tickManager.CurTimeSpeed = mapComp.DesiredTimeSpeed;
+            tickManager.gameStartAbsTick = mapComp.GameStartAbsTick;
 
             return prev;
         }

Source/Client/Factions/FactionCreator.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
 using Multiplayer.API;
@@ -14,6 +15,7 @@ public static class FactionCreator
 {
     private static Dictionary<int, List<Pawn>> pawnStore = new();
     public static bool generatingMap;
+    public const string preventSpecialCalculationPathInGenTicksTicksAbs = "dummy";
 
     public static void ClearData()
     {
@@ -27,34 +29,30 @@ public static void SendPawn(int playerId, Pawn p)
     }
 
     [SyncMethod]
-    public static void CreateFaction(
-        int playerId, string factionName, int tile,
-        [CanBeNull] ScenarioDef scenarioDef, ChooseIdeoInfo chooseIdeoInfo,
-        bool generateMap
-    )
+    public static void CreateFaction(int playerId, FactionCreationData creationData)
     {
         var self = TickPatch.currentExecutingCmdIssuedBySelf;
 
         LongEventHandler.QueueLongEvent(() =>
         {
-            PrepareGameInitData(playerId);
+            var scenario = creationData.scenarioDef?.scenario ?? Current.Game.Scenario;
+            Map newMap = null;
+
+            PrepareGameInitData(playerId, scenario, self, creationData.startingPossessions);
 
-            var scenario = scenarioDef?.scenario ?? Current.Game.Scenario;
             var newFaction = NewFactionWithIdeo(
-                factionName,
+                creationData.factionName,
                 scenario.playerFaction.factionDef,
-                chooseIdeoInfo
+                creationData.chooseIdeoInfo
             );
 
-            Map newMap = null;
-
-            if (generateMap)
+            if (creationData.generateMap)
                 using (MpScope.PushFaction(newFaction))
                 {
                     foreach (var pawn in StartingPawnUtility.StartingAndOptionalPawns)
                         pawn.ideo.SetIdeo(newFaction.ideos.PrimaryIdeo);
 
-                    newMap = GenerateNewMap(tile, scenario);
+                    newMap = GenerateNewMap(creationData.startingTile, scenario, creationData.setupNextMapFromTickZero);
                 }
 
             foreach (Map map in Find.Maps)
@@ -70,6 +68,10 @@ bool generateMap
 
                 Multiplayer.game.ChangeRealPlayerFaction(newFaction);
 
+                CameraJumper.TryJump(MapGenerator.playerStartSpotInt, newMap);
+
+                PostGameStart(scenario);
+
                 // todo setting faction of self
                 Multiplayer.Client.Send(
                     Packets.Client_SetFaction,
@@ -80,66 +82,141 @@ bool generateMap
         }, "GeneratingMap", doAsynchronously: true, GameAndMapInitExceptionHandlers.ErrorWhileGeneratingMap);
     }
 
-    private static Map GenerateNewMap(int tile, Scenario scenario)
+    private static void PostGameStart(Scenario scenario)
+    {
+        /**
+        ScenPart_StartingResearch.cs				
+        ScenPart_AutoActivateMonolith.cs		
+        ScenPart_CreateIncident.cs		
+        ScenPart_GameStartDialog.cs			
+        ScenPart_PlayerFaction.cs		
+        ScenPart_Rule.cs
+
+        Would like to call PostGameStart on all implementations (scenario.PostGameStart) -
+        but dont know if it breaks with dlcs other than biotech - especially while only called
+        on self
+        **/
+
+        HashSet<Type> types = new HashSet<Type>
+        {
+            typeof(ScenPart_PlayerFaction),
+            typeof(ScenPart_GameStartDialog),
+            typeof(ScenPart_StartingResearch),
+        };
+
+        foreach (ScenPart part in scenario.AllParts)
+        {
+            if (types.Contains(part.GetType()))
+            {
+                part.PostGameStart();
+            }
+        }
+    }
+
+    private static Map GenerateNewMap(int tile, Scenario scenario, bool setupNextMapFromTickZero)
     {
         // This has to be null, otherwise, during map generation, Faction.OfPlayer returns it which breaks FactionContext
         Find.GameInitData.playerFaction = null;
         Find.GameInitData.PrepForMapGen();
 
-        var mapParent = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
-        mapParent.Tile = tile;
-        mapParent.SetFaction(Faction.OfPlayer);
-        Find.WorldObjects.Add(mapParent);
+        // ScenPart_PlayerFaction --> PreMapGenerate 
+
+        var settlement = (Settlement)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Settlement);
+        settlement.Tile = tile;
+        settlement.SetFaction(Faction.OfPlayer);
+        Find.WorldObjects.Add(settlement);
+
+        // ^^^^ Duplicate Code here ^^^^
 
         var prevScenario = Find.Scenario;
+        var prevStartingTile = Find.GameInfo.startingTile;
+
         Current.Game.Scenario = scenario;
+        Find.GameInfo.startingTile = tile;
+        Find.GameInitData.startingTile = tile;
+
+        MapSetup.SetupNextMapFromTickZero = setupNextMapFromTickZero;
+
         generatingMap = true;
 
         try
         {
-            return GetOrGenerateMapUtility.GetOrGenerateMap(
+            Map map = GetOrGenerateMapUtility.GetOrGenerateMap(
                 tile,
                 new IntVec3(250, 1, 250),
                 null
             );
+
+            SetAllThingWithCompsOnMapForbidden(map);
+
+            return map;
         }
         finally
         {
             generatingMap = false;
             Current.Game.Scenario = prevScenario;
+            Find.GameInfo.startingTile = prevStartingTile;
+            Find.GameInitData.startingTile = prevStartingTile;
+        }
+    }
+
+    // TODO: Remove this Workaround (see Issue #535)
+    private static void SetAllThingWithCompsOnMapForbidden(Map map)
+    {
+        foreach (Thing thing in map.listerThings.AllThings)
+        {
+            if (thing is ThingWithComps)
+            {
+                thing.SetForbidden(true, false);
+            }
         }
     }
 
     private static void InitNewGame()
     {
         PawnUtility.GiveAllStartingPlayerPawnsThought(ThoughtDefOf.NewColonyOptimism);
+
         ResearchUtility.ApplyPlayerStartingResearch();
         // Initialize anomaly. Since the Anomaly comp is currently shared by all players,
         // we need to ensure that any new factions have access to anomaly research if
         // anomaly content was started.
         Find.ResearchManager.Notify_MonolithLevelChanged(Find.Anomaly.Level);
     }
 
-    private static void PrepareGameInitData(int sessionId)
+    private static void PrepareGameInitData(int sessionId, Scenario scenario, bool self, List<ThingDefCount> startingPossessions)
     {
-        Current.Game.InitData = new GameInitData
+        if (!self)
         {
-            startingPawnCount = 3,
-            gameToLoad = "dummy" // Prevent special calculation path in GenTicks.TicksAbs
-        };
+            Current.Game.InitData = new GameInitData()
+            {
+                startingPawnCount = GetStartingPawnsCountForScenario(scenario),
+                gameToLoad = preventSpecialCalculationPathInGenTicksTicksAbs
+            };
+        }
 
         if (pawnStore.TryGetValue(sessionId, out var pawns))
         {
-            Current.Game.InitData.startingAndOptionalPawns = pawns;
-            Current.Game.InitData.startingPossessions = new Dictionary<Pawn, List<ThingDefCount>>();
-            foreach (var p in pawns)
-                Current.Game.InitData.startingPossessions[p] = new List<ThingDefCount>();
+            Pawn firstPawn = pawns.First();
+
+            GameInitData gameInitData = Current.Game.InitData;
+            gameInitData.startingAndOptionalPawns = pawns;
+            gameInitData.startingPossessions = new Dictionary<Pawn, List<ThingDefCount>>();
+
+            foreach (var pawn in pawns)
+            {
+                gameInitData.startingPossessions[pawn] = new List<ThingDefCount>();
+            }
+
+            foreach (var possesion in startingPossessions)
+            {
+                gameInitData.startingPossessions[firstPawn].Add(possesion);
+            }
 
             pawnStore.Remove(sessionId);
         }
     }
 
-    private static Faction NewFactionWithIdeo(string name, FactionDef def, ChooseIdeoInfo chooseIdeoInfo)
+    private static Faction NewFactionWithIdeo(string name, FactionDef def, IdeologyData chooseIdeoInfo)
     {
         var faction = new Faction
         {
@@ -148,6 +225,7 @@ private static Faction NewFactionWithIdeo(string name, FactionDef def, ChooseIde
             Name = name,
             hidden = true
         };
+
         faction.ideos = new FactionIdeosTracker(faction);
 
         if (!ModsConfig.IdeologyActive || Find.IdeoManager.classicMode || chooseIdeoInfo.SelectedIdeo == null)
@@ -181,7 +259,7 @@ private static Faction NewFactionWithIdeo(string name, FactionDef def, ChooseIde
         return faction;
     }
 
-    private static Ideo GenerateIdeo(ChooseIdeoInfo chooseIdeoInfo)
+    private static Ideo GenerateIdeo(IdeologyData chooseIdeoInfo)
     {
         List<MemeDef> list = chooseIdeoInfo.SelectedIdeo.memes.ToList();
 
@@ -195,4 +273,30 @@ private static Ideo GenerateIdeo(ChooseIdeoInfo chooseIdeoInfo)
 
         return ideo;
     }
+
+    public static int GetStartingPawnsCountForScenario(Scenario scenario)
+    {
+        foreach (ScenPart part in scenario.AllParts)
+        {
+            if (part is ScenPart_ConfigPage_ConfigureStartingPawnsBase startingPawnsConfig)
+            {
+                return startingPawnsConfig.TotalPawnCount;
+            }
+        }
+
+        MpLog.Error("No starting pawns config found to access startingPawnCount");
+
+        return 0;
+    }
 }
+public record FactionCreationData : ISyncSimple
+{
+    public string factionName;
+    public int startingTile;
+    [CanBeNull] public ScenarioDef scenarioDef;
+    public IdeologyData chooseIdeoInfo;
+    public bool generateMap;
+    public List<ThingDefCount> startingPossessions;
+    public bool setupNextMapFromTickZero;
+}
+