Choose Antags Before Job Selection

Content.Server/Antag/AntagSelectionSystem.API.cs

@@ -348,7 +348,7 @@ public void ForceMakeAntag<T>(ICommonSession? player, string defaultRule) where
 
         if (!TryGetNextAvailableDefinition(rule, out var def))
             def = rule.Comp.Definitions.Last();
-        MakeAntag(rule, player, def.Value, null);
+        MakeAntag(rule, player, def.Value);
     }
 
     /// <summary>

Content.Server/Antag/AntagSelectionSystem.cs

@@ -26,6 +26,7 @@
 using Robust.Server.Player;
 using Robust.Shared.Enums;
 using Robust.Shared.Map;
+using Robust.Shared.Network;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
@@ -50,6 +51,8 @@ public sealed partial class AntagSelectionSystem : GameRuleSystem<AntagSelection
     // arbitrary random number to give late joining some mild interest.
     public const float LateJoinRandomChance = 0.5f;
 
+    public Dictionary<NetUserId, (ICommonSession, AntagSelectionDefinition, Entity<AntagSelectionComponent>)> QueuedAntags = [];
+
     /// <inheritdoc/>
     public override void Initialize()
     {
@@ -77,7 +80,7 @@ private void OnTakeGhostRole(Entity<GhostRoleAntagSpawnerComponent> ent, ref Tak
         if (!Exists(rule) || !TryComp<AntagSelectionComponent>(rule, out var select))
             return;
 
-        MakeAntag((rule, select), args.Player, def, null, ignoreSpawner: true);
+        MakeAntag((rule, select), args.Player, def, ignoreSpawner: true);
         args.TookRole = true;
         _ghostRole.UnregisterGhostRole((ent, Comp<GhostRoleComponent>(ent)));
     }
@@ -86,18 +89,21 @@ private void OnPlayerSpawning(RulePlayerSpawningEvent args)
     {
         var pool = args.PlayerPool;
 
-        var query = QueryActiveRules();
-        while (query.MoveNext(out var uid, out _, out var comp, out _))
+        var query = QueryAllRules();
+        while (query.MoveNext(out var uid, out var comp, out _))
         {
-            if (comp.SelectionTime != AntagSelectionTime.PrePlayerSpawn)
-                continue;
 
             if (comp.SelectionsComplete)
                 continue;
 
             ChooseAntags((uid, comp), pool);
 
-            foreach (var session in comp.SelectedSessions)
+            if (comp.SelectionTime != AntagSelectionTime.PrePlayerSpawn)
+            {
+                continue;
+            }
+
+            foreach (var session in comp.ProcessedSessions)
             {
                 args.PlayerPool.Remove(session);
                 GameTicker.PlayerJoinGame(session);
@@ -113,7 +119,15 @@ private void OnJobsAssigned(RulePlayerJobsAssignedEvent args)
             if (comp.SelectionTime != AntagSelectionTime.PostPlayerSpawn)
                 continue;
 
-            ChooseAntags((uid, comp), args.Players);
+            if (!comp.SelectionsComplete) // Should never happen I think?
+                ChooseAntags((uid, comp), args.Players);
+
+            foreach ((var _, var antagData) in QueuedAntags)
+            {
+                if (antagData.Item3.Comp == comp)
+                    MakeAntag(antagData.Item3, antagData.Item1, antagData.Item2);
+            }
+
         }
     }
 
@@ -181,8 +195,33 @@ protected override void Started(EntityUid uid, AntagSelectionComponent component
         if (GameTicker.RunLevel != GameRunLevel.InRound)
             return;
 
-        if (component.SelectionsComplete)
-            return;
+        if (component.SelectionsComplete) // Imp edit start
+        {
+            if (QueuedAntags.Count != 0)
+            {
+                foreach ((var _, var antagData) in QueuedAntags)
+                {
+                    if (antagData.Item3.Comp == component)
+                        MakeAntag(antagData.Item3, antagData.Item1, antagData.Item2);
+
+                }
+                // Checking if antag counts meet expectations and choosing additional antags if not
+                var existingAntags = GetAntagMinds((uid, component)).Count;
+                var targetCount = GetTargetAntagCount((uid, component), null);
+                if (existingAntags < targetCount)
+                {
+                    var playerPool = _playerManager.Sessions
+                                .Where(x => GameTicker.PlayerGameStatuses.TryGetValue(x.UserId, out var status) && status == PlayerGameStatus.JoinedGame)
+                                .ToList();
+                    if (TryGetNextAvailableDefinition((uid, component), out var def)) // Given how we're getting here this should never be false but I'm wrapping it like this anyway Because
+                    {
+                        ChooseAntags((uid, component), playerPool, (AntagSelectionDefinition)def, midround: true, targetCount - existingAntags);
+                    }
+                }
+            }
+            else
+                return;
+        } // Imp edit end
 
         var players = _playerManager.Sessions
             .Where(x => GameTicker.PlayerGameStatuses.TryGetValue(x.UserId, out var status) && status == PlayerGameStatus.JoinedGame)
@@ -217,13 +256,17 @@ public void ChooseAntags(Entity<AntagSelectionComponent> ent, IList<ICommonSessi
     /// <param name="pool">The players to choose from</param>
     /// <param name="def">The antagonist selection parameters and criteria</param>
     /// <param name="midround">Disable picking players for pre-spawn antags in the middle of a round</param>
+    /// <param name="number">Override to choose a number of additional antags if there are not enough at the start of the gamerule. </param>
     public void ChooseAntags(Entity<AntagSelectionComponent> ent,
         IList<ICommonSession> pool,
         AntagSelectionDefinition def,
-        bool midround = false)
+        bool midround = false,
+        int number = 0)
     {
         var playerPool = GetPlayerPool(ent, pool, def);
-        var count = GetTargetAntagCount(ent, GetTotalPlayerCount(pool), def);
+        var count = number;
+        if (count <= 0)
+            count = GetTargetAntagCount(ent, GetTotalPlayerCount(pool), def);
 
         // if there is both a spawner and players getting picked, let it fall back to a spawner.
         var noSpawner = def.SpawnerPrototype == null;
@@ -248,14 +291,19 @@ public void ChooseAntags(Entity<AntagSelectionComponent> ent,
                     break;
                 }
 
-                if (session != null && ent.Comp.SelectedSessions.Contains(session))
+                if (session != null && QueuedAntags.ContainsKey(session.UserId))
                 {
-                    Log.Warning($"Somehow picked {session} for an antag when this rule already selected them previously");
+                    Log.Warning($"Somehow picked {session} for an antag when another rule already selected them previously");
                     continue;
                 }
             }
-
-            MakeAntag(ent, session, def, playerPool);
+            if (!midround && ent.Comp.SelectionTime != AntagSelectionTime.PrePlayerSpawn && session != null) //Midround rule additions, ghost roles, and prespawn activations should never be queued
+            {
+                ent.Comp.SelectedSessions.Add(session);
+                QueuedAntags[session.UserId] = (session, def, ent);
+            }
+            else
+                MakeAntag(ent, session, def);
         }
     }
 
@@ -270,21 +318,23 @@ public bool TryMakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? se
         if (!IsSessionValid(ent, session, def) || !IsEntityValid(session?.AttachedEntity, def))
             return false;
 
-        MakeAntag(ent, session, def, null, ignoreSpawner);
+        MakeAntag(ent, session, def, ignoreSpawner);
         return true;
     }
 
     /// <summary>
     /// Makes a given player into the specified antagonist.
     /// </summary>
-    public void MakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? session, AntagSelectionDefinition def, AntagSelectionPlayerPool? pool, bool ignoreSpawner = false)
+    public void MakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? session, AntagSelectionDefinition def, bool ignoreSpawner = false)
     {
         EntityUid? antagEnt = null;
         var isSpawner = false;
 
         if (session != null)
         {
-            ent.Comp.SelectedSessions.Add(session);
+            ent.Comp.SelectedSessions.Remove(session);
+            QueuedAntags.Remove(session.UserId);
+            ent.Comp.ProcessedSessions.Add(session);
 
             // we shouldn't be blocking the entity if they're just a ghost or smth.
             if (!HasComp<GhostComponent>(session.AttachedEntity))
@@ -307,7 +357,7 @@ public void MakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? sessi
         {
             Log.Error($"Attempted to make {session} antagonist in gamerule {ToPrettyString(ent)} but there was no valid entity for player.");
             if (session != null)
-                ent.Comp.SelectedSessions.Remove(session);
+                ent.Comp.ProcessedSessions.Remove(session);
             return;
         }
 
@@ -337,7 +387,7 @@ public void MakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? sessi
             return;
         }
 
-        var prereqEv = new AntagPrereqSetupEvent(session, ent, def, pool);
+        var prereqEv = new AntagPrereqSetupEvent(session, ent, def);
         RaiseLocalEvent(ent, ref prereqEv, true);
 
         // The following is where we apply components, equipment, and other changes to our antagonist entity.
@@ -413,7 +463,7 @@ public bool IsSessionValid(Entity<AntagSelectionComponent> ent, ICommonSession?
         if (session.Status is SessionStatus.Disconnected or SessionStatus.Zombie)
             return false;
 
-        if (ent.Comp.SelectedSessions.Contains(session))
+        if (ent.Comp.ProcessedSessions.Contains(session))
             return false;
 
         mind ??= session.GetMind();
@@ -519,7 +569,7 @@ public record struct AntagSelectLocationEvent(ICommonSession? Session, Entity<An
 /// Used for applying additional more complex setup logic.
 /// </summary>
 [ByRefEvent]
-public readonly record struct AntagPrereqSetupEvent(ICommonSession? Session, Entity<AntagSelectionComponent> GameRule, AntagSelectionDefinition Def, AntagSelectionPlayerPool? Pool);
+public readonly record struct AntagPrereqSetupEvent(ICommonSession? Session, Entity<AntagSelectionComponent> GameRule, AntagSelectionDefinition Def);
 
 /// <summary>
 /// Event raised on a game rule entity after the setup logic for an antag is complete.

Content.Server/Antag/Components/AntagSelectionComponent.cs

@@ -43,6 +43,12 @@ public sealed partial class AntagSelectionComponent : Component
     /// </summary>
     public HashSet<ICommonSession> SelectedSessions = new();
 
+    /// <summary>
+    /// Cached sessions of players who are chosen. Used so we don't have to rebuild the pool multiple times in a tick.
+    /// Is not serialized.
+    /// </summary>
+    public HashSet<ICommonSession> ProcessedSessions = new();
+
     /// <summary>
     /// Locale id for the name of the antag.
     /// If this is set then the antag is listed in the round-end summary.

Content.Server/GameTicking/Rules/TraitorRuleSystem.cs

@@ -8,6 +8,7 @@
 using Content.Server.Traitor.Uplink;
 using Content.Shared.Database;
 using Content.Shared.FixedPoint;
+using Content.Shared.GameTicking;
 using Content.Shared.GameTicking.Components;
 using Content.Shared.Mind;
 using Content.Shared.NPC.Systems;
@@ -17,6 +18,7 @@
 using Content.Shared.Roles.RoleCodeword;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
+using Robust.Server.Player;
 using System.Linq;
 using System.Text;
 
@@ -31,6 +33,7 @@ public sealed class TraitorRuleSystem : GameRuleSystem<TraitorRuleComponent>
     [Dependency] private readonly SharedJobSystem _jobs = default!;
     [Dependency] private readonly MindSystem _mindSystem = default!;
     [Dependency] private readonly NpcFactionSystem _npcFaction = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly IRobustRandom _random = default!;
     [Dependency] private readonly SharedRoleCodewordSystem _roleCodewordSystem = default!;
@@ -59,8 +62,17 @@ protected override void Added(EntityUid uid, TraitorRuleComponent component, Gam
 
     private void AdditionalSetup(Entity<TraitorRuleComponent> ent, ref AntagPrereqSetupEvent args)
     {
-        CurrentAntagPool = args.Pool;
         ForceAllPossible = args.Def.ForceAllPossible;
+        if (args.Def.ForceAllPossible)
+        {
+            CurrentAntagPool = _antag.GetPlayerPool( // Get player pool of potential antags. Used for assigning objective targets
+                args.GameRule,
+                _playerManager.Sessions
+                .Where(x => GameTicker.PlayerGameStatuses.TryGetValue(x.UserId, out var status) && status == PlayerGameStatus.JoinedGame)
+                .ToList(),
+                args.Def
+            );
+        }
     }
 
     private void AfterEntitySelected(Entity<TraitorRuleComponent> ent, ref AfterAntagEntitySelectedEvent args)

Content.Server/Station/Systems/StationJobsSystem.Roundstart.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.Antag;
 using Content.Server.Administration.Managers;
 using Content.Server.Players.PlayTimeTracking;
 using Content.Server.Station.Components;
@@ -17,6 +18,7 @@ public sealed partial class StationJobsSystem
 {
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly IBanManager _banManager = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
 
     private Dictionary<int, HashSet<string>> _jobsByWeight = default!;
     private List<int> _orderedWeights = default!;
@@ -361,6 +363,9 @@ private Dictionary<NetUserId, List<string>> GetPlayersJobCandidates(int? weight,
                 if (!_prototypeManager.TryIndex(jobId, out var job))
                     continue;
 
+                if (!job.CanBeAntag && _antag.QueuedAntags.ContainsKey(player))
+                    continue;
+
                 if (weight is not null && job.Weight != weight.Value)
                     continue;
 

Resources/Prototypes/_Impstation/GameRules/roundstart.yml

@@ -48,8 +48,8 @@
   - type: GameRule
     minPlayers: 35
     delay:
-      min: 2
-      max: 4
+      min: 240
+      max: 420
   - type: AntagObjectives
     objectives:
     - KillRandomTraitorSvSObjective