diff --git a/Content.Benchmarks/SpawnEquipDeleteBenchmark.cs b/Content.Benchmarks/SpawnEquipDeleteBenchmark.cs
index de51b2fb192..8512107b69d 100644
--- a/Content.Benchmarks/SpawnEquipDeleteBenchmark.cs
+++ b/Content.Benchmarks/SpawnEquipDeleteBenchmark.cs
@@ -58,7 +58,7 @@ await _pair.Server.WaitPost(() =>
             for (var i = 0; i < N; i++)
             {
                 _entity = server.EntMan.SpawnAttachedTo(Mob, _coords);
-                _spawnSys.EquipStartingGear(_entity, _gear, null);
+                _spawnSys.EquipStartingGear(_entity, _gear);
                 server.EntMan.DeleteEntity(_entity);
             }
         });
diff --git a/Content.Client/Humanoid/HumanoidAppearanceSystem.cs b/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
index 8087d1833e6..867dcbc2692 100644
--- a/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
+++ b/Content.Client/Humanoid/HumanoidAppearanceSystem.cs
@@ -118,8 +118,11 @@ private void SetLayerData(
     ///     This should not be used if the entity is owned by the server. The server will otherwise
     ///     override this with the appearance data it sends over.
     /// </remarks>
-    public override void LoadProfile(EntityUid uid, HumanoidCharacterProfile profile, HumanoidAppearanceComponent? humanoid = null)
+    public override void LoadProfile(EntityUid uid, HumanoidCharacterProfile? profile, HumanoidAppearanceComponent? humanoid = null)
     {
+        if (profile == null)
+            return;
+
         if (!Resolve(uid, ref humanoid))
         {
             return;
diff --git a/Content.IntegrationTests/Pair/TestPair.Helpers.cs b/Content.IntegrationTests/Pair/TestPair.Helpers.cs
index 0ea6d3e2dcc..f46b83165ff 100644
--- a/Content.IntegrationTests/Pair/TestPair.Helpers.cs
+++ b/Content.IntegrationTests/Pair/TestPair.Helpers.cs
@@ -2,6 +2,9 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using Content.Server.Preferences.Managers;
+using Content.Shared.Preferences;
+using Content.Shared.Roles;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
@@ -128,4 +131,29 @@ public List<EntityPrototype> GetPrototypesWithComponent<T>(
 
         return list;
     }
+
+    /// <summary>
+    /// Helper method for enabling or disabling a antag role
+    /// </summary>
+    public async Task SetAntagPref(ProtoId<AntagPrototype> id, bool value)
+    {
+        var prefMan = Server.ResolveDependency<IServerPreferencesManager>();
+
+        var prefs = prefMan.GetPreferences(Client.User!.Value);
+        // what even is the point of ICharacterProfile if we always cast it to HumanoidCharacterProfile to make it usable?
+        var profile = (HumanoidCharacterProfile) prefs.SelectedCharacter;
+
+        Assert.That(profile.AntagPreferences.Any(preference => preference == id), Is.EqualTo(!value));
+        var newProfile = profile.WithAntagPreference(id, value);
+
+        await Server.WaitPost(() =>
+        {
+            prefMan.SetProfile(Client.User.Value, prefs.SelectedCharacterIndex, newProfile).Wait();
+        });
+
+        // And why the fuck does it always create a new preference and profile object instead of just reusing them?
+        var newPrefs = prefMan.GetPreferences(Client.User.Value);
+        var newProf = (HumanoidCharacterProfile) newPrefs.SelectedCharacter;
+        Assert.That(newProf.AntagPreferences.Any(preference => preference == id), Is.EqualTo(value));
+    }
 }
diff --git a/Content.IntegrationTests/PoolManager.cs b/Content.IntegrationTests/PoolManager.cs
index b544fe28547..3f489de6497 100644
--- a/Content.IntegrationTests/PoolManager.cs
+++ b/Content.IntegrationTests/PoolManager.cs
@@ -68,11 +68,11 @@ public static partial class PoolManager
 
         options.BeforeStart += () =>
         {
+            // Server-only systems (i.e., systems that subscribe to events with server-only components)
             var entSysMan = IoCManager.Resolve<IEntitySystemManager>();
-            entSysMan.LoadExtraSystemType<ResettingEntitySystemTests.TestRoundRestartCleanupEvent>();
-            entSysMan.LoadExtraSystemType<InteractionSystemTests.TestInteractionSystem>();
             entSysMan.LoadExtraSystemType<DeviceNetworkTestSystem>();
             entSysMan.LoadExtraSystemType<TestDestructibleListenerSystem>();
+
             IoCManager.Resolve<ILogManager>().GetSawmill("loc").Level = LogLevel.Error;
             IoCManager.Resolve<IConfigurationManager>()
                 .OnValueChanged(RTCVars.FailureLogLevel, value => logHandler.FailureLevel = value, true);
diff --git a/Content.IntegrationTests/Tests/GameRules/AntagPreferenceTest.cs b/Content.IntegrationTests/Tests/GameRules/AntagPreferenceTest.cs
new file mode 100644
index 00000000000..662ea3b9747
--- /dev/null
+++ b/Content.IntegrationTests/Tests/GameRules/AntagPreferenceTest.cs
@@ -0,0 +1,76 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.Antag;
+using Content.Server.Antag.Components;
+using Content.Server.GameTicking;
+using Content.Shared.GameTicking;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Player;
+using Robust.Shared.Random;
+
+namespace Content.IntegrationTests.Tests.GameRules;
+
+// Once upon a time, players in the lobby weren't ever considered eligible for antag roles.
+// Lets not let that happen again.
+[TestFixture]
+public sealed class AntagPreferenceTest
+{
+    [Test]
+    public async Task TestLobbyPlayersValid()
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            DummyTicker = false,
+            Connected = true,
+            InLobby = true
+        });
+
+        var server = pair.Server;
+        var client = pair.Client;
+        var ticker = server.System<GameTicker>();
+        var sys = server.System<AntagSelectionSystem>();
+
+        // Initially in the lobby
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
+        Assert.That(client.AttachedEntity, Is.Null);
+        Assert.That(ticker.PlayerGameStatuses[client.User!.Value], Is.EqualTo(PlayerGameStatus.NotReadyToPlay));
+
+        EntityUid uid = default;
+        await server.WaitPost(() => uid = server.EntMan.Spawn("Traitor"));
+        var rule = new Entity<AntagSelectionComponent>(uid, server.EntMan.GetComponent<AntagSelectionComponent>(uid));
+        var def = rule.Comp.Definitions.Single();
+
+        // IsSessionValid & IsEntityValid are preference agnostic and should always be true for players in the lobby.
+        // Though maybe that will change in the future, but then GetPlayerPool() needs to be updated to reflect that.
+        Assert.That(sys.IsSessionValid(rule, pair.Player, def), Is.True);
+        Assert.That(sys.IsEntityValid(client.AttachedEntity, def), Is.True);
+
+        // By default, traitor/antag preferences are disabled, so the pool should be empty.
+        var sessions = new List<ICommonSession>{pair.Player!};
+        var pool = sys.GetPlayerPool(rule, sessions, def);
+        Assert.That(pool.Count, Is.EqualTo(0));
+
+        // Opt into the traitor role.
+        await pair.SetAntagPref("Traitor", true);
+
+        Assert.That(sys.IsSessionValid(rule, pair.Player, def), Is.True);
+        Assert.That(sys.IsEntityValid(client.AttachedEntity, def), Is.True);
+        pool = sys.GetPlayerPool(rule, sessions, def);
+        Assert.That(pool.Count, Is.EqualTo(1));
+        pool.TryPickAndTake(pair.Server.ResolveDependency<IRobustRandom>(), out var picked);
+        Assert.That(picked, Is.EqualTo(pair.Player));
+        Assert.That(sessions.Count, Is.EqualTo(1));
+
+        // opt back out
+        await pair.SetAntagPref("Traitor", false);
+
+        Assert.That(sys.IsSessionValid(rule, pair.Player, def), Is.True);
+        Assert.That(sys.IsEntityValid(client.AttachedEntity, def), Is.True);
+        pool = sys.GetPlayerPool(rule, sessions, def);
+        Assert.That(pool.Count, Is.EqualTo(0));
+
+        await server.WaitPost(() => server.EntMan.DeleteEntity(uid));
+        await pair.CleanReturnAsync();
+    }
+}
diff --git a/Content.IntegrationTests/Tests/GameRules/NukeOpsTest.cs b/Content.IntegrationTests/Tests/GameRules/NukeOpsTest.cs
new file mode 100644
index 00000000000..62fa93c9997
--- /dev/null
+++ b/Content.IntegrationTests/Tests/GameRules/NukeOpsTest.cs
@@ -0,0 +1,212 @@
+/* WD edit
+
+#nullable enable
+using System.Linq;
+using Content.Server.Body.Components;
+using Content.Server.GameTicking;
+using Content.Server.GameTicking.Presets;
+using Content.Server.GameTicking.Rules.Components;
+using Content.Server.Mind;
+using Content.Server.NPC.Systems;
+using Content.Server.Pinpointer;
+using Content.Server.Roles;
+using Content.Server.Shuttles.Components;
+using Content.Server.Station.Components;
+using Content.Shared.CCVar;
+using Content.Shared.Damage;
+using Content.Shared.FixedPoint;
+using Content.Shared.GameTicking;
+using Content.Shared.Hands.Components;
+using Content.Shared.Inventory;
+using Content.Shared.NukeOps;
+using Robust.Server.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map.Components;
+
+namespace Content.IntegrationTests.Tests.GameRules;
+
+[TestFixture]
+public sealed class NukeOpsTest
+{
+    /// <summary>
+    /// Check that a nuke ops game mode can start without issue. I.e., that the nuke station and such all get loaded.
+    /// </summary>
+    [Test]
+    public async Task TryStopNukeOpsFromConstantlyFailing()
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            Dirty = true,
+            DummyTicker = false,
+            Connected = true,
+            InLobby = true
+        });
+
+        var server = pair.Server;
+        var client = pair.Client;
+        var entMan = server.EntMan;
+        var mapSys = server.System<MapSystem>();
+        var ticker = server.System<GameTicker>();
+        var mindSys = server.System<MindSystem>();
+        var roleSys = server.System<RoleSystem>();
+        var invSys = server.System<InventorySystem>();
+        var factionSys = server.System<NpcFactionSystem>();
+
+        Assert.That(server.CfgMan.GetCVar(CCVars.GridFill), Is.False);
+        server.CfgMan.SetCVar(CCVars.GridFill, true);
+
+        // Initially in the lobby
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
+        Assert.That(client.AttachedEntity, Is.Null);
+        Assert.That(ticker.PlayerGameStatuses[client.User!.Value], Is.EqualTo(PlayerGameStatus.NotReadyToPlay));
+
+        // Opt into the nukies role.
+        await pair.SetAntagPref("NukeopsCommander", true);
+
+        // There are no grids or maps
+        Assert.That(entMan.Count<MapComponent>(), Is.Zero);
+        Assert.That(entMan.Count<MapGridComponent>(), Is.Zero);
+        Assert.That(entMan.Count<StationMapComponent>(), Is.Zero);
+        Assert.That(entMan.Count<StationMemberComponent>(), Is.Zero);
+        Assert.That(entMan.Count<StationCentcommComponent>(), Is.Zero);
+
+        // And no nukie related components
+        Assert.That(entMan.Count<NukeopsRuleComponent>(), Is.Zero);
+        Assert.That(entMan.Count<NukeopsRoleComponent>(), Is.Zero);
+        Assert.That(entMan.Count<NukeOperativeComponent>(), Is.Zero);
+        Assert.That(entMan.Count<NukeOpsShuttleComponent>(), Is.Zero);
+        Assert.That(entMan.Count<NukeOperativeSpawnerComponent>(), Is.Zero);
+
+        // Ready up and start nukeops
+        await pair.WaitClientCommand("toggleready True");
+        Assert.That(ticker.PlayerGameStatuses[client.User!.Value], Is.EqualTo(PlayerGameStatus.ReadyToPlay));
+        await pair.WaitCommand("forcepreset Nukeops");
+        await pair.RunTicksSync(10);
+
+        // Game should have started
+        Assert.That(ticker.RunLevel, Is.EqualTo(GameRunLevel.InRound));
+        Assert.That(ticker.PlayerGameStatuses[client.User!.Value], Is.EqualTo(PlayerGameStatus.JoinedGame));
+        Assert.That(client.EntMan.EntityExists(client.AttachedEntity));
+        var player = pair.Player!.AttachedEntity!.Value;
+        Assert.That(entMan.EntityExists(player));
+
+        // Maps now exist
+        Assert.That(entMan.Count<MapComponent>(), Is.GreaterThan(0));
+        Assert.That(entMan.Count<MapGridComponent>(), Is.GreaterThan(0));
+        Assert.That(entMan.Count<StationDataComponent>(), Is.EqualTo(2)); // The main station & nukie station
+        Assert.That(entMan.Count<StationMemberComponent>(), Is.GreaterThan(3)); // Each station has at least 1 grid, plus some shuttles
+        Assert.That(entMan.Count<StationCentcommComponent>(), Is.EqualTo(1));
+
+        // And we now have nukie related components
+        Assert.That(entMan.Count<NukeopsRuleComponent>(), Is.EqualTo(1));
+        Assert.That(entMan.Count<NukeopsRoleComponent>(), Is.EqualTo(1));
+        Assert.That(entMan.Count<NukeOperativeComponent>(), Is.EqualTo(1));
+        Assert.That(entMan.Count<NukeOpsShuttleComponent>(), Is.EqualTo(1));
+
+        // The player entity should be the nukie commander
+        var mind = mindSys.GetMind(player)!.Value;
+        Assert.That(entMan.HasComponent<NukeOperativeComponent>(player));
+        Assert.That(roleSys.MindIsAntagonist(mind));
+        Assert.That(roleSys.MindHasRole<NukeopsRoleComponent>(mind));
+
+        Assert.That(factionSys.IsMember(player, "Syndicate"), Is.True);
+        Assert.That(factionSys.IsMember(player, "NanoTrasen"), Is.False);
+
+        var roles = roleSys.MindGetAllRoles(mind);
+        var cmdRoles = roles.Where(x => x.Prototype == "NukeopsCommander" && x.Component is NukeopsRoleComponent);
+        Assert.That(cmdRoles.Count(), Is.EqualTo(1));
+
+        // The game rule exists, and all the stations/shuttles/maps are properly initialized
+        var rule = entMan.AllComponents<NukeopsRuleComponent>().Single().Component;
+        var mapRule = entMan.AllComponents<LoadMapRuleComponent>().Single().Component;
+        foreach (var grid in mapRule.MapGrids)
+        {
+            Assert.That(entMan.EntityExists(grid));
+            Assert.That(entMan.HasComponent<MapGridComponent>(grid));
+            Assert.That(entMan.HasComponent<StationMemberComponent>(grid));
+        }
+        Assert.That(entMan.EntityExists(rule.TargetStation));
+
+        Assert.That(entMan.HasComponent<StationDataComponent>(rule.TargetStation));
+
+        var nukieShuttlEnt = entMan.AllComponents<NukeOpsShuttleComponent>().FirstOrDefault().Uid;
+        Assert.That(entMan.EntityExists(nukieShuttlEnt));
+
+        EntityUid? nukieStationEnt = null;
+        foreach (var grid in mapRule.MapGrids)
+        {
+            if (entMan.HasComponent<StationMemberComponent>(grid))
+            {
+                nukieStationEnt = grid;
+                break;
+            }
+        }
+
+        Assert.That(entMan.EntityExists(nukieStationEnt));
+        var nukieStation = entMan.GetComponent<StationMemberComponent>(nukieStationEnt!.Value);
+
+        Assert.That(entMan.EntityExists(nukieStation.Station));
+        Assert.That(nukieStation.Station, Is.Not.EqualTo(rule.TargetStation));
+
+        Assert.That(server.MapMan.MapExists(mapRule.Map));
+        var nukieMap = mapSys.GetMap(mapRule.Map!.Value);
+
+        var targetStation = entMan.GetComponent<StationDataComponent>(rule.TargetStation!.Value);
+        var targetGrid = targetStation.Grids.First();
+        var targetMap = entMan.GetComponent<TransformComponent>(targetGrid).MapUid!.Value;
+        Assert.That(targetMap, Is.Not.EqualTo(nukieMap));
+
+        Assert.That(entMan.GetComponent<TransformComponent>(player).MapUid, Is.EqualTo(nukieMap));
+        Assert.That(entMan.GetComponent<TransformComponent>(nukieStationEnt.Value).MapUid, Is.EqualTo(nukieMap));
+        Assert.That(entMan.GetComponent<TransformComponent>(nukieShuttlEnt).MapUid, Is.EqualTo(nukieMap));
+
+        // The maps are all map-initialized, including the player
+        // Yes, this is necessary as this has repeatedly been broken somehow.
+        Assert.That(mapSys.IsInitialized(nukieMap));
+        Assert.That(mapSys.IsInitialized(targetMap));
+        Assert.That(mapSys.IsPaused(nukieMap), Is.False);
+        Assert.That(mapSys.IsPaused(targetMap), Is.False);
+
+        EntityLifeStage LifeStage(EntityUid? uid) => entMan.GetComponent<MetaDataComponent>(uid!.Value).EntityLifeStage;
+        Assert.That(LifeStage(player), Is.GreaterThan(EntityLifeStage.Initialized));
+        Assert.That(LifeStage(nukieMap), Is.GreaterThan(EntityLifeStage.Initialized));
+        Assert.That(LifeStage(targetMap), Is.GreaterThan(EntityLifeStage.Initialized));
+        Assert.That(LifeStage(nukieStationEnt.Value), Is.GreaterThan(EntityLifeStage.Initialized));
+        Assert.That(LifeStage(nukieShuttlEnt), Is.GreaterThan(EntityLifeStage.Initialized));
+        Assert.That(LifeStage(rule.TargetStation), Is.GreaterThan(EntityLifeStage.Initialized));
+
+        // Make sure the player has hands. We've had fucking disarmed nukies before.
+        Assert.That(entMan.HasComponent<HandsComponent>(player));
+        Assert.That(entMan.GetComponent<HandsComponent>(player).Hands.Count, Is.GreaterThan(0));
+
+        // While we're at it, lets make sure they aren't naked. I don't know how many inventory slots all mobs will be
+        // likely to have in the future. But nukies should probably have at least 3 slots with something in them.
+        var enumerator = invSys.GetSlotEnumerator(player);
+        int total = 0;
+        while (enumerator.NextItem(out _))
+        {
+            total++;
+        }
+        Assert.That(total, Is.GreaterThan(3));
+
+        // Finally lets check the nukie commander passed basic training and figured out how to breathe.
+        var totalSeconds = 30;
+        var totalTicks = (int) Math.Ceiling(totalSeconds / server.Timing.TickPeriod.TotalSeconds);
+        int increment = 5;
+        var resp = entMan.GetComponent<RespiratorComponent>(player);
+        var damage = entMan.GetComponent<DamageableComponent>(player);
+        for (var tick = 0; tick < totalTicks; tick += increment)
+        {
+            await pair.RunTicksSync(increment);
+            Assert.That(resp.SuffocationCycles, Is.LessThanOrEqualTo(resp.SuffocationCycleThreshold));
+            Assert.That(damage.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
+        }
+
+        //ticker.SetGamePreset((GamePresetPrototype?)null); WD edit
+        server.CfgMan.SetCVar(CCVars.GridFill, false);
+        await pair.SetAntagPref("NukeopsCommander", false);
+        await pair.CleanReturnAsync();
+    }
+}
+
+*/
diff --git a/Content.IntegrationTests/Tests/GameRules/RuleMaxTimeRestartTest.cs b/Content.IntegrationTests/Tests/GameRules/RuleMaxTimeRestartTest.cs
index 1e3f9c9854f..ffaff3b8ded 100644
--- a/Content.IntegrationTests/Tests/GameRules/RuleMaxTimeRestartTest.cs
+++ b/Content.IntegrationTests/Tests/GameRules/RuleMaxTimeRestartTest.cs
@@ -1,5 +1,6 @@
 using Content.Server.GameTicking;
 using Content.Server.GameTicking.Commands;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Shared.CCVar;
diff --git a/Content.IntegrationTests/Tests/GameRules/SecretStartsTest.cs b/Content.IntegrationTests/Tests/GameRules/SecretStartsTest.cs
index 0f665a63de0..5d7ae8efbf4 100644
--- a/Content.IntegrationTests/Tests/GameRules/SecretStartsTest.cs
+++ b/Content.IntegrationTests/Tests/GameRules/SecretStartsTest.cs
@@ -17,6 +17,7 @@ public async Task TestSecretStarts()
 
         var server = pair.Server;
         await server.WaitIdleAsync();
+        var entMan = server.ResolveDependency<IEntityManager>();
         var gameTicker = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<GameTicker>();
 
         await server.WaitAssertion(() =>
@@ -32,10 +33,7 @@ await server.WaitAssertion(() =>
 
         await server.WaitAssertion(() =>
         {
-            foreach (var rule in gameTicker.GetAddedGameRules())
-            {
-                Assert.That(gameTicker.GetActiveGameRules(), Does.Contain(rule));
-            }
+            Assert.That(gameTicker.GetAddedGameRules().Count(), Is.GreaterThan(1), $"No additional rules started by secret rule.");
 
             // End all rules
             gameTicker.ClearGameRules();
diff --git a/Content.IntegrationTests/Tests/Interaction/Click/InteractionSystemTests.cs b/Content.IntegrationTests/Tests/Interaction/Click/InteractionSystemTests.cs
index 317aa10400b..4415eddf376 100644
--- a/Content.IntegrationTests/Tests/Interaction/Click/InteractionSystemTests.cs
+++ b/Content.IntegrationTests/Tests/Interaction/Click/InteractionSystemTests.cs
@@ -407,7 +407,6 @@ await server.WaitAssertion(() =>
             await pair.CleanReturnAsync();
         }
 
-        [Reflect(false)]
         public sealed class TestInteractionSystem : EntitySystem
         {
             public EntityEventHandler<InteractUsingEvent>? InteractUsingEvent;
diff --git a/Content.IntegrationTests/Tests/ResettingEntitySystemTests.cs b/Content.IntegrationTests/Tests/ResettingEntitySystemTests.cs
index d5c2a9124dd..40457f54883 100644
--- a/Content.IntegrationTests/Tests/ResettingEntitySystemTests.cs
+++ b/Content.IntegrationTests/Tests/ResettingEntitySystemTests.cs
@@ -9,7 +9,6 @@ namespace Content.IntegrationTests.Tests
     [TestOf(typeof(RoundRestartCleanupEvent))]
     public sealed class ResettingEntitySystemTests
     {
-        [Reflect(false)]
         public sealed class TestRoundRestartCleanupEvent : EntitySystem
         {
             public bool HasBeenReset { get; set; }
@@ -49,8 +48,6 @@ await server.WaitAssertion(() =>
 
                 system.HasBeenReset = false;
 
-                Assert.That(system.HasBeenReset, Is.False);
-
                 gameTicker.RestartRound();
 
                 Assert.That(system.HasBeenReset);
diff --git a/Content.Server/Administration/ServerApi.cs b/Content.Server/Administration/ServerApi.cs
index 6f10ef9b479..04fd38598fb 100644
--- a/Content.Server/Administration/ServerApi.cs
+++ b/Content.Server/Administration/ServerApi.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Content.Server.Administration.Systems;
 using Content.Server.GameTicking;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Presets;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Maps;
diff --git a/Content.Server/Administration/Systems/AdminVerbSystem.Antags.cs b/Content.Server/Administration/Systems/AdminVerbSystem.Antags.cs
index eff97136d06..4103b8a8aa7 100644
--- a/Content.Server/Administration/Systems/AdminVerbSystem.Antags.cs
+++ b/Content.Server/Administration/Systems/AdminVerbSystem.Antags.cs
@@ -1,23 +1,37 @@
-using Content.Server.GameTicking.Rules;
+using Content.Server.Administration.Commands;
+using Content.Server.Antag;
+using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Zombies;
 using Content.Shared.Administration;
 using Content.Shared.Database;
-using Content.Shared.Humanoid;
 using Content.Shared.Mind.Components;
+using Content.Shared.Roles;
 using Content.Shared.Verbs;
 using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
 
 namespace Content.Server.Administration.Systems;
 
 public sealed partial class AdminVerbSystem
 {
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
     [Dependency] private readonly ZombieSystem _zombie = default!;
-    [Dependency] private readonly ThiefRuleSystem _thief = default!;
-    [Dependency] private readonly TraitorRuleSystem _traitorRule = default!;
-    [Dependency] private readonly NukeopsRuleSystem _nukeopsRule = default!;
-    [Dependency] private readonly PiratesRuleSystem _piratesRule = default!;
-    [Dependency] private readonly RevolutionaryRuleSystem _revolutionaryRule = default!;
+
+    [ValidatePrototypeId<EntityPrototype>]
+    private const string DefaultTraitorRule = "Traitor";
+
+    [ValidatePrototypeId<EntityPrototype>]
+    private const string DefaultNukeOpRule = "LoneOpsSpawn";
+
+    [ValidatePrototypeId<EntityPrototype>]
+    private const string DefaultRevsRule = "Revolutionary";
+
+    [ValidatePrototypeId<EntityPrototype>]
+    private const string DefaultThiefRule = "Thief";
+
+    [ValidatePrototypeId<StartingGearPrototype>]
+    private const string PirateGearId = "PirateGear";
 
     // All antag verbs have names so invokeverb works.
     private void AddAntagVerbs(GetVerbsEvent<Verb> args)
@@ -30,9 +44,11 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
         if (!_adminManager.HasAdminFlag(player, AdminFlags.Fun))
             return;
 
-        if (!HasComp<MindContainerComponent>(args.Target))
+        if (!HasComp<MindContainerComponent>(args.Target) || !TryComp<ActorComponent>(args.Target, out var targetActor))
             return;
 
+        var targetPlayer = targetActor.PlayerSession;
+
         Verb traitor = new()
         {
             Text = Loc.GetString("admin-verb-text-make-traitor"),
@@ -40,9 +56,7 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
             Icon = new SpriteSpecifier.Rsi(new ResPath("/Textures/Structures/Wallmounts/posters.rsi"), "poster5_contraband"),
             Act = () =>
             {
-                // if its a monkey or mouse or something dont give uplink or objectives
-                var isHuman = HasComp<HumanoidAppearanceComponent>(args.Target);
-                _traitorRule.MakeTraitorAdmin(args.Target, giveUplink: isHuman, giveObjectives: isHuman);
+                _antag.ForceMakeAntag<TraitorRuleComponent>(targetPlayer, DefaultTraitorRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-traitor"),
@@ -71,7 +85,7 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
             Icon = new SpriteSpecifier.Rsi(new("/Textures/Structures/Wallmounts/signs.rsi"), "radiation"),
             Act = () =>
             {
-                _nukeopsRule.MakeLoneNukie(args.Target);
+                _antag.ForceMakeAntag<NukeopsRuleComponent>(targetPlayer, DefaultNukeOpRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-nuclear-operative"),
@@ -85,14 +99,14 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
             Icon = new SpriteSpecifier.Rsi(new("/Textures/Clothing/Head/Hats/pirate.rsi"), "icon"),
             Act = () =>
             {
-                _piratesRule.MakePirate(args.Target);
+                // pirates just get an outfit because they don't really have logic associated with them
+                SetOutfitCommand.SetOutfit(args.Target, PirateGearId, EntityManager);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-pirate"),
         };
         args.Verbs.Add(pirate);
 
-        //todo come here at some point dear lort.
         Verb headRev = new()
         {
             Text = Loc.GetString("admin-verb-text-make-head-rev"),
@@ -100,7 +114,7 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
             Icon = new SpriteSpecifier.Rsi(new("/Textures/Interface/Misc/job_icons.rsi"), "HeadRevolutionary"),
             Act = () =>
             {
-                _revolutionaryRule.OnHeadRevAdmin(args.Target);
+                _antag.ForceMakeAntag<RevolutionaryRuleComponent>(targetPlayer, DefaultRevsRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-head-rev"),
@@ -114,7 +128,7 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
             Icon = new SpriteSpecifier.Rsi(new ResPath("/Textures/Clothing/Hands/Gloves/Color/black.rsi"), "icon"),
             Act = () =>
             {
-                _thief.AdminMakeThief(args.Target, false); //Midround add pacified is bad
+                _antag.ForceMakeAntag<ThiefRuleComponent>(targetPlayer, DefaultThiefRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-thief"),
diff --git a/Content.Server/Antag/AntagSelectionPlayerPool.cs b/Content.Server/Antag/AntagSelectionPlayerPool.cs
new file mode 100644
index 00000000000..87873e96d1a
--- /dev/null
+++ b/Content.Server/Antag/AntagSelectionPlayerPool.cs
@@ -0,0 +1,27 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Robust.Shared.Player;
+using Robust.Shared.Random;
+
+namespace Content.Server.Antag;
+
+public sealed class AntagSelectionPlayerPool (List<List<ICommonSession>> orderedPools)
+{
+    public bool TryPickAndTake(IRobustRandom random, [NotNullWhen(true)] out ICommonSession? session)
+    {
+        session = null;
+
+        foreach (var pool in orderedPools)
+        {
+            if (pool.Count == 0)
+                continue;
+
+            session = random.PickAndTake(pool);
+            break;
+        }
+
+        return session != null;
+    }
+
+    public int Count => orderedPools.Sum(p => p.Count);
+}
diff --git a/Content.Server/Antag/AntagSelectionSystem.API.cs b/Content.Server/Antag/AntagSelectionSystem.API.cs
new file mode 100644
index 00000000000..59bf05fe03f
--- /dev/null
+++ b/Content.Server/Antag/AntagSelectionSystem.API.cs
@@ -0,0 +1,328 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Content.Server.Antag.Components;
+using Content.Server.GameTicking.Rules.Components;
+using Content.Server.Objectives;
+using Content.Shared.Chat;
+using Content.Shared.Mind;
+using JetBrains.Annotations;
+using Robust.Shared.Audio;
+using Robust.Shared.Enums;
+using Robust.Shared.Player;
+
+namespace Content.Server.Antag;
+
+public sealed partial class AntagSelectionSystem
+{
+    /// <summary>
+    /// Tries to get the next non-filled definition based on the current amount of selected minds and other factors.
+    /// </summary>
+    public bool TryGetNextAvailableDefinition(Entity<AntagSelectionComponent> ent,
+        [NotNullWhen(true)] out AntagSelectionDefinition? definition)
+    {
+        definition = null;
+
+        var totalTargetCount = GetTargetAntagCount(ent);
+        var mindCount = ent.Comp.SelectedMinds.Count;
+        if (mindCount >= totalTargetCount)
+            return false;
+
+        // TODO ANTAG fix this
+        // If here are two definitions with 1/10 and 10/10 slots filled, this will always return the second definition
+        // even though it has already met its target
+        // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA I fucking hate game ticker code.
+        // It needs to track selected minds for each definition independently.
+        foreach (var def in ent.Comp.Definitions)
+        {
+            var target = GetTargetAntagCount(ent, null, def);
+
+            if (mindCount < target)
+            {
+                definition = def;
+                return true;
+            }
+
+            mindCount -= target;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Gets the number of antagonists that should be present for a given rule based on the provided pool.
+    /// A null pool will simply use the player count.
+    /// </summary>
+    public int GetTargetAntagCount(Entity<AntagSelectionComponent> ent, int? playerCount = null)
+    {
+        var count = 0;
+        foreach (var def in ent.Comp.Definitions)
+        {
+            count += GetTargetAntagCount(ent, playerCount, def);
+        }
+
+        return count;
+    }
+
+    public int GetTotalPlayerCount(IList<ICommonSession> pool)
+    {
+        var count = 0;
+        foreach (var session in pool)
+        {
+            if (session.Status is SessionStatus.Disconnected or SessionStatus.Zombie)
+                continue;
+
+            count++;
+        }
+
+        return count;
+    }
+
+    /// <summary>
+    /// Gets the number of antagonists that should be present for a given antag definition based on the provided pool.
+    /// A null pool will simply use the player count.
+    /// </summary>
+    public int GetTargetAntagCount(Entity<AntagSelectionComponent> ent, int? playerCount, AntagSelectionDefinition def)
+    {
+        // TODO ANTAG
+        // make pool non-nullable
+        // Review uses and ensure that people are INTENTIONALLY including players in the lobby if this is a mid-round
+        // antag selection.
+        var poolSize = playerCount ?? GetTotalPlayerCount(_playerManager.Sessions);
+
+        // factor in other definitions' affect on the count.
+        var countOffset = 0;
+        foreach (var otherDef in ent.Comp.Definitions)
+        {
+            countOffset += Math.Clamp(poolSize / otherDef.PlayerRatio, otherDef.Min, otherDef.Max) * otherDef.PlayerRatio;
+        }
+        // make sure we don't double-count the current selection
+        countOffset -= Math.Clamp((poolSize + countOffset) / def.PlayerRatio, def.Min, def.Max) * def.PlayerRatio;
+
+        return Math.Clamp((poolSize - countOffset) / def.PlayerRatio, def.Min, def.Max);
+    }
+
+    /// <summary>
+    /// Returns identifiable information for all antagonists to be used in a round end summary.
+    /// </summary>
+    /// <returns>
+    /// A list containing, in order, the antag's mind, the session data, and the original name stored as a string.
+    /// </returns>
+    public List<(EntityUid, SessionData, string)> GetAntagIdentifiers(Entity<AntagSelectionComponent?> ent)
+    {
+        if (!Resolve(ent, ref ent.Comp, false))
+            return new List<(EntityUid, SessionData, string)>();
+
+        var output = new List<(EntityUid, SessionData, string)>();
+        foreach (var (mind, name) in ent.Comp.SelectedMinds)
+        {
+            if (!TryComp<MindComponent>(mind, out var mindComp) || mindComp.OriginalOwnerUserId == null)
+                continue;
+
+            if (!_playerManager.TryGetPlayerData(mindComp.OriginalOwnerUserId.Value, out var data))
+                continue;
+
+            output.Add((mind, data, name));
+        }
+        return output;
+    }
+
+    /// <summary>
+    /// Returns all the minds of antagonists.
+    /// </summary>
+    public List<Entity<MindComponent>> GetAntagMinds(Entity<AntagSelectionComponent?> ent)
+    {
+        if (!Resolve(ent, ref ent.Comp, false))
+            return new();
+
+        var output = new List<Entity<MindComponent>>();
+        foreach (var (mind, _) in ent.Comp.SelectedMinds)
+        {
+            if (!TryComp<MindComponent>(mind, out var mindComp) || mindComp.OriginalOwnerUserId == null)
+                continue;
+
+            output.Add((mind, mindComp));
+        }
+        return output;
+    }
+
+    /// <remarks>
+    /// Helper specifically for <see cref="ObjectivesTextGetInfoEvent"/>
+    /// </remarks>
+    public List<EntityUid> GetAntagMindEntityUids(Entity<AntagSelectionComponent?> ent)
+    {
+        if (!Resolve(ent, ref ent.Comp, false))
+            return new();
+
+        return ent.Comp.SelectedMinds.Select(p => p.Item1).ToList();
+    }
+
+    /// <summary>
+    /// Returns all the antagonists for this rule who are currently alive
+    /// </summary>
+    public IEnumerable<EntityUid> GetAliveAntags(Entity<AntagSelectionComponent?> ent)
+    {
+        if (!Resolve(ent, ref ent.Comp, false))
+            yield break;
+
+        var minds = GetAntagMinds(ent);
+        foreach (var mind in minds)
+        {
+            if (_mind.IsCharacterDeadIc(mind))
+                continue;
+
+            if (mind.Comp.OriginalOwnedEntity != null)
+                yield return GetEntity(mind.Comp.OriginalOwnedEntity.Value);
+        }
+    }
+
+    /// <summary>
+    /// Returns the number of alive antagonists for this rule.
+    /// </summary>
+    public int GetAliveAntagCount(Entity<AntagSelectionComponent?> ent)
+    {
+        if (!Resolve(ent, ref ent.Comp, false))
+            return 0;
+
+        var numbah = 0;
+        var minds = GetAntagMinds(ent);
+        foreach (var mind in minds)
+        {
+            if (_mind.IsCharacterDeadIc(mind))
+                continue;
+
+            numbah++;
+        }
+
+        return numbah;
+    }
+
+    /// <summary>
+    /// Returns if there are any remaining antagonists alive for this rule.
+    /// </summary>
+    public bool AnyAliveAntags(Entity<AntagSelectionComponent?> ent)
+    {
+        if (!Resolve(ent, ref ent.Comp, false))
+            return false;
+
+        return GetAliveAntags(ent).Any();
+    }
+
+    /// <summary>
+    /// Checks if all the antagonists for this rule are alive.
+    /// </summary>
+    public bool AllAntagsAlive(Entity<AntagSelectionComponent?> ent)
+    {
+        if (!Resolve(ent, ref ent.Comp, false))
+            return false;
+
+        return GetAliveAntagCount(ent) == ent.Comp.SelectedMinds.Count;
+    }
+
+    /// <summary>
+    /// Helper method to send the briefing text and sound to a player entity
+    /// </summary>
+    /// <param name="entity">The entity chosen to be antag</param>
+    /// <param name="briefing">The briefing text to send</param>
+    /// <param name="briefingColor">The color the briefing should be, null for default</param>
+    /// <param name="briefingSound">The sound to briefing/greeting sound to play</param>
+    public void SendBriefing(EntityUid entity, string briefing, Color? briefingColor, SoundSpecifier? briefingSound)
+    {
+        if (!_mind.TryGetMind(entity, out _, out var mindComponent))
+            return;
+
+        if (mindComponent.Session == null)
+            return;
+
+        SendBriefing(mindComponent.Session, briefing, briefingColor, briefingSound);
+    }
+
+    /// <summary>
+    /// Helper method to send the briefing text and sound to a list of sessions
+    /// </summary>
+    /// <param name="sessions">The sessions that will be sent the briefing</param>
+    /// <param name="briefing">The briefing text to send</param>
+    /// <param name="briefingColor">The color the briefing should be, null for default</param>
+    /// <param name="briefingSound">The sound to briefing/greeting sound to play</param>
+    [PublicAPI]
+    public void SendBriefing(List<ICommonSession> sessions, string briefing, Color? briefingColor, SoundSpecifier? briefingSound)
+    {
+        foreach (var session in sessions)
+        {
+            SendBriefing(session, briefing, briefingColor, briefingSound);
+        }
+    }
+
+    /// <summary>
+    /// Helper method to send the briefing text and sound to a session
+    /// </summary>
+    /// <param name="session">The player chosen to be an antag</param>
+    /// <param name="data">The briefing data</param>
+    public void SendBriefing(
+        ICommonSession? session,
+        BriefingData? data)
+    {
+        if (session == null || data == null)
+            return;
+
+        var text = data.Value.Text == null ? string.Empty : Loc.GetString(data.Value.Text);
+        SendBriefing(session, text, data.Value.Color, data.Value.Sound);
+    }
+
+    /// <summary>
+    /// Helper method to send the briefing text and sound to a session
+    /// </summary>
+    /// <param name="session">The player chosen to be an antag</param>
+    /// <param name="briefing">The briefing text to send</param>
+    /// <param name="briefingColor">The color the briefing should be, null for default</param>
+    /// <param name="briefingSound">The sound to briefing/greeting sound to play</param>
+    public void SendBriefing(
+        ICommonSession? session,
+        string briefing,
+        Color? briefingColor,
+        SoundSpecifier? briefingSound)
+    {
+        if (session == null)
+            return;
+
+        _audio.PlayGlobal(briefingSound, session);
+        if (!string.IsNullOrEmpty(briefing))
+        {
+            var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", briefing));
+            _chat.ChatMessageToOne(ChatChannel.Server, briefing, wrappedMessage, default, false, session.Channel,
+                briefingColor);
+        }
+    }
+
+    /// <summary>
+    /// This technically is a gamerule-ent-less way to make an entity an antag.
+    /// You should almost never be using this.
+    /// </summary>
+    public void ForceMakeAntag<T>(ICommonSession? player, string defaultRule) where T : Component
+    {
+        var rule = ForceGetGameRuleEnt<T>(defaultRule);
+
+        if (!TryGetNextAvailableDefinition(rule, out var def))
+            def = rule.Comp.Definitions.Last();
+
+        MakeAntag(rule, player, def.Value);
+    }
+
+    /// <summary>
+    /// Tries to grab one of the weird specific antag gamerule ents or starts a new one.
+    /// This is gross code but also most of this is pretty gross to begin with.
+    /// </summary>
+    public Entity<AntagSelectionComponent> ForceGetGameRuleEnt<T>(string id) where T : Component
+    {
+        var query = EntityQueryEnumerator<T, AntagSelectionComponent>();
+        while (query.MoveNext(out var uid, out _, out var comp))
+        {
+            return (uid, comp);
+        }
+        var ruleEnt = GameTicker.AddGameRule(id);
+        RemComp<LoadMapRuleComponent>(ruleEnt);
+        var antag = Comp<AntagSelectionComponent>(ruleEnt);
+        antag.SelectionsComplete = true; // don't do normal selection.
+        GameTicker.StartGameRule(ruleEnt);
+        return (ruleEnt, antag);
+    }
+}
diff --git a/Content.Server/Antag/AntagSelectionSystem.cs b/Content.Server/Antag/AntagSelectionSystem.cs
index b11c562df5a..d74824dd2d5 100644
--- a/Content.Server/Antag/AntagSelectionSystem.cs
+++ b/Content.Server/Antag/AntagSelectionSystem.cs
@@ -1,347 +1,453 @@
+using System.Linq;
+using Content.Server.Antag.Components;
+using Content.Server.Chat.Managers;
+using Content.Server.GameTicking;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules;
-using Content.Server.GameTicking.Rules.Components;
+using Content.Server.Ghost.Roles;
+using Content.Server.Ghost.Roles.Components;
 using Content.Server.Mind;
 using Content.Server.Preferences.Managers;
+using Content.Server.Roles;
 using Content.Server.Roles.Jobs;
 using Content.Server.Shuttles.Components;
+using Content.Server.Station.Systems;
 using Content.Shared.Antag;
+using Content.Shared.GameTicking;
+using Content.Shared.Ghost;
 using Content.Shared.Humanoid;
 using Content.Shared.Players;
 using Content.Shared.Preferences;
-using Content.Shared.Roles;
 using Robust.Server.Audio;
-using Robust.Shared.Audio;
+using Robust.Server.GameObjects;
+using Robust.Server.Player;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
 using Robust.Shared.Player;
-using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
-using System.Linq;
-using Content.Shared.Chat;
-using Robust.Shared.Enums;
+using Robust.Shared.Utility;
 
 namespace Content.Server.Antag;
 
-public sealed class AntagSelectionSystem : GameRuleSystem<GameRuleComponent>
+public sealed partial class AntagSelectionSystem : GameRuleSystem<AntagSelectionComponent>
 {
-    [Dependency] private readonly IServerPreferencesManager _prefs = default!;
-    [Dependency] private readonly AudioSystem _audioSystem = default!;
+    [Dependency] private readonly IChatManager _chat = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IServerPreferencesManager _pref = default!;
+    [Dependency] private readonly AudioSystem _audio = default!;
+    [Dependency] private readonly GhostRoleSystem _ghostRole = default!;
     [Dependency] private readonly JobSystem _jobs = default!;
-    [Dependency] private readonly MindSystem _mindSystem = default!;
-    [Dependency] private readonly SharedRoleSystem _roleSystem = default!;
+    [Dependency] private readonly MindSystem _mind = default!;
+    [Dependency] private readonly RoleSystem _role = default!;
+    [Dependency] private readonly StationSpawningSystem _stationSpawning = default!;
+    [Dependency] private readonly TransformSystem _transform = default!;
 
-    #region Eligible Player Selection
-    /// <summary>
-    /// Get all players that are eligible for an antag role
-    /// </summary>
-    /// <param name="playerSessions">All sessions from which to select eligible players</param>
-    /// <param name="antagPrototype">The prototype to get eligible players for</param>
-    /// <param name="includeAllJobs">Should jobs that prohibit antag roles (ie Heads, Sec, Interns) be included</param>
-    /// <param name="acceptableAntags">Should players already selected as antags be eligible</param>
-    /// <param name="ignorePreferences">Should we ignore if the player has enabled this specific role</param>
-    /// <param name="customExcludeCondition">A custom condition that each player is tested against, if it returns true the player is excluded from eligibility</param>
-    /// <returns>List of all player entities that match the requirements</returns>
-    public List<EntityUid> GetEligiblePlayers(IEnumerable<ICommonSession> playerSessions,
-        ProtoId<AntagPrototype> antagPrototype,
-        bool includeAllJobs = false,
-        AntagAcceptability acceptableAntags = AntagAcceptability.NotExclusive,
-        bool ignorePreferences = false,
-        bool allowNonHumanoids = false,
-        Func<EntityUid?, bool>? customExcludeCondition = null)
+    // arbitrary random number to give late joining some mild interest.
+    public const float LateJoinRandomChance = 0.5f;
+
+    /// <inheritdoc/>
+    public override void Initialize()
     {
-        var eligiblePlayers = new List<EntityUid>();
+        base.Initialize();
 
-        foreach (var player in playerSessions)
-        {
-            if (IsPlayerEligible(player, antagPrototype, includeAllJobs, acceptableAntags, ignorePreferences, allowNonHumanoids, customExcludeCondition))
-                eligiblePlayers.Add(player.AttachedEntity!.Value);
-        }
+        SubscribeLocalEvent<GhostRoleAntagSpawnerComponent, TakeGhostRoleEvent>(OnTakeGhostRole);
 
-        return eligiblePlayers;
+        SubscribeLocalEvent<RulePlayerSpawningEvent>(OnPlayerSpawning);
+        SubscribeLocalEvent<RulePlayerJobsAssignedEvent>(OnJobsAssigned);
+        SubscribeLocalEvent<PlayerSpawnCompleteEvent>(OnSpawnComplete);
     }
 
-    /// <summary>
-    /// Get all sessions that are eligible for an antag role, can be run prior to sessions being attached to an entity
-    /// This does not exclude sessions that have already been chosen as antags - that must be handled manually
-    /// </summary>
-    /// <param name="playerSessions">All sessions from which to select eligible players</param>
-    /// <param name="antagPrototype">The prototype to get eligible players for</param>
-    /// <param name="ignorePreferences">Should we ignore if the player has enabled this specific role</param>
-    /// <returns>List of all player sessions that match the requirements</returns>
-    public List<ICommonSession> GetEligibleSessions(IEnumerable<ICommonSession> playerSessions, ProtoId<AntagPrototype> antagPrototype, bool ignorePreferences = false)
+    private void OnTakeGhostRole(Entity<GhostRoleAntagSpawnerComponent> ent, ref TakeGhostRoleEvent args)
     {
-        var eligibleSessions = new List<ICommonSession>();
+        if (args.TookRole)
+            return;
+
+        if (ent.Comp.Rule is not { } rule || ent.Comp.Definition is not { } def)
+            return;
 
-        foreach (var session in playerSessions)
+        if (!Exists(rule) || !TryComp<AntagSelectionComponent>(rule, out var select))
+            return;
+
+        MakeAntag((rule, select), args.Player, def, ignoreSpawner: true);
+        args.TookRole = true;
+        _ghostRole.UnregisterGhostRole((ent, Comp<GhostRoleComponent>(ent)));
+    }
+
+    private void OnPlayerSpawning(RulePlayerSpawningEvent args)
+    {
+        var pool = args.PlayerPool;
+
+        var query = QueryActiveRules();
+        while (query.MoveNext(out var uid, out _, out var comp, out _))
         {
-            if (IsSessionEligible(session, antagPrototype, ignorePreferences))
-                eligibleSessions.Add(session);
+            if (comp.SelectionTime != AntagSelectionTime.PrePlayerSpawn)
+                continue;
+
+            if (comp.SelectionsComplete)
+                continue;
+
+            ChooseAntags((uid, comp), pool);
+
+            foreach (var session in comp.SelectedSessions)
+            {
+                args.PlayerPool.Remove(session);
+                GameTicker.PlayerJoinGame(session);
+            }
         }
+    }
 
-        return eligibleSessions;
+    private void OnJobsAssigned(RulePlayerJobsAssignedEvent args)
+    {
+        var query = QueryActiveRules();
+        while (query.MoveNext(out var uid, out _, out var comp, out _))
+        {
+            if (comp.SelectionTime != AntagSelectionTime.PostPlayerSpawn)
+                continue;
+
+            ChooseAntags((uid, comp), args.Players);
+        }
     }
 
-    /// <summary>
-    /// Test eligibility of the player for a specific antag role
-    /// </summary>
-    /// <param name="session">The player session to test</param>
-    /// <param name="antagPrototype">The prototype to get eligible players for</param>
-    /// <param name="includeAllJobs">Should jobs that prohibit antag roles (ie Heads, Sec, Interns) be included</param>
-    /// <param name="acceptableAntags">Should players already selected as antags be eligible</param>
-    /// <param name="ignorePreferences">Should we ignore if the player has enabled this specific role</param>
-    /// <param name="customExcludeCondition">A function, accepting an EntityUid and returning bool. Each player is tested against this, returning truw will exclude the player from eligibility</param>
-    /// <returns>True if the player session matches the requirements, false otherwise</returns>
-    public bool IsPlayerEligible(ICommonSession session,
-        ProtoId<AntagPrototype> antagPrototype,
-        bool includeAllJobs = false,
-        AntagAcceptability acceptableAntags = AntagAcceptability.NotExclusive,
-        bool ignorePreferences = false,
-        bool allowNonHumanoids = false,
-        Func<EntityUid?, bool>? customExcludeCondition = null)
+    private void OnSpawnComplete(PlayerSpawnCompleteEvent args)
     {
-        if (!IsSessionEligible(session, antagPrototype, ignorePreferences))
-            return false;
+        if (!args.LateJoin)
+            return;
 
-        //Ensure the player has a mind
-        if (session.GetMind() is not { } playerMind)
-            return false;
+        // TODO: this really doesn't handle multiple latejoin definitions well
+        // eventually this should probably store the players per definition with some kind of unique identifier.
+        // something to figure out later.
 
-        //Ensure the player has an attached entity
-        if (session.AttachedEntity is not { } playerEntity)
-            return false;
+        var query = QueryActiveRules();
+        while (query.MoveNext(out var uid, out _, out var antag, out _))
+        {
+            // TODO ANTAG
+            // what why aasdiuhasdopiuasdfhksad
+            // stop this insanity please
+            // probability of antag assignment shouldn't depend on the order in which rules are returned by the query.
+            if (!RobustRandom.Prob(LateJoinRandomChance))
+                continue;
 
-        //Ignore latejoined players, ie those on the arrivals station
-        if (HasComp<PendingClockInComponent>(playerEntity))
-            return false;
+            if (!antag.Definitions.Any(p => p.LateJoinAdditional))
+                continue;
 
-        //Exclude jobs that cannot be antag, unless explicitly allowed
-        if (!includeAllJobs && !_jobs.CanBeAntag(session))
-            return false;
+            DebugTools.AssertEqual(antag.SelectionTime, AntagSelectionTime.PostPlayerSpawn);
 
-        //Check if the entity is already an antag
-        switch (acceptableAntags)
-        {
-            //If we dont want to select any antag roles
-            case AntagAcceptability.None:
-                {
-                    if (_roleSystem.MindIsAntagonist(playerMind))
-                        return false;
-                    break;
-                }
-            //If we dont want to select exclusive antag roles
-            case AntagAcceptability.NotExclusive:
-                {
-                    if (_roleSystem.MindIsExclusiveAntagonist(playerMind))
-                        return false;
-                    break;
-                }
+            if (!TryGetNextAvailableDefinition((uid, antag), out var def))
+                continue;
+
+            if (TryMakeAntag((uid, antag), args.Player, def.Value))
+                break;
         }
+    }
 
-        //Unless explictly allowed, ignore non humanoids (eg pets)
-        if (!allowNonHumanoids && !HasComp<HumanoidAppearanceComponent>(playerEntity))
-            return false;
+    protected override void Added(EntityUid uid, AntagSelectionComponent component, GameRuleComponent gameRule, GameRuleAddedEvent args)
+    {
+        base.Added(uid, component, gameRule, args);
 
-        //If a custom condition was provided, test it and exclude the player if it returns true
-        if (customExcludeCondition != null && customExcludeCondition(playerEntity))
-            return false;
+        for (var i = 0; i < component.Definitions.Count; i++)
+        {
+            var def = component.Definitions[i];
 
+            if (def.MinRange != null)
+            {
+                def.Min = def.MinRange.Value.Next(RobustRandom);
+            }
 
-        return true;
+            if (def.MaxRange != null)
+            {
+                def.Max = def.MaxRange.Value.Next(RobustRandom);
+            }
+        }
     }
 
-    /// <summary>
-    /// Check if the session is eligible for a role, can be run prior to the session being attached to an entity
-    /// </summary>
-    /// <param name="session">Player session to check</param>
-    /// <param name="antagPrototype">Which antag prototype to check for</param>
-    /// <param name="ignorePreferences">Ignore if the player has enabled this antag</param>
-    /// <returns>True if the session matches the requirements, false otherwise</returns>
-    public bool IsSessionEligible(ICommonSession session, ProtoId<AntagPrototype> antagPrototype, bool ignorePreferences = false)
+    protected override void Started(EntityUid uid, AntagSelectionComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
     {
-        //Exclude disconnected or zombie sessions
-        //No point giving antag roles to them
-        if (session.Status == SessionStatus.Disconnected ||
-            session.Status == SessionStatus.Zombie)
-            return false;
+        base.Started(uid, component, gameRule, args);
 
-        //Check the player has this antag preference selected
-        //Unless we are ignoring preferences, in which case add them anyway
-        var pref = (HumanoidCharacterProfile) _prefs.GetPreferences(session.UserId).SelectedCharacter;
-        if (!pref.AntagPreferences.Contains(antagPrototype.Id) && !ignorePreferences)
-            return false;
+        // If the round has not yet started, we defer antag selection until roundstart
+        if (GameTicker.RunLevel != GameRunLevel.InRound)
+            return;
 
-        return true;
+        if (component.SelectionsComplete)
+            return;
+
+        var players = _playerManager.Sessions
+            .Where(x => GameTicker.PlayerGameStatuses[x.UserId] == PlayerGameStatus.JoinedGame)
+            .ToList();
+
+        ChooseAntags((uid, component), players);
     }
-    #endregion
 
     /// <summary>
-    /// Helper method to calculate the number of antags to select based upon the number of players
+    /// Chooses antagonists from the given selection of players
     /// </summary>
-    /// <param name="playerCount">How many players there are on the server</param>
-    /// <param name="playersPerAntag">How many players should there be for an additional antag</param>
-    /// <param name="maxAntags">Maximum number of antags allowed</param>
-    /// <returns>The number of antags that should be chosen</returns>
-    public int CalculateAntagCount(int playerCount, int playersPerAntag, int maxAntags)
+    public void ChooseAntags(Entity<AntagSelectionComponent> ent, IList<ICommonSession> pool)
     {
-        return Math.Clamp(playerCount / playersPerAntag, 1, maxAntags);
+        if (ent.Comp.SelectionsComplete)
+            return;
+
+        foreach (var def in ent.Comp.Definitions)
+        {
+            ChooseAntags(ent, pool, def);
+        }
+
+        ent.Comp.SelectionsComplete = true;
     }
 
-    #region Antag Selection
     /// <summary>
-    /// Selects a set number of entities from several lists, prioritising the first list till its empty, then second list etc
+    /// Chooses antagonists from the given selection of players for the given antag definition.
     /// </summary>
-    /// <param name="eligiblePlayerLists">Array of lists, which are chosen from in order until the correct number of items are selected</param>
-    /// <param name="count">How many items to select</param>
-    /// <returns>Up to the specified count of elements from all provided lists</returns>
-    public List<EntityUid> ChooseAntags(int count, params List<EntityUid>[] eligiblePlayerLists)
+    public void ChooseAntags(Entity<AntagSelectionComponent> ent, IList<ICommonSession> pool, AntagSelectionDefinition def)
     {
-        var chosenPlayers = new List<EntityUid>();
-        foreach (var playerList in eligiblePlayerLists)
+        var playerPool = GetPlayerPool(ent, pool, def);
+        var count = GetTargetAntagCount(ent, GetTotalPlayerCount(pool), def);
+
+        for (var i = 0; i < count; i++)
         {
-            //Remove all chosen players from this list, to prevent duplicates
-            foreach (var chosenPlayer in chosenPlayers)
+            var session = (ICommonSession?) null;
+            if (def.PickPlayer)
             {
-                playerList.Remove(chosenPlayer);
-            }
+                if (!playerPool.TryPickAndTake(RobustRandom, out session))
+                    break;
 
-            //If we have reached the desired number of players, skip
-            if (chosenPlayers.Count >= count)
-                continue;
+                if (ent.Comp.SelectedSessions.Contains(session))
+                    continue;
+            }
 
-            //Pick and choose a random number of players from this list
-            chosenPlayers.AddRange(ChooseAntags(count - chosenPlayers.Count, playerList));
+            MakeAntag(ent, session, def);
         }
-        return chosenPlayers;
     }
+
     /// <summary>
-    /// Helper method to choose antags from a list
+    /// Tries to makes a given player into the specified antagonist.
     /// </summary>
-    /// <param name="eligiblePlayers">List of eligible players</param>
-    /// <param name="count">How many to choose</param>
-    /// <returns>Up to the specified count of elements from the provided list</returns>
-    public List<EntityUid> ChooseAntags(int count, List<EntityUid> eligiblePlayers)
+    public bool TryMakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? session, AntagSelectionDefinition def, bool ignoreSpawner = false)
     {
-        var chosenPlayers = new List<EntityUid>();
-
-        for (var i = 0; i < count; i++)
+        if (!IsSessionValid(ent, session, def) ||
+            !IsEntityValid(session?.AttachedEntity, def))
         {
-            if (eligiblePlayers.Count == 0)
-                break;
-
-            chosenPlayers.Add(RobustRandom.PickAndTake(eligiblePlayers));
+            return false;
         }
 
-        return chosenPlayers;
+        MakeAntag(ent, session, def, ignoreSpawner);
+        return true;
     }
 
     /// <summary>
-    /// Selects a set number of sessions from several lists, prioritising the first list till its empty, then second list etc
+    /// Makes a given player into the specified antagonist.
     /// </summary>
-    /// <param name="eligiblePlayerLists">Array of lists, which are chosen from in order until the correct number of items are selected</param>
-    /// <param name="count">How many items to select</param>
-    /// <returns>Up to the specified count of elements from all provided lists</returns>
-    public List<ICommonSession> ChooseAntags(int count, params List<ICommonSession>[] eligiblePlayerLists)
+    public void MakeAntag(Entity<AntagSelectionComponent> ent, ICommonSession? session, AntagSelectionDefinition def, bool ignoreSpawner = false)
     {
-        var chosenPlayers = new List<ICommonSession>();
-        foreach (var playerList in eligiblePlayerLists)
+        var antagEnt = (EntityUid?) null;
+        var isSpawner = false;
+
+        if (session != null)
         {
-            //Remove all chosen players from this list, to prevent duplicates
-            foreach (var chosenPlayer in chosenPlayers)
+            ent.Comp.SelectedSessions.Add(session);
+
+            // we shouldn't be blocking the entity if they're just a ghost or smth.
+            if (!HasComp<GhostComponent>(session.AttachedEntity))
+                antagEnt = session.AttachedEntity;
+        }
+        else if (!ignoreSpawner && def.SpawnerPrototype != null) // don't add spawners if we have a player, dummy.
+        {
+            antagEnt = Spawn(def.SpawnerPrototype);
+            isSpawner = true;
+        }
+
+        if (!antagEnt.HasValue)
+        {
+            var getEntEv = new AntagSelectEntityEvent(session, ent);
+            RaiseLocalEvent(ent, ref getEntEv, true);
+
+            if (!getEntEv.Handled)
             {
-                playerList.Remove(chosenPlayer);
+                throw new InvalidOperationException($"Attempted to make {session} antagonist in gamerule {ToPrettyString(ent)} but there was no valid entity for player.");
             }
 
-            //If we have reached the desired number of players, skip
-            if (chosenPlayers.Count >= count)
-                continue;
+            antagEnt = getEntEv.Entity;
+        }
+
+        if (antagEnt is not { } player)
+            return;
 
-            //Pick and choose a random number of players from this list
-            chosenPlayers.AddRange(ChooseAntags(count - chosenPlayers.Count, playerList));
+        var getPosEv = new AntagSelectLocationEvent(session, ent);
+        RaiseLocalEvent(ent, ref getPosEv, true);
+        if (getPosEv.Handled)
+        {
+            var playerXform = Transform(player);
+            var pos = RobustRandom.Pick(getPosEv.Coordinates);
+            _transform.SetMapCoordinates((player, playerXform), pos);
         }
-        return chosenPlayers;
-    }
-    /// <summary>
-    /// Helper method to choose sessions from a list
-    /// </summary>
-    /// <param name="eligiblePlayers">List of eligible sessions</param>
-    /// <param name="count">How many to choose</param>
-    /// <returns>Up to the specified count of elements from the provided list</returns>
-    public List<ICommonSession> ChooseAntags(int count, List<ICommonSession> eligiblePlayers)
-    {
-        var chosenPlayers = new List<ICommonSession>();
 
-        for (int i = 0; i < count; i++)
+        if (isSpawner)
         {
-            if (eligiblePlayers.Count == 0)
-                break;
+            if (!TryComp<GhostRoleAntagSpawnerComponent>(player, out var spawnerComp))
+            {
+                Log.Error("Antag spawner with GhostRoleAntagSpawnerComponent.");
+                return;
+            }
 
-            chosenPlayers.Add(RobustRandom.PickAndTake(eligiblePlayers));
+            spawnerComp.Rule = ent;
+            spawnerComp.Definition = def;
+            return;
         }
 
-        return chosenPlayers;
+        EntityManager.AddComponents(player, def.Components);
+        _stationSpawning.EquipStartingGear(player, def.StartingGear);
+
+        if (session != null)
+        {
+            var curMind = session.GetMind();
+            if (curMind == null)
+            {
+                curMind = _mind.CreateMind(session.UserId, Name(antagEnt.Value));
+                _mind.SetUserId(curMind.Value, session.UserId);
+            }
+
+            _mind.TransferTo(curMind.Value, antagEnt, ghostCheckOverride: true);
+            _role.MindAddRoles(curMind.Value, def.MindComponents);
+            ent.Comp.SelectedMinds.Add((curMind.Value, Name(player)));
+            SendBriefing(session, def.Briefing);
+        }
+
+        var afterEv = new AfterAntagEntitySelectedEvent(session, player, ent, def);
+        RaiseLocalEvent(ent, ref afterEv, true);
     }
-    #endregion
 
-    #region Briefings
     /// <summary>
-    /// Helper method to send the briefing text and sound to a list of entities
+    /// Gets an ordered player pool based on player preferences and the antagonist definition.
     /// </summary>
-    /// <param name="entities">The players chosen to be antags</param>
-    /// <param name="briefing">The briefing text to send</param>
-    /// <param name="briefingColor">The color the briefing should be, null for default</param>
-    /// <param name="briefingSound">The sound to briefing/greeting sound to play</param>
-    public void SendBriefing(List<EntityUid> entities, string briefing, Color? briefingColor, SoundSpecifier? briefingSound)
+    public AntagSelectionPlayerPool GetPlayerPool(Entity<AntagSelectionComponent> ent, IList<ICommonSession> sessions, AntagSelectionDefinition def)
     {
-        foreach (var entity in entities)
+        var preferredList = new List<ICommonSession>();
+        var fallbackList = new List<ICommonSession>();
+        foreach (var session in sessions)
         {
-            SendBriefing(entity, briefing, briefingColor, briefingSound);
+            if (!IsSessionValid(ent, session, def) ||
+                !IsEntityValid(session.AttachedEntity, def))
+                continue;
+
+            var pref = (HumanoidCharacterProfile) _pref.GetPreferences(session.UserId).SelectedCharacter;
+            if (def.PrefRoles.Count != 0 && pref.AntagPreferences.Any(p => def.PrefRoles.Contains(p)))
+            {
+                preferredList.Add(session);
+            }
+            else if (def.FallbackRoles.Count != 0 && pref.AntagPreferences.Any(p => def.FallbackRoles.Contains(p)))
+            {
+                fallbackList.Add(session);
+            }
         }
+
+        return new AntagSelectionPlayerPool(new() { preferredList, fallbackList });
     }
 
     /// <summary>
-    /// Helper method to send the briefing text and sound to a player entity
+    /// Checks if a given session is valid for an antagonist.
     /// </summary>
-    /// <param name="entity">The entity chosen to be antag</param>
-    /// <param name="briefing">The briefing text to send</param>
-    /// <param name="briefingColor">The color the briefing should be, null for default</param>
-    /// <param name="briefingSound">The sound to briefing/greeting sound to play</param>
-    public void SendBriefing(EntityUid entity, string briefing, Color? briefingColor, SoundSpecifier? briefingSound)
+    public bool IsSessionValid(Entity<AntagSelectionComponent> ent, ICommonSession? session, AntagSelectionDefinition def, EntityUid? mind = null)
     {
-        if (!_mindSystem.TryGetMind(entity, out _, out var mindComponent))
-            return;
+        if (session == null)
+            return true;
 
-        if (mindComponent.Session == null)
-            return;
+        if (session.Status is SessionStatus.Disconnected or SessionStatus.Zombie)
+            return false;
 
-        SendBriefing(mindComponent.Session, briefing, briefingColor, briefingSound);
-    }
+        if (ent.Comp.SelectedSessions.Contains(session))
+            return false;
 
-    /// <summary>
-    /// Helper method to send the briefing text and sound to a list of sessions
-    /// </summary>
-    /// <param name="sessions"></param>
-    /// <param name="briefing"></param>
-    /// <param name="briefingColor"></param>
-    /// <param name="briefingSound"></param>
+        mind ??= session.GetMind();
 
-    public void SendBriefing(List<ICommonSession> sessions, string briefing, Color? briefingColor, SoundSpecifier? briefingSound)
-    {
-        foreach (var session in sessions)
+        // If the player has not spawned in as any entity (e.g., in the lobby), they can be given an antag role/entity.
+        if (mind == null)
+            return true;
+
+        //todo: we need some way to check that we're not getting the same role twice. (double picking thieves or zombies through midrounds)
+
+        switch (def.MultiAntagSetting)
         {
-            SendBriefing(session, briefing, briefingColor, briefingSound);
+            case AntagAcceptability.None:
+            {
+                if (_role.MindIsAntagonist(mind))
+                    return false;
+                break;
+            }
+            case AntagAcceptability.NotExclusive:
+            {
+                if (_role.MindIsExclusiveAntagonist(mind))
+                    return false;
+                break;
+            }
         }
+
+        // todo: expand this to allow for more fine antag-selection logic for game rules.
+        if (!_jobs.CanBeAntag(session))
+            return false;
+
+        return true;
     }
+
     /// <summary>
-    /// Helper method to send the briefing text and sound to a session
+    /// Checks if a given entity (mind/session not included) is valid for a given antagonist.
     /// </summary>
-    /// <param name="session">The player chosen to be an antag</param>
-    /// <param name="briefing">The briefing text to send</param>
-    /// <param name="briefingColor">The color the briefing should be, null for default</param>
-    /// <param name="briefingSound">The sound to briefing/greeting sound to play</param>
-
-    public void SendBriefing(ICommonSession session, string briefing, Color? briefingColor, SoundSpecifier? briefingSound)
+    public bool IsEntityValid(EntityUid? entity, AntagSelectionDefinition def)
     {
-        _audioSystem.PlayGlobal(briefingSound, session);
-        var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", briefing));
-        ChatManager.ChatMessageToOne(ChatChannel.Server, briefing, wrappedMessage, default, false, session.Channel, briefingColor);
+        // If the player has not spawned in as any entity (e.g., in the lobby), they can be given an antag role/entity.
+        if (entity == null)
+            return true;
+
+        if (HasComp<PendingClockInComponent>(entity))
+            return false;
+
+        if (!def.AllowNonHumans && !HasComp<HumanoidAppearanceComponent>(entity))
+            return false;
+
+        if (def.Whitelist != null)
+        {
+            if (!def.Whitelist.IsValid(entity.Value, EntityManager))
+                return false;
+        }
+
+        if (def.Blacklist != null)
+        {
+            if (def.Blacklist.IsValid(entity.Value, EntityManager))
+                return false;
+        }
+
+        return true;
     }
-    #endregion
 }
+
+/// <summary>
+/// Event raised on a game rule entity in order to determine what the antagonist entity will be.
+/// Only raised if the selected player's current entity is invalid.
+/// </summary>
+[ByRefEvent]
+public record struct AntagSelectEntityEvent(ICommonSession? Session, Entity<AntagSelectionComponent> GameRule)
+{
+    public readonly ICommonSession? Session = Session;
+
+    public bool Handled => Entity != null;
+
+    public EntityUid? Entity;
+}
+
+/// <summary>
+/// Event raised on a game rule entity to determine the location for the antagonist.
+/// </summary>
+[ByRefEvent]
+public record struct AntagSelectLocationEvent(ICommonSession? Session, Entity<AntagSelectionComponent> GameRule)
+{
+    public readonly ICommonSession? Session = Session;
+
+    public bool Handled => Coordinates.Any();
+
+    public List<MapCoordinates> Coordinates = new();
+}
+
+/// <summary>
+/// Event raised on a game rule entity after the setup logic for an antag is complete.
+/// Used for applying additional more complex setup logic.
+/// </summary>
+[ByRefEvent]
+public readonly record struct AfterAntagEntitySelectedEvent(ICommonSession? Session, EntityUid EntityUid, Entity<AntagSelectionComponent> GameRule, AntagSelectionDefinition Def);
diff --git a/Content.Server/Antag/Components/AntagSelectionComponent.cs b/Content.Server/Antag/Components/AntagSelectionComponent.cs
new file mode 100644
index 00000000000..096be14049a
--- /dev/null
+++ b/Content.Server/Antag/Components/AntagSelectionComponent.cs
@@ -0,0 +1,189 @@
+using Content.Server.Administration.Systems;
+using Content.Server.Destructible.Thresholds;
+using Content.Shared.Antag;
+using Content.Shared.Roles;
+using Content.Shared.Storage;
+using Content.Shared.Whitelist;
+using Robust.Shared.Audio;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.Antag.Components;
+
+[RegisterComponent, Access(typeof(AntagSelectionSystem), typeof(AdminVerbSystem))]
+public sealed partial class AntagSelectionComponent : Component
+{
+    /// <summary>
+    /// Has the primary selection of antagonists finished yet?
+    /// </summary>
+    [DataField]
+    public bool SelectionsComplete;
+
+    /// <summary>
+    /// The definitions for the antagonists
+    /// </summary>
+    [DataField]
+    public List<AntagSelectionDefinition> Definitions = new();
+
+    /// <summary>
+    /// The minds and original names of the players selected to be antagonists.
+    /// </summary>
+    [DataField]
+    public List<(EntityUid, string)> SelectedMinds = new();
+
+    /// <summary>
+    /// When the antag selection will occur.
+    /// </summary>
+    [DataField]
+    public AntagSelectionTime SelectionTime = AntagSelectionTime.PostPlayerSpawn;
+
+    /// <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> SelectedSessions = new();
+}
+
+[DataDefinition]
+public partial struct AntagSelectionDefinition()
+{
+    /// <summary>
+    /// A list of antagonist roles that are used for selecting which players will be antagonists.
+    /// </summary>
+    [DataField]
+    public List<ProtoId<AntagPrototype>> PrefRoles = new();
+
+    /// <summary>
+    /// Fallback for <see cref="PrefRoles"/>. Useful if you need multiple role preferences for a team antagonist.
+    /// </summary>
+    [DataField]
+    public List<ProtoId<AntagPrototype>> FallbackRoles = new();
+
+    /// <summary>
+    /// Should we allow people who already have an antagonist role?
+    /// </summary>
+    [DataField]
+    public AntagAcceptability MultiAntagSetting = AntagAcceptability.None;
+
+    /// <summary>
+    /// The minimum number of this antag.
+    /// </summary>
+    [DataField]
+    public int Min = 1;
+
+    /// <summary>
+    /// The maximum number of this antag.
+    /// </summary>
+    [DataField]
+    public int Max = 1;
+
+    /// <summary>
+    /// A range used to randomly select <see cref="Min"/>
+    /// </summary>
+    [DataField]
+    public MinMax? MinRange;
+
+    /// <summary>
+    /// A range used to randomly select <see cref="Max"/>
+    /// </summary>
+    [DataField]
+    public MinMax? MaxRange;
+
+    /// <summary>
+    /// a player to antag ratio: used to determine the amount of antags that will be present.
+    /// </summary>
+    [DataField]
+    public int PlayerRatio = 10;
+
+    /// <summary>
+    /// Whether or not players should be picked to inhabit this antag or not.
+    /// </summary>
+    [DataField]
+    public bool PickPlayer = true;
+
+    /// <summary>
+    /// If true, players that latejoin into a round have a chance of being converted into antagonists.
+    /// </summary>
+    [DataField]
+    public bool LateJoinAdditional = false;
+
+    //todo: find out how to do this with minimal boilerplate: filler department, maybe?
+    //public HashSet<ProtoId<JobPrototype>> JobBlacklist = new()
+
+    /// <remarks>
+    /// Mostly just here for legacy compatibility and reducing boilerplate
+    /// </remarks>
+    [DataField]
+    public bool AllowNonHumans = false;
+
+    /// <summary>
+    /// A whitelist for selecting which players can become this antag.
+    /// </summary>
+    [DataField]
+    public EntityWhitelist? Whitelist;
+
+    /// <summary>
+    /// A blacklist for selecting which players can become this antag.
+    /// </summary>
+    [DataField]
+    public EntityWhitelist? Blacklist;
+
+    /// <summary>
+    /// Components added to the player.
+    /// </summary>
+    [DataField]
+    public ComponentRegistry Components = new();
+
+    /// <summary>
+    /// Components added to the player's mind.
+    /// </summary>
+    [DataField]
+    public ComponentRegistry MindComponents = new();
+
+    /// <summary>
+    /// A set of starting gear that's equipped to the player.
+    /// </summary>
+    [DataField]
+    public ProtoId<StartingGearPrototype>? StartingGear;
+
+    /// <summary>
+    /// A briefing shown to the player.
+    /// </summary>
+    [DataField]
+    public BriefingData? Briefing;
+
+    /// <summary>
+    /// A spawner used to defer the selection of this particular definition.
+    /// </summary>
+    /// <remarks>
+    /// Not the cleanest way of doing this code but it's just an odd specific behavior.
+    /// Sue me.
+    /// </remarks>
+    [DataField]
+    public EntProtoId? SpawnerPrototype;
+}
+
+/// <summary>
+/// Contains data used to generate a briefing.
+/// </summary>
+[DataDefinition]
+public partial struct BriefingData
+{
+    /// <summary>
+    /// The text shown
+    /// </summary>
+    [DataField]
+    public LocId? Text;
+
+    /// <summary>
+    /// The color of the text.
+    /// </summary>
+    [DataField]
+    public Color? Color;
+
+    /// <summary>
+    /// The sound played.
+    /// </summary>
+    [DataField]
+    public SoundSpecifier? Sound;
+}
diff --git a/Content.Server/Antag/Components/GhostRoleAntagSpawnerComponent.cs b/Content.Server/Antag/Components/GhostRoleAntagSpawnerComponent.cs
new file mode 100644
index 00000000000..fcaa4d42672
--- /dev/null
+++ b/Content.Server/Antag/Components/GhostRoleAntagSpawnerComponent.cs
@@ -0,0 +1,14 @@
+namespace Content.Server.Antag.Components;
+
+/// <summary>
+/// Ghost role spawner that creates an antag for the associated gamerule.
+/// </summary>
+[RegisterComponent, Access(typeof(AntagSelectionSystem))]
+public sealed partial class GhostRoleAntagSpawnerComponent : Component
+{
+    [DataField]
+    public EntityUid? Rule;
+
+    [DataField]
+    public AntagSelectionDefinition? Definition;
+}
diff --git a/Content.Server/Antag/MobReplacementRuleSystem.cs b/Content.Server/Antag/MobReplacementRuleSystem.cs
index ba09c84bce4..18837b5a7c8 100644
--- a/Content.Server/Antag/MobReplacementRuleSystem.cs
+++ b/Content.Server/Antag/MobReplacementRuleSystem.cs
@@ -1,45 +1,16 @@
-using System.Numerics;
-using Content.Server.Advertise.Components;
-using Content.Server.Advertise.EntitySystems;
 using Content.Server.Antag.Mimic;
-using Content.Server.Chat.Systems;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules;
 using Content.Server.GameTicking.Rules.Components;
-using Content.Server.NPC.Systems;
-using Content.Server.Station.Systems;
-using Content.Server.GameTicking;
 using Content.Shared.VendingMachines;
 using Robust.Shared.Map;
-using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
-using Robust.Server.GameObjects;
-using Robust.Shared.Physics.Systems;
-using System.Linq;
-using Robust.Shared.Physics;
-using Content.Shared.Movement.Components;
-using Content.Shared.Damage;
-using Content.Server.NPC.HTN;
-using Content.Server.NPC;
-using Content.Shared.Weapons.Melee;
-using Content.Server.Power.Components;
-using Content.Shared.CombatMode;
 
 namespace Content.Server.Antag;
 
 public sealed class MobReplacementRuleSystem : GameRuleSystem<MobReplacementRuleComponent>
 {
     [Dependency] private readonly IRobustRandom _random = default!;
-    [Dependency] private readonly StationSystem _station = default!;
-    [Dependency] private readonly GameTicker _gameTicker = default!;
-    [Dependency] private readonly ChatSystem _chat = default!;
-    [Dependency] private readonly IPrototypeManager _prototype = default!;
-    [Dependency] private readonly IComponentFactory _componentFactory = default!;
-    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
-    [Dependency] private readonly NpcFactionSystem _npcFaction = default!;
-    [Dependency] private readonly NPCSystem _npc = default!;
-    [Dependency] private readonly SharedTransformSystem _transform = default!;
-    [Dependency] private readonly AdvertiseSystem _advertise = default!;
-
 
     protected override void Started(EntityUid uid, MobReplacementRuleComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
     {
@@ -47,133 +18,21 @@ protected override void Started(EntityUid uid, MobReplacementRuleComponent compo
 
         var query = AllEntityQuery<VendingMachineComponent, TransformComponent>();
         var spawns = new List<(EntityUid Entity, EntityCoordinates Coordinates)>();
-        var stations = _gameTicker.GetSpawnableStations();
 
         while (query.MoveNext(out var vendingUid, out _, out var xform))
         {
-            var ownerStation = _station.GetOwningStation(vendingUid);
-
-            if (ownerStation == null
-                || ownerStation != stations[0])
-                continue;
-
-            // Make sure that we aren't running this on something that is already a mimic
-            if (HasComp<CombatModeComponent>(vendingUid))
+            if (!_random.Prob(component.Chance))
                 continue;
 
             spawns.Add((vendingUid, xform.Coordinates));
         }
 
-        if (spawns == null)
+        foreach (var entity in spawns)
         {
-            //WTF THE STATION DOESN'T EXIST! WE MUST BE IN A TEST! QUICK, PUT A MIMIC AT 0,0!!!
-            Spawn(component.Proto, new EntityCoordinates(uid, new Vector2(0, 0)));
-        }
-        else
-        {
-            // This is intentionally not clamped. If a server host wants to replace every vending machine in the entire station with a mimic, who am I to stop them?
-            var k = MathF.MaxMagnitude(component.NumberToReplace, 1);
-            while (k > 0 && spawns != null && spawns.Count > 0)
-            {
-                if (k > 1)
-                {
-                    var spawnLocation = _random.PickAndTake(spawns);
-                    BuildAMimicWorkshop(spawnLocation.Entity, component);
-                }
-                else
-                {
-                    BuildAMimicWorkshop(spawns[0].Entity, component);
-                }
-
-                if (k == MathF.MaxMagnitude(component.NumberToReplace, 1)
-                    && component.DoAnnouncement)
-                    _chat.DispatchStationAnnouncement(stations[0], Loc.GetString("station-event-rampant-intelligence-announcement"), playDefaultSound: true,
-                        colorOverride: Color.Red, sender: "Central Command");
-
-                k--;
-            }
-        }
-    }
-
-    /// <summary>
-    /// 	It's like Build a Bear, but MURDER
-    /// </summary>
-    /// <param name="uid"></param>
-    public void BuildAMimicWorkshop(EntityUid uid, MobReplacementRuleComponent component)
-    {
-        var metaData = MetaData(uid);
-        var vendorPrototype = metaData.EntityPrototype;
-        var mimicProto = _prototype.Index<EntityPrototype>(component.Proto);
-
-        var vendorComponents = vendorPrototype?.Components.Keys
-            .Where(n => n != "Transform" && n != "MetaData")
-            .Select(name => (name, _componentFactory.GetRegistration(name).Type))
-            .ToList() ?? new List<(string name, Type type)>();
-
-        var mimicComponents = mimicProto?.Components.Keys
-            .Where(n => n != "Transform" && n != "MetaData")
-            .Select(name => (name, _componentFactory.GetRegistration(name).Type))
-            .ToList() ?? new List<(string name, Type type)>();
+            var coordinates = entity.Coordinates;
+            Del(entity.Entity);
 
-        foreach (var name in mimicComponents.Except(vendorComponents))
-        {
-            var newComponent = _componentFactory.GetComponent(name.name);
-            EntityManager.AddComponent(uid, newComponent);
+            Spawn(component.Proto, coordinates);
         }
-
-        var xform = Transform(uid);
-        if (xform.Anchored)
-            _transform.Unanchor(uid, xform);
-
-        SetupMimicNPC(uid, component);
-
-        if (TryComp<AdvertiseComponent>(uid, out var vendor)
-            && component.VendorModify)
-            SetupMimicVendor(uid, component, vendor);
-    }
-    /// <summary>
-    /// 	This handles getting the entity ready to be a hostile NPC
-    /// </summary>
-    /// <param name="uid"></param>
-    /// <param name="component"></param>
-    private void SetupMimicNPC(EntityUid uid, MobReplacementRuleComponent component)
-    {
-        _physics.SetBodyType(uid, BodyType.KinematicController);
-        _npcFaction.AddFaction(uid, "SimpleHostile");
-
-        var melee = EnsureComp<MeleeWeaponComponent>(uid);
-        melee.Angle = 0;
-        DamageSpecifier dspec = new()
-        {
-            DamageDict = new()
-            {
-                { "Blunt", component.MimicMeleeDamage }
-            }
-        };
-        melee.Damage = dspec;
-
-        var movementSpeed = EnsureComp<MovementSpeedModifierComponent>(uid);
-        (movementSpeed.BaseSprintSpeed, movementSpeed.BaseWalkSpeed) = (component.MimicMoveSpeed, component.MimicMoveSpeed);
-
-        var htn = EnsureComp<HTNComponent>(uid);
-        htn.RootTask = new HTNCompoundTask() { Task = component.MimicAIType };
-        htn.Blackboard.SetValue(NPCBlackboard.NavSmash, component.MimicSmashGlass);
-        _npc.WakeNPC(uid, htn);
-    }
-
-    /// <summary>
-    /// Handling specific interactions with vending machines
-    /// </summary>
-    /// <param name="uid"></param>
-    /// <param name="mimicComponent"></param>
-    /// <param name="vendorComponent"></param>
-    private void SetupMimicVendor(EntityUid uid, MobReplacementRuleComponent mimicComponent, AdvertiseComponent vendorComponent)
-    {
-        vendorComponent.MinimumWait = 5;
-        vendorComponent.MaximumWait = 15;
-        _advertise.SayAdvertisement(uid, vendorComponent);
-
-        if (TryComp<ApcPowerReceiverComponent>(uid, out var aPC))
-            aPC.NeedsPower = false;
     }
 }
diff --git a/Content.Server/DeltaV/ParadoxAnomaly/Systems/ParadoxAnomalySystem.cs b/Content.Server/DeltaV/ParadoxAnomaly/Systems/ParadoxAnomalySystem.cs
index d8ca263d5b2..477a3c56590 100644
--- a/Content.Server/DeltaV/ParadoxAnomaly/Systems/ParadoxAnomalySystem.cs
+++ b/Content.Server/DeltaV/ParadoxAnomaly/Systems/ParadoxAnomalySystem.cs
@@ -144,7 +144,7 @@ private bool TrySpawnParadoxAnomaly(string rule, [NotNullWhen(true)] out EntityU
 
         if (job.StartingGear != null && _proto.TryIndex<StartingGearPrototype>(job.StartingGear, out var gear))
         {
-            _stationSpawning.EquipStartingGear(spawned, gear, profile);
+            _stationSpawning.EquipStartingGear(spawned, gear);
             _stationSpawning.EquipIdCard(spawned,
                 profile.Name,
                 job,
diff --git a/Content.Server/DeltaV/StationEvents/Events/GlimmerMobSpawnRule.cs b/Content.Server/DeltaV/StationEvents/Events/GlimmerMobSpawnRule.cs
index ec9ec770313..6849c508a1f 100644
--- a/Content.Server/DeltaV/StationEvents/Events/GlimmerMobSpawnRule.cs
+++ b/Content.Server/DeltaV/StationEvents/Events/GlimmerMobSpawnRule.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Robust.Shared.Random;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.NPC.Components;
diff --git a/Content.Server/DeltaV/StationEvents/Events/PirateRadioSpawnRule.cs b/Content.Server/DeltaV/StationEvents/Events/PirateRadioSpawnRule.cs
index 4e43c1ff967..43e7c3b4747 100644
--- a/Content.Server/DeltaV/StationEvents/Events/PirateRadioSpawnRule.cs
+++ b/Content.Server/DeltaV/StationEvents/Events/PirateRadioSpawnRule.cs
@@ -13,6 +13,7 @@
 using Content.Shared.Salvage;
 using Content.Shared.Random.Helpers;
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Content.Shared.CCVar;
 
 namespace Content.Server.StationEvents.Events;
diff --git a/Content.Server/Destructible/Thresholds/MinMax.cs b/Content.Server/Destructible/Thresholds/MinMax.cs
index b438e7c0e8d..c44864183ab 100644
--- a/Content.Server/Destructible/Thresholds/MinMax.cs
+++ b/Content.Server/Destructible/Thresholds/MinMax.cs
@@ -1,4 +1,6 @@
-namespace Content.Server.Destructible.Thresholds
+using Robust.Shared.Random;
+
+namespace Content.Server.Destructible.Thresholds
 {
     [Serializable]
     [DataDefinition]
@@ -9,5 +11,16 @@ public partial struct MinMax
 
         [DataField("max")]
         public int Max;
+
+        public MinMax(int min, int max)
+        {
+            Min = min;
+            Max = max;
+        }
+
+        public int Next(IRobustRandom random)
+        {
+            return random.Next(Min, Max + 1);
+        }
     }
 }
diff --git a/Content.Server/Entry/EntryPoint.cs b/Content.Server/Entry/EntryPoint.cs
index a04f274491c..48a65973491 100644
--- a/Content.Server/Entry/EntryPoint.cs
+++ b/Content.Server/Entry/EntryPoint.cs
@@ -5,9 +5,9 @@
 using Content.Server.Afk;
 using Content.Server.Chat.Managers;
 using Content.Server.Connection;
-using Content.Server.DiscordAuth;
 using Content.Server.JoinQueue;
 using Content.Server.Database;
+using Content.Server.DiscordAuth;
 using Content.Server.EUI;
 using Content.Server.GameTicking;
 using Content.Server.GhostKick;
diff --git a/Content.Server/GameTicking/Rules/Components/ActiveGameRuleComponent.cs b/Content.Server/GameTicking/Components/ActiveGameRuleComponent.cs
similarity index 84%
rename from Content.Server/GameTicking/Rules/Components/ActiveGameRuleComponent.cs
rename to Content.Server/GameTicking/Components/ActiveGameRuleComponent.cs
index 956768bdd99..b9e6fa5d4b8 100644
--- a/Content.Server/GameTicking/Rules/Components/ActiveGameRuleComponent.cs
+++ b/Content.Server/GameTicking/Components/ActiveGameRuleComponent.cs
@@ -1,4 +1,4 @@
-namespace Content.Server.GameTicking.Rules.Components;
+namespace Content.Server.GameTicking.Components;
 
 /// <summary>
 ///     Added to game rules before <see cref="GameRuleStartedEvent"/> and removed before <see cref="GameRuleEndedEvent"/>.
diff --git a/Content.Server/GameTicking/Components/DelayedStartRuleComponent.cs b/Content.Server/GameTicking/Components/DelayedStartRuleComponent.cs
new file mode 100644
index 00000000000..de4be83627d
--- /dev/null
+++ b/Content.Server/GameTicking/Components/DelayedStartRuleComponent.cs
@@ -0,0 +1,16 @@
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Server.GameTicking.Components;
+
+/// <summary>
+/// Generic component used to track a gamerule that's start has been delayed.
+/// </summary>
+[RegisterComponent, AutoGenerateComponentPause]
+public sealed partial class DelayedStartRuleComponent : Component
+{
+    /// <summary>
+    /// The time at which the rule will start properly.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+    public TimeSpan RuleStartTime;
+}
diff --git a/Content.Server/GameTicking/Rules/Components/EndedGameRuleComponent.cs b/Content.Server/GameTicking/Components/EndedGameRuleComponent.cs
similarity index 81%
rename from Content.Server/GameTicking/Rules/Components/EndedGameRuleComponent.cs
rename to Content.Server/GameTicking/Components/EndedGameRuleComponent.cs
index 4484abd4d0b..3234bfff3a0 100644
--- a/Content.Server/GameTicking/Rules/Components/EndedGameRuleComponent.cs
+++ b/Content.Server/GameTicking/Components/EndedGameRuleComponent.cs
@@ -1,4 +1,4 @@
-namespace Content.Server.GameTicking.Rules.Components;
+namespace Content.Server.GameTicking.Components;
 
 /// <summary>
 ///     Added to game rules before <see cref="GameRuleEndedEvent"/>.
diff --git a/Content.Server/GameTicking/Rules/Components/GameRuleComponent.cs b/Content.Server/GameTicking/Components/GameRuleComponent.cs
similarity index 83%
rename from Content.Server/GameTicking/Rules/Components/GameRuleComponent.cs
rename to Content.Server/GameTicking/Components/GameRuleComponent.cs
index 6309b974020..1e6c3f0ab1d 100644
--- a/Content.Server/GameTicking/Rules/Components/GameRuleComponent.cs
+++ b/Content.Server/GameTicking/Components/GameRuleComponent.cs
@@ -1,6 +1,7 @@
+using Content.Server.Destructible.Thresholds;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 
-namespace Content.Server.GameTicking.Rules.Components;
+namespace Content.Server.GameTicking.Components;
 
 /// <summary>
 /// Component attached to all gamerule entities.
@@ -20,6 +21,12 @@ public sealed partial class GameRuleComponent : Component
     /// </summary>
     [DataField]
     public int MinPlayers;
+
+    /// <summary>
+    /// A delay for when the rule the is started and when the starting logic actually runs.
+    /// </summary>
+    [DataField]
+    public MinMax? Delay;
 }
 
 /// <summary>
diff --git a/Content.Server/GameTicking/GameTicker.GameRule.cs b/Content.Server/GameTicking/GameTicker.GameRule.cs
index 4ebe946af4a..f52a3cb296d 100644
--- a/Content.Server/GameTicking/GameTicker.GameRule.cs
+++ b/Content.Server/GameTicking/GameTicker.GameRule.cs
@@ -1,6 +1,6 @@
 using System.Linq;
 using Content.Server.Administration;
-using Content.Server.GameTicking.Rules.Components;
+using Content.Server.GameTicking.Components;
 using Content.Shared.Administration;
 using Content.Shared.Database;
 using Content.Shared.Prototypes;
@@ -102,6 +102,22 @@ public bool StartGameRule(EntityUid ruleEntity, GameRuleComponent? ruleData = nu
         if (MetaData(ruleEntity).EntityPrototype?.ID is not { } id) // you really fucked up
             return false;
 
+        // If we already have it, then we just skip the delay as it has already happened.
+        if (!RemComp<DelayedStartRuleComponent>(ruleEntity) && ruleData.Delay != null)
+        {
+            var delayTime = TimeSpan.FromSeconds(ruleData.Delay.Value.Next(_robustRandom));
+
+            if (delayTime > TimeSpan.Zero)
+            {
+                _sawmill.Info($"Queued start for game rule {ToPrettyString(ruleEntity)} with delay {delayTime}");
+                _adminLogger.Add(LogType.EventStarted, $"Queued start for game rule {ToPrettyString(ruleEntity)} with delay {delayTime}");
+
+                var delayed = EnsureComp<DelayedStartRuleComponent>(ruleEntity);
+                delayed.RuleStartTime = _gameTiming.CurTime + (delayTime);
+                return true;
+            }
+        }
+
         _allPreviousGameRules.Add((RoundDuration(), id));
         _sawmill.Info($"Started game rule {ToPrettyString(ruleEntity)}");
         _adminLogger.Add(LogType.EventStarted, $"Started game rule {ToPrettyString(ruleEntity)}");
@@ -255,6 +271,18 @@ public IEnumerable<EntityPrototype> GetAllGameRulePrototypes()
         }
     }
 
+    private void UpdateGameRules()
+    {
+        var query = EntityQueryEnumerator<DelayedStartRuleComponent, GameRuleComponent>();
+        while (query.MoveNext(out var uid, out var delay, out var rule))
+        {
+            if (_gameTiming.CurTime < delay.RuleStartTime)
+                continue;
+
+            StartGameRule(uid, rule);
+        }
+    }
+
     #region Command Implementations
 
     [AdminCommand(AdminFlags.Fun)]
@@ -323,38 +351,3 @@ private void ClearGameRulesCommand(IConsoleShell shell, string argstr, string[]
 
     #endregion
 }
-
-/*
-/// <summary>
-///     Raised broadcast when a game rule is selected, but not started yet.
-/// </summary>
-public sealed class GameRuleAddedEvent
-{
-    public GameRulePrototype Rule { get; }
-
-    public GameRuleAddedEvent(GameRulePrototype rule)
-    {
-        Rule = rule;
-    }
-}
-
-public sealed class GameRuleStartedEvent
-{
-    public GameRulePrototype Rule { get; }
-
-    public GameRuleStartedEvent(GameRulePrototype rule)
-    {
-        Rule = rule;
-    }
-}
-
-public sealed class GameRuleEndedEvent
-{
-    public GameRulePrototype Rule { get; }
-
-    public GameRuleEndedEvent(GameRulePrototype rule)
-    {
-        Rule = rule;
-    }
-}
-*/
diff --git a/Content.Server/GameTicking/GameTicker.RoundFlow.cs b/Content.Server/GameTicking/GameTicker.RoundFlow.cs
index 154244ace19..0fc984abeda 100644
--- a/Content.Server/GameTicking/GameTicker.RoundFlow.cs
+++ b/Content.Server/GameTicking/GameTicker.RoundFlow.cs
@@ -175,6 +175,26 @@ public IReadOnlyList<EntityUid> LoadGameMap(GameMapPrototype map, MapId targetMa
             return gridUids;
         }
 
+        public int ReadyPlayerCount()
+        {
+            var total = 0;
+            foreach (var (userId, status) in _playerGameStatuses)
+            {
+                if (LobbyEnabled && status == PlayerGameStatus.NotReadyToPlay)
+                    continue;
+
+                if (!_playerManager.TryGetSessionById(userId, out _))
+                    continue;
+
+                if (_banManager.GetRoleBans(userId) == null)
+                    continue;
+
+                total++;
+            }
+
+            return total;
+        }
+
         public void StartRound(bool force = false)
         {
 #if EXCEPTION_TOLERANCE
@@ -230,6 +250,8 @@ public void StartRound(bool force = false)
                 readyPlayerProfiles.Add(userId, profile);
             }
 
+            DebugTools.AssertEqual(readyPlayers.Count, ReadyPlayerCount());
+
             // Just in case it hasn't been loaded previously we'll try loading it.
             LoadMaps();
 
@@ -771,7 +793,7 @@ public RulePlayerSpawningEvent(List<ICommonSession> playerPool, IReadOnlyDiction
     }
 
     /// <summary>
-    ///     Event raised after players were assigned jobs by the GameTicker.
+    ///     Event raised after players were assigned jobs by the GameTicker and have been spawned in.
     ///     You can give on-station people special roles by listening to this event.
     /// </summary>
     public sealed class RulePlayerJobsAssignedEvent
diff --git a/Content.Server/GameTicking/GameTicker.cs b/Content.Server/GameTicking/GameTicker.cs
index efda3df0ca1..fa23312268f 100644
--- a/Content.Server/GameTicking/GameTicker.cs
+++ b/Content.Server/GameTicking/GameTicker.cs
@@ -133,6 +133,7 @@ public override void Update(float frameTime)
                 return;
             base.Update(frameTime);
             UpdateRoundFlow(frameTime);
+            UpdateGameRules();
         }
     }
 }
diff --git a/Content.Server/GameTicking/Rules/Components/LoadMapRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/LoadMapRuleComponent.cs
new file mode 100644
index 00000000000..463aecbff54
--- /dev/null
+++ b/Content.Server/GameTicking/Rules/Components/LoadMapRuleComponent.cs
@@ -0,0 +1,29 @@
+using Content.Server.Maps;
+using Content.Shared.Whitelist;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Server.GameTicking.Rules.Components;
+
+/// <summary>
+/// This is used for a game rule that loads a map when activated.
+/// </summary>
+[RegisterComponent]
+public sealed partial class LoadMapRuleComponent : Component
+{
+    [DataField]
+    public MapId? Map;
+
+    [DataField]
+    public ProtoId<GameMapPrototype>? GameMap ;
+
+    [DataField]
+    public ResPath? MapPath;
+
+    [DataField]
+    public List<EntityUid> MapGrids = new();
+
+    [DataField]
+    public EntityWhitelist? SpawnerWhitelist;
+}
diff --git a/Content.Server/GameTicking/Rules/Components/NinjaRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/NinjaRuleComponent.cs
index e6966c1e377..fa352eb320b 100644
--- a/Content.Server/GameTicking/Rules/Components/NinjaRuleComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/NinjaRuleComponent.cs
@@ -8,7 +8,7 @@ namespace Content.Server.GameTicking.Rules.Components;
 
 /// <summary>
 /// Stores some configuration used by the ninja system.
-/// Objectives and roundend summary are handled by <see cref="GenericAntagRuleComponent/">.
+/// Objectives and roundend summary are handled by <see cref="GenericAntagRuleComponent"/>.
 /// </summary>
 [RegisterComponent, Access(typeof(SpaceNinjaSystem))]
 public sealed partial class NinjaRuleComponent : Component
diff --git a/Content.Server/GameTicking/Rules/Components/NukeOperativeSpawnerComponent.cs b/Content.Server/GameTicking/Rules/Components/NukeOperativeSpawnerComponent.cs
index e02d90c18bf..bb1b7c87460 100644
--- a/Content.Server/GameTicking/Rules/Components/NukeOperativeSpawnerComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/NukeOperativeSpawnerComponent.cs
@@ -1,6 +1,3 @@
-using Content.Shared.Roles;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
-
 namespace Content.Server.GameTicking.Rules.Components;
 
 /// <summary>
@@ -9,11 +6,5 @@ namespace Content.Server.GameTicking.Rules.Components;
 /// TODO: Remove once systems can request spawns from the ghost role system directly.
 /// </summary>
 [RegisterComponent]
-public sealed partial class NukeOperativeSpawnerComponent : Component
-{
-    [DataField("name", required:true)]
-    public string OperativeName = default!;
+public sealed partial class NukeOperativeSpawnerComponent : Component;
 
-    [DataField]
-    public NukeopSpawnPreset SpawnDetails = default!;
-}
diff --git a/Content.Server/GameTicking/Rules/Components/NukeOpsShuttleComponent.cs b/Content.Server/GameTicking/Rules/Components/NukeOpsShuttleComponent.cs
index 358b157cdf3..3d097cd7c79 100644
--- a/Content.Server/GameTicking/Rules/Components/NukeOpsShuttleComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/NukeOpsShuttleComponent.cs
@@ -6,4 +6,6 @@
 [RegisterComponent]
 public sealed partial class NukeOpsShuttleComponent : Component
 {
+    [DataField]
+    public EntityUid AssociatedRule;
 }
diff --git a/Content.Server/GameTicking/Rules/Components/NukeopsRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/NukeopsRuleComponent.cs
index 8efd61b4694..f64947e286e 100644
--- a/Content.Server/GameTicking/Rules/Components/NukeopsRuleComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/NukeopsRuleComponent.cs
@@ -1,10 +1,9 @@
 using Content.Server.Maps;
 using Content.Server.NPC.Components;
 using Content.Server.RoundEnd;
-using Content.Server.StationEvents.Events;
 using Content.Shared.Dataset;
 using Content.Shared.Roles;
-using Robust.Shared.Map;
+using Robust.Shared.Audio;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
@@ -14,18 +13,9 @@
 
 namespace Content.Server.GameTicking.Rules.Components;
 
-[RegisterComponent, Access(typeof(NukeopsRuleSystem), typeof(LoneOpsSpawnRule))]
+[RegisterComponent, Access(typeof(NukeopsRuleSystem))]
 public sealed partial class NukeopsRuleComponent : Component
 {
-    /// <summary>
-    /// This INCLUDES the operatives. So a value of 3 is satisfied by 2 players & 1 operative
-    /// </summary>
-    [DataField]
-    public int PlayersPerOperative = 10;
-
-    [DataField]
-    public int MaxOps = 5;
-
     /// <summary>
     /// What will happen if all of the nuclear operatives will die. Used by LoneOpsSpawn event.
     /// </summary>
@@ -56,12 +46,6 @@ public sealed partial class NukeopsRuleComponent : Component
     [DataField]
     public TimeSpan EvacShuttleTime = TimeSpan.FromMinutes(3);
 
-    /// <summary>
-    /// Whether or not to spawn the nuclear operative outpost. Used by LoneOpsSpawn event.
-    /// </summary>
-    [DataField]
-    public bool SpawnOutpost = true;
-
     /// <summary>
     /// Whether or not nukie left their outpost
     /// </summary>
@@ -84,7 +68,7 @@ public sealed partial class NukeopsRuleComponent : Component
     ///     This amount of TC will be given to each nukie
     /// </summary>
     [DataField]
-    public int WarTCAmountPerNukie = 40;
+    public int WarTcAmountPerNukie = 40;
 
     /// <summary>
     ///     Delay between war declaration and nuke ops arrival on station map. Gives crew time to prepare
@@ -98,49 +82,23 @@ public sealed partial class NukeopsRuleComponent : Component
     [DataField]
     public int WarDeclarationMinOps = 4;
 
-    [DataField]
-    public EntProtoId SpawnPointProto = "SpawnPointNukies";
-
-    [DataField]
-    public EntProtoId GhostSpawnPointProto = "SpawnPointGhostNukeOperative";
-
-    [DataField]
-    public string OperationName = "Test Operation";
-
-    [DataField]
-    public ProtoId<GameMapPrototype> OutpostMapPrototype = "NukieOutpost";
-
     [DataField]
     public WinType WinType = WinType.Neutral;
 
     [DataField]
     public List<WinCondition> WinConditions = new ();
 
-    public MapId? NukiePlanet;
-
-    // TODO: use components, don't just cache entity UIDs
-    // There have been (and probably still are) bugs where these refer to deleted entities from old rounds.
-    public EntityUid? NukieOutpost;
-    public EntityUid? NukieShuttle;
-    public EntityUid? TargetStation;
-
-    /// <summary>
-    ///     Data to be used in <see cref="OnMindAdded"/> for an operative once the Mind has been added.
-    /// </summary>
-    [DataField]
-    public Dictionary<EntityUid, string> OperativeMindPendingData = new();
-
-    [DataField(required: true)]
-    public ProtoId<NpcFactionPrototype> Faction = default!;
-
     [DataField]
-    public NukeopSpawnPreset CommanderSpawnDetails = new() { AntagRoleProto = "NukeopsCommander", GearProto = "SyndicateCommanderGearFull", NamePrefix = "nukeops-role-commander", NameList = "SyndicateNamesElite" };
+    public EntityUid? TargetStation;
 
     [DataField]
-    public NukeopSpawnPreset AgentSpawnDetails = new() { AntagRoleProto = "NukeopsMedic", GearProto = "SyndicateOperativeMedicFull", NamePrefix = "nukeops-role-agent", NameList = "SyndicateNamesNormal" };
+    public ProtoId<NpcFactionPrototype> Faction = "Syndicate";
 
+    /// <summary>
+    ///     Path to antagonist alert sound.
+    /// </summary>
     [DataField]
-    public NukeopSpawnPreset OperativeSpawnDetails = new();
+    public SoundSpecifier GreetSoundNotification = new SoundPathSpecifier("/Audio/Ambience/Antag/nukeops_start.ogg");
 }
 
 /// <summary>
diff --git a/Content.Server/GameTicking/Rules/Components/PiratesRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/PiratesRuleComponent.cs
deleted file mode 100644
index 1d03b41d773..00000000000
--- a/Content.Server/GameTicking/Rules/Components/PiratesRuleComponent.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using Robust.Shared.Audio;
-
-namespace Content.Server.GameTicking.Rules.Components;
-
-[RegisterComponent, Access(typeof(PiratesRuleSystem))]
-public sealed partial class PiratesRuleComponent : Component
-{
-    [ViewVariables]
-    public List<EntityUid> Pirates = new();
-    [ViewVariables]
-    public EntityUid PirateShip = EntityUid.Invalid;
-    [ViewVariables]
-    public HashSet<EntityUid> InitialItems = new();
-    [ViewVariables]
-    public double InitialShipValue;
-
-    /// <summary>
-    ///     Path to antagonist alert sound.
-    /// </summary>
-    [DataField("pirateAlertSound")]
-    public SoundSpecifier PirateAlertSound = new SoundPathSpecifier(
-        "/Audio/Ambience/Antag/pirate_start.ogg",
-        AudioParams.Default.WithVolume(4));
-}
diff --git a/Content.Server/GameTicking/Rules/Components/RevolutionaryRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/RevolutionaryRuleComponent.cs
index 2ce3f1f9a66..3b19bbffb6a 100644
--- a/Content.Server/GameTicking/Rules/Components/RevolutionaryRuleComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/RevolutionaryRuleComponent.cs
@@ -22,43 +22,6 @@ public sealed partial class RevolutionaryRuleComponent : Component
     [DataField]
     public TimeSpan TimerWait = TimeSpan.FromSeconds(20);
 
-    /// <summary>
-    /// Stores players minds
-    /// </summary>
-    [DataField]
-    public Dictionary<string, EntityUid> HeadRevs = new();
-
-    [DataField]
-    public ProtoId<AntagPrototype> HeadRevPrototypeId = "HeadRev";
-
-    /// <summary>
-    /// Min players needed for Revolutionary gamemode to start.
-    /// </summary>
-    [DataField, ViewVariables(VVAccess.ReadWrite)]
-    public int MinPlayers = 15;
-
-    /// <summary>
-    /// Max Head Revs allowed during selection.
-    /// </summary>
-    [DataField, ViewVariables(VVAccess.ReadWrite)]
-    public int MaxHeadRevs = 3;
-
-    /// <summary>
-    /// The amount of Head Revs that will spawn per this amount of players.
-    /// </summary>
-    [DataField, ViewVariables(VVAccess.ReadWrite)]
-    public int PlayersPerHeadRev = 15;
-
-    /// <summary>
-    /// The gear head revolutionaries are given on spawn.
-    /// </summary>
-    [DataField]
-    public List<EntProtoId> StartingGear = new()
-    {
-        "Flash",
-        "ClothingEyesGlassesSunglasses"
-    };
-
     /// <summary>
     /// The time it takes after the last head is killed for the shuttle to arrive.
     /// </summary>
diff --git a/Content.Server/GameTicking/Rules/Components/ThiefRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/ThiefRuleComponent.cs
index 9dfd6e6627c..01a078625ae 100644
--- a/Content.Server/GameTicking/Rules/Components/ThiefRuleComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/ThiefRuleComponent.cs
@@ -1,12 +1,11 @@
 using Content.Shared.Random;
-using Content.Shared.Roles;
 using Robust.Shared.Audio;
 using Robust.Shared.Prototypes;
 
 namespace Content.Server.GameTicking.Rules.Components;
 
 /// <summary>
-/// Stores data for <see cref="ThiefRuleSystem/">.
+/// Stores data for <see cref="ThiefRuleSystem"/>.
 /// </summary>
 [RegisterComponent, Access(typeof(ThiefRuleSystem))]
 public sealed partial class ThiefRuleComponent : Component
@@ -23,42 +22,9 @@ public sealed partial class ThiefRuleComponent : Component
     [DataField]
     public float BigObjectiveChance = 0.7f;
 
-    /// <summary>
-    /// Add a Pacified comp to thieves
-    /// </summary>
-    [DataField]
-    public bool PacifistThieves = true;
-
-    [DataField]
-    public ProtoId<AntagPrototype> ThiefPrototypeId = "Thief";
-
     [DataField]
     public float MaxObjectiveDifficulty = 2.5f;
 
     [DataField]
     public int MaxStealObjectives = 10;
-
-    /// <summary>
-    /// Things that will be given to thieves
-    /// </summary>
-    [DataField]
-    public List<EntProtoId> StarterItems = new() { "ToolboxThief", "ClothingHandsChameleonThief" };
-
-    /// <summary>
-    /// All Thieves created by this rule
-    /// </summary>
-    [DataField]
-    public List<EntityUid> ThievesMinds = new();
-
-    /// <summary>
-    /// Max Thiefs created by rule on roundstart
-    /// </summary>
-    [DataField]
-    public int MaxAllowThief = 3;
-
-    /// <summary>
-    /// Sound played when making the player a thief via antag control or ghost role
-    /// </summary>
-    [DataField]
-    public SoundSpecifier? GreetingSound = new SoundPathSpecifier("/Audio/Misc/thief_greeting.ogg");
 }
diff --git a/Content.Server/GameTicking/Rules/Components/TraitorRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/TraitorRuleComponent.cs
index 62619db76a2..dd359969b6f 100644
--- a/Content.Server/GameTicking/Rules/Components/TraitorRuleComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/TraitorRuleComponent.cs
@@ -57,4 +57,19 @@ public enum SelectionState
     /// </summary>
     [DataField]
     public SoundSpecifier GreetSoundNotification = new SoundPathSpecifier("/Audio/Ambience/Antag/traitor_start.ogg");
+
+    /// <summary>
+    /// The amount of codewords that are selected.
+    /// </summary>
+    [DataField]
+    public int CodewordCount = 4;
+
+    /// <summary>
+    /// The amount of TC traitors start with.
+    /// </summary>
+    [DataField]
+    public int StartingBalance = 20;
+
+    [DataField]
+    public int MaxDifficulty = 5;
 }
diff --git a/Content.Server/GameTicking/Rules/Components/ZombieRuleComponent.cs b/Content.Server/GameTicking/Rules/Components/ZombieRuleComponent.cs
index 4fe91e3a5f5..59d1940eafe 100644
--- a/Content.Server/GameTicking/Rules/Components/ZombieRuleComponent.cs
+++ b/Content.Server/GameTicking/Rules/Components/ZombieRuleComponent.cs
@@ -8,12 +8,6 @@ namespace Content.Server.GameTicking.Rules.Components;
 [RegisterComponent, Access(typeof(ZombieRuleSystem))]
 public sealed partial class ZombieRuleComponent : Component
 {
-    [DataField]
-    public Dictionary<string, string> InitialInfectedNames = new();
-
-    [DataField]
-    public ProtoId<AntagPrototype> PatientZeroPrototypeId = "InitialInfected";
-
     /// <summary>
     /// When the round will next check for round end.
     /// </summary>
@@ -26,61 +20,9 @@ public sealed partial class ZombieRuleComponent : Component
     [DataField]
     public TimeSpan EndCheckDelay = TimeSpan.FromSeconds(30);
 
-    /// <summary>
-    /// The time at which the initial infected will be chosen.
-    /// </summary>
-    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
-    public TimeSpan? StartTime;
-
-    /// <summary>
-    /// The minimum amount of time after the round starts that the initial infected will be chosen.
-    /// </summary>
-    [DataField]
-    public TimeSpan MinStartDelay = TimeSpan.FromMinutes(10);
-
-    /// <summary>
-    /// The maximum amount of time after the round starts that the initial infected will be chosen.
-    /// </summary>
-    [DataField]
-    public TimeSpan MaxStartDelay = TimeSpan.FromMinutes(15);
-
-    /// <summary>
-    /// The sound that plays when someone becomes an initial infected.
-    /// todo: this should have a unique sound instead of reusing the zombie one.
-    /// </summary>
-    [DataField]
-    public SoundSpecifier InitialInfectedSound = new SoundPathSpecifier("/Audio/Ambience/Antag/zombie_start.ogg");
-
-    /// <summary>
-    /// The minimum amount of time initial infected have before they start taking infection damage.
-    /// </summary>
-    [DataField]
-    public TimeSpan MinInitialInfectedGrace = TimeSpan.FromMinutes(12.5f);
-
-    /// <summary>
-    /// The maximum amount of time initial infected have before they start taking damage.
-    /// </summary>
-    [DataField]
-    public TimeSpan MaxInitialInfectedGrace = TimeSpan.FromMinutes(15f);
-
-    /// <summary>
-    /// How many players for each initial infected.
-    /// </summary>
-    [DataField]
-    public int PlayersPerInfected = 10;
-
-    /// <summary>
-    /// The maximum number of initial infected.
-    /// </summary>
-    [DataField]
-    public int MaxInitialInfected = 6;
-
     /// <summary>
     /// After this amount of the crew become zombies, the shuttle will be automatically called.
     /// </summary>
     [DataField]
     public float ZombieShuttleCallPercentage = 0.7f;
-
-    [DataField]
-    public EntProtoId ZombifySelfActionPrototype = "ActionTurnUndead";
 }
diff --git a/Content.Server/GameTicking/Rules/DeathMatchRuleSystem.cs b/Content.Server/GameTicking/Rules/DeathMatchRuleSystem.cs
index 82ac755592e..78b8a8a85c8 100644
--- a/Content.Server/GameTicking/Rules/DeathMatchRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/DeathMatchRuleSystem.cs
@@ -1,5 +1,6 @@
 using System.Linq;
 using Content.Server.Administration.Commands;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.KillTracking;
 using Content.Server.Mind;
@@ -33,7 +34,6 @@ public override void Initialize()
         SubscribeLocalEvent<PlayerSpawnCompleteEvent>(OnSpawnComplete);
         SubscribeLocalEvent<KillReportedEvent>(OnKillReported);
         SubscribeLocalEvent<DeathMatchRuleComponent, PlayerPointChangedEvent>(OnPointChanged);
-        SubscribeLocalEvent<RoundEndTextAppendEvent>(OnRoundEndTextAppend);
     }
 
     private void OnBeforeSpawn(PlayerBeforeSpawnEvent ev)
@@ -113,21 +113,17 @@ private void OnPointChanged(EntityUid uid, DeathMatchRuleComponent component, re
         _roundEnd.EndRound(component.RestartDelay);
     }
 
-    private void OnRoundEndTextAppend(RoundEndTextAppendEvent ev)
+    protected override void AppendRoundEndText(EntityUid uid, DeathMatchRuleComponent component, GameRuleComponent gameRule, ref RoundEndTextAppendEvent args)
     {
-        var query = EntityQueryEnumerator<DeathMatchRuleComponent, PointManagerComponent, GameRuleComponent>();
-        while (query.MoveNext(out var uid, out var dm, out var point, out var rule))
-        {
-            if (!GameTicker.IsGameRuleAdded(uid, rule))
-                continue;
+        if (!TryComp<PointManagerComponent>(uid, out var point))
+            return;
 
-            if (dm.Victor != null && _player.TryGetPlayerData(dm.Victor.Value, out var data))
-            {
-                ev.AddLine(Loc.GetString("point-scoreboard-winner", ("player", data.UserName)));
-                ev.AddLine("");
-            }
-            ev.AddLine(Loc.GetString("point-scoreboard-header"));
-            ev.AddLine(new FormattedMessage(point.Scoreboard).ToMarkup());
+        if (component.Victor != null && _player.TryGetPlayerData(component.Victor.Value, out var data))
+        {
+            args.AddLine(Loc.GetString("point-scoreboard-winner", ("player", data.UserName)));
+            args.AddLine("");
         }
+        args.AddLine(Loc.GetString("point-scoreboard-header"));
+        args.AddLine(new FormattedMessage(point.Scoreboard).ToMarkup());
     }
 }
diff --git a/Content.Server/GameTicking/Rules/GameRuleSystem.Utility.cs b/Content.Server/GameTicking/Rules/GameRuleSystem.Utility.cs
index a60a2bfe22f..27a9edbad71 100644
--- a/Content.Server/GameTicking/Rules/GameRuleSystem.Utility.cs
+++ b/Content.Server/GameTicking/Rules/GameRuleSystem.Utility.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Station.Components;
 using Robust.Shared.Collections;
@@ -15,29 +16,12 @@ protected EntityQueryEnumerator<ActiveGameRuleComponent, T, GameRuleComponent> Q
         return EntityQueryEnumerator<ActiveGameRuleComponent, T, GameRuleComponent>();
     }
 
-    protected bool TryRoundStartAttempt(RoundStartAttemptEvent ev, string localizedPresetName)
+    /// <summary>
+    /// Queries all gamerules, regardless of if they're active or not.
+    /// </summary>
+    protected EntityQueryEnumerator<T, GameRuleComponent> QueryAllRules()
     {
-        var query = EntityQueryEnumerator<ActiveGameRuleComponent, T, GameRuleComponent>();
-        while (query.MoveNext(out _, out _, out _, out var gameRule))
-        {
-            var minPlayers = gameRule.MinPlayers;
-            if (!ev.Forced && ev.Players.Length < minPlayers)
-            {
-                ChatManager.SendAdminAnnouncement(Loc.GetString("preset-not-enough-ready-players",
-                    ("readyPlayersCount", ev.Players.Length), ("minimumPlayers", minPlayers),
-                    ("presetName", localizedPresetName)));
-                ev.Cancel();
-                continue;
-            }
-
-            if (ev.Players.Length == 0)
-            {
-                ChatManager.DispatchServerAnnouncement(Loc.GetString("preset-no-one-ready"));
-                ev.Cancel();
-            }
-        }
-
-        return !ev.Cancelled;
+        return EntityQueryEnumerator<T, GameRuleComponent>();
     }
 
     /// <summary>
diff --git a/Content.Server/GameTicking/Rules/GameRuleSystem.cs b/Content.Server/GameTicking/Rules/GameRuleSystem.cs
index 363c2ad7f75..c167ae7b6c7 100644
--- a/Content.Server/GameTicking/Rules/GameRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/GameRuleSystem.cs
@@ -1,6 +1,6 @@
 using Content.Server.Atmos.EntitySystems;
 using Content.Server.Chat.Managers;
-using Content.Server.GameTicking.Rules.Components;
+using Content.Server.GameTicking.Components;
 using Robust.Server.GameObjects;
 using Robust.Shared.Random;
 using Robust.Shared.Timing;
@@ -22,9 +22,31 @@ public override void Initialize()
     {
         base.Initialize();
 
+        SubscribeLocalEvent<RoundStartAttemptEvent>(OnStartAttempt);
         SubscribeLocalEvent<T, GameRuleAddedEvent>(OnGameRuleAdded);
         SubscribeLocalEvent<T, GameRuleStartedEvent>(OnGameRuleStarted);
         SubscribeLocalEvent<T, GameRuleEndedEvent>(OnGameRuleEnded);
+        SubscribeLocalEvent<T, RoundEndTextAppendEvent>(OnRoundEndTextAppend);
+    }
+
+    private void OnStartAttempt(RoundStartAttemptEvent args)
+    {
+        if (args.Forced || args.Cancelled)
+            return;
+
+        var query = QueryAllRules();
+        while (query.MoveNext(out var uid, out _, out var gameRule))
+        {
+            var minPlayers = gameRule.MinPlayers;
+            if (args.Players.Length >= minPlayers)
+                continue;
+
+            ChatManager.SendAdminAnnouncement(Loc.GetString("preset-not-enough-ready-players",
+                ("readyPlayersCount", args.Players.Length),
+                ("minimumPlayers", minPlayers),
+                ("presetName", ToPrettyString(uid))));
+            args.Cancel();
+        }
     }
 
     private void OnGameRuleAdded(EntityUid uid, T component, ref GameRuleAddedEvent args)
@@ -48,6 +70,12 @@ private void OnGameRuleEnded(EntityUid uid, T component, ref GameRuleEndedEvent
         Ended(uid, component, ruleData, args);
     }
 
+    private void OnRoundEndTextAppend(Entity<T> ent, ref RoundEndTextAppendEvent args)
+    {
+        if (!TryComp<GameRuleComponent>(ent, out var ruleData))
+            return;
+        AppendRoundEndText(ent, ent, ruleData, ref args);
+    }
 
     /// <summary>
     /// Called when the gamerule is added
@@ -73,6 +101,14 @@ protected virtual void Ended(EntityUid uid, T component, GameRuleComponent gameR
 
     }
 
+    /// <summary>
+    /// Called at the end of a round when text needs to be added for a game rule.
+    /// </summary>
+    protected virtual void AppendRoundEndText(EntityUid uid, T component, GameRuleComponent gameRule, ref RoundEndTextAppendEvent args)
+    {
+
+    }
+
     /// <summary>
     /// Called on an active gamerule entity in the Update function
     /// </summary>
diff --git a/Content.Server/GameTicking/Rules/InactivityTimeRestartRuleSystem.cs b/Content.Server/GameTicking/Rules/InactivityTimeRestartRuleSystem.cs
index b775b7af564..01fa387595c 100644
--- a/Content.Server/GameTicking/Rules/InactivityTimeRestartRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/InactivityTimeRestartRuleSystem.cs
@@ -1,5 +1,6 @@
 using System.Threading;
 using Content.Server.Chat.Managers;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Robust.Server.Player;
 using Robust.Shared.Player;
diff --git a/Content.Server/GameTicking/Rules/KillCalloutRuleSystem.cs b/Content.Server/GameTicking/Rules/KillCalloutRuleSystem.cs
index 01fd97d9a79..3da55e30c9e 100644
--- a/Content.Server/GameTicking/Rules/KillCalloutRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/KillCalloutRuleSystem.cs
@@ -1,4 +1,5 @@
 using Content.Server.Chat.Managers;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.KillTracking;
 using Content.Shared.Chat;
diff --git a/Content.Server/GameTicking/Rules/LoadMapRuleSystem.cs b/Content.Server/GameTicking/Rules/LoadMapRuleSystem.cs
new file mode 100644
index 00000000000..aba9ed9e583
--- /dev/null
+++ b/Content.Server/GameTicking/Rules/LoadMapRuleSystem.cs
@@ -0,0 +1,80 @@
+using Content.Server.Antag;
+using Content.Server.GameTicking.Components;
+using Content.Server.GameTicking.Rules.Components;
+using Content.Server.Spawners.Components;
+using Robust.Server.GameObjects;
+using Robust.Server.Maps;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.GameTicking.Rules;
+
+public sealed class LoadMapRuleSystem : GameRuleSystem<LoadMapRuleComponent>
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly MapSystem _map = default!;
+    [Dependency] private readonly MapLoaderSystem _mapLoader = default!;
+    [Dependency] private readonly TransformSystem _transform = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<LoadMapRuleComponent, AntagSelectLocationEvent>(OnSelectLocation);
+        SubscribeLocalEvent<GridSplitEvent>(OnGridSplit);
+    }
+
+    private void OnGridSplit(ref GridSplitEvent args)
+    {
+        var rule = QueryActiveRules();
+        while (rule.MoveNext(out _, out var mapComp, out _))
+        {
+            if (!mapComp.MapGrids.Contains(args.Grid))
+                continue;
+
+            mapComp.MapGrids.AddRange(args.NewGrids);
+            break;
+        }
+    }
+
+    protected override void Added(EntityUid uid, LoadMapRuleComponent comp, GameRuleComponent rule, GameRuleAddedEvent args)
+    {
+        if (comp.Map != null)
+            return;
+
+        _map.CreateMap(out var mapId);
+        comp.Map = mapId;
+
+        if (comp.GameMap != null)
+        {
+            var gameMap = _prototypeManager.Index(comp.GameMap.Value);
+            comp.MapGrids.AddRange(GameTicker.LoadGameMap(gameMap, comp.Map.Value, new MapLoadOptions()));
+        }
+        else if (comp.MapPath != null)
+        {
+            if (_mapLoader.TryLoad(comp.Map.Value, comp.MapPath.Value.ToString(), out var roots, new MapLoadOptions { LoadMap = true }))
+                comp.MapGrids.AddRange(roots);
+        }
+        else
+        {
+            Log.Error($"No valid map prototype or map path associated with the rule {ToPrettyString(uid)}");
+        }
+    }
+
+    private void OnSelectLocation(Entity<LoadMapRuleComponent> ent, ref AntagSelectLocationEvent args)
+    {
+        var query = EntityQueryEnumerator<SpawnPointComponent, TransformComponent>();
+        while (query.MoveNext(out var uid, out _, out var xform))
+        {
+            if (xform.MapID != ent.Comp.Map)
+                continue;
+
+            if (xform.GridUid == null || !ent.Comp.MapGrids.Contains(xform.GridUid.Value))
+                continue;
+
+            if (ent.Comp.SpawnerWhitelist != null && !ent.Comp.SpawnerWhitelist.IsValid(uid, EntityManager))
+                continue;
+
+            args.Coordinates.Add(_transform.GetMapCoordinates(xform));
+        }
+    }
+}
diff --git a/Content.Server/GameTicking/Rules/MaxTimeRestartRuleSystem.cs b/Content.Server/GameTicking/Rules/MaxTimeRestartRuleSystem.cs
index e792a004df5..ee3a025533a 100644
--- a/Content.Server/GameTicking/Rules/MaxTimeRestartRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/MaxTimeRestartRuleSystem.cs
@@ -1,5 +1,6 @@
 using System.Threading;
 using Content.Server.Chat.Managers;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Timer = Robust.Shared.Timing.Timer;
 
diff --git a/Content.Server/GameTicking/Rules/NukeopsRuleSystem.cs b/Content.Server/GameTicking/Rules/NukeopsRuleSystem.cs
index 46040e29450..d06b9fb899c 100644
--- a/Content.Server/GameTicking/Rules/NukeopsRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/NukeopsRuleSystem.cs
@@ -1,77 +1,51 @@
-using Content.Server.Administration.Commands;
-using Content.Server.Administration.Managers;
 using Content.Server.Antag;
 using Content.Server.Communications;
 using Content.Server.GameTicking.Rules.Components;
-using Content.Server.Ghost.Roles.Components;
-using Content.Server.Ghost.Roles.Events;
 using Content.Server.Humanoid;
-using Content.Server.Mind;
-using Content.Server.NPC.Components;
-using Content.Server.NPC.Systems;
 using Content.Server.Nuke;
 using Content.Server.NukeOps;
 using Content.Server.Popups;
 using Content.Server.Preferences.Managers;
-using Content.Server.RandomMetadata;
 using Content.Server.Roles;
 using Content.Server.RoundEnd;
 using Content.Server.Shuttles.Events;
 using Content.Server.Shuttles.Systems;
-using Content.Server.Spawners.Components;
 using Content.Server.Station.Components;
-using Content.Server.Station.Systems;
 using Content.Server.Store.Components;
 using Content.Server.Store.Systems;
-using Content.Shared.CCVar;
-using Content.Shared.Dataset;
 using Content.Shared.Humanoid;
 using Content.Shared.Humanoid.Prototypes;
-using Content.Shared.Mind.Components;
 using Content.Shared.Mobs;
 using Content.Shared.Mobs.Components;
 using Content.Shared.Nuke;
 using Content.Shared.NukeOps;
 using Content.Shared.Preferences;
-using Content.Shared.Roles;
 using Content.Shared.Store;
 using Content.Shared.Tag;
 using Content.Shared.Zombies;
-using Robust.Server.Player;
-using Robust.Shared.Configuration;
 using Robust.Shared.Map;
-using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using Robust.Shared.Utility;
 using System.Linq;
+using Content.Server.GameTicking.Components;
+using Content.Server.NPC.Components;
+using Content.Server.NPC.Systems;
 
 namespace Content.Server.GameTicking.Rules;
 
 public sealed class NukeopsRuleSystem : GameRuleSystem<NukeopsRuleComponent>
 {
-    [Dependency] private readonly IMapManager _mapManager = default!;
-    [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly IServerPreferencesManager _prefs = default!;
-    [Dependency] private readonly IAdminManager _adminManager = default!;
-    [Dependency] private readonly IConfigurationManager _cfg = default!;
-    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly EmergencyShuttleSystem _emergency = default!;
     [Dependency] private readonly HumanoidAppearanceSystem _humanoid = default!;
-    [Dependency] private readonly MetaDataSystem _metaData = default!;
-    [Dependency] private readonly RandomMetadataSystem _randomMetadata = default!;
-    [Dependency] private readonly MindSystem _mind = default!;
     [Dependency] private readonly NpcFactionSystem _npcFaction = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
     [Dependency] private readonly PopupSystem _popupSystem = default!;
     [Dependency] private readonly RoundEndSystem _roundEndSystem = default!;
-    [Dependency] private readonly SharedRoleSystem _roles = default!;
-    [Dependency] private readonly StationSpawningSystem _stationSpawning = default!;
     [Dependency] private readonly StoreSystem _store = default!;
     [Dependency] private readonly TagSystem _tag = default!;
-    [Dependency] private readonly AntagSelectionSystem _antagSelection = default!;
-
-    private ISawmill _sawmill = default!;
 
     [ValidatePrototypeId<CurrencyPrototype>]
     private const string TelecrystalCurrencyPrototype = "Telecrystal";
@@ -79,141 +53,67 @@ public sealed class NukeopsRuleSystem : GameRuleSystem<NukeopsRuleComponent>
     [ValidatePrototypeId<TagPrototype>]
     private const string NukeOpsUplinkTagPrototype = "NukeOpsUplink";
 
-    [ValidatePrototypeId<AntagPrototype>]
-    public const string NukeopsId = "Nukeops";
-
-    [ValidatePrototypeId<DatasetPrototype>]
-    private const string OperationPrefixDataset = "operationPrefix";
-
-    [ValidatePrototypeId<DatasetPrototype>]
-    private const string OperationSuffixDataset = "operationSuffix";
-
     public override void Initialize()
     {
         base.Initialize();
 
-        _sawmill = _logManager.GetSawmill("NukeOps");
-
-        SubscribeLocalEvent<RoundStartAttemptEvent>(OnStartAttempt);
-        SubscribeLocalEvent<RulePlayerSpawningEvent>(OnPlayersSpawning);
-        SubscribeLocalEvent<RoundEndTextAppendEvent>(OnRoundEndText);
         SubscribeLocalEvent<NukeExplodedEvent>(OnNukeExploded);
         SubscribeLocalEvent<GameRunLevelChangedEvent>(OnRunLevelChanged);
         SubscribeLocalEvent<NukeDisarmSuccessEvent>(OnNukeDisarm);
 
         SubscribeLocalEvent<NukeOperativeComponent, ComponentRemove>(OnComponentRemove);
         SubscribeLocalEvent<NukeOperativeComponent, MobStateChangedEvent>(OnMobStateChanged);
-        SubscribeLocalEvent<NukeOperativeComponent, GhostRoleSpawnerUsedEvent>(OnPlayersGhostSpawning);
-        SubscribeLocalEvent<NukeOperativeComponent, MindAddedMessage>(OnMindAdded);
         SubscribeLocalEvent<NukeOperativeComponent, EntityZombifiedEvent>(OnOperativeZombified);
 
+        SubscribeLocalEvent<NukeOpsShuttleComponent, MapInitEvent>(OnMapInit);
+
         SubscribeLocalEvent<ConsoleFTLAttemptEvent>(OnShuttleFTLAttempt);
         SubscribeLocalEvent<WarDeclaredEvent>(OnWarDeclared);
         SubscribeLocalEvent<CommunicationConsoleCallShuttleAttemptEvent>(OnShuttleCallAttempt);
+
+        SubscribeLocalEvent<NukeopsRuleComponent, AntagSelectEntityEvent>(OnAntagSelectEntity);
+        SubscribeLocalEvent<NukeopsRuleComponent, AfterAntagEntitySelectedEvent>(OnAfterAntagEntSelected);
     }
 
     protected override void Started(EntityUid uid, NukeopsRuleComponent component, GameRuleComponent gameRule,
         GameRuleStartedEvent args)
     {
-        base.Started(uid, component, gameRule, args);
-
-        if (GameTicker.RunLevel == GameRunLevel.InRound)
-            SpawnOperativesForGhostRoles(uid, component);
-    }
-
-    #region Event Handlers
-
-    private void OnStartAttempt(RoundStartAttemptEvent ev)
-    {
-        TryRoundStartAttempt(ev, Loc.GetString("nukeops-title"));
-    }
-
-    private void OnPlayersSpawning(RulePlayerSpawningEvent ev)
-    {
-        var query = QueryActiveRules();
-        while (query.MoveNext(out var uid, out _, out var nukeops, out _))
+        var eligible = new List<Entity<StationEventEligibleComponent, NpcFactionMemberComponent>>();
+        var eligibleQuery = EntityQueryEnumerator<StationEventEligibleComponent, NpcFactionMemberComponent>();
+        while (eligibleQuery.MoveNext(out var eligibleUid, out var eligibleComp, out var member))
         {
-            if (!SpawnMap((uid, nukeops)))
-            {
-                _sawmill.Info("Failed to load map for nukeops");
-                continue;
-            }
-
-            //Handle there being nobody readied up
-            if (ev.PlayerPool.Count == 0)
+            if (!_npcFaction.IsFactionHostile(component.Faction, eligibleUid, member))
                 continue;
 
-            var commanderEligible = _antagSelection.GetEligibleSessions(ev.PlayerPool, nukeops.CommanderSpawnDetails.AntagRoleProto);
-            var agentEligible = _antagSelection.GetEligibleSessions(ev.PlayerPool, nukeops.AgentSpawnDetails.AntagRoleProto);
-            var operativeEligible = _antagSelection.GetEligibleSessions(ev.PlayerPool, nukeops.OperativeSpawnDetails.AntagRoleProto);
-            //Calculate how large the nukeops team needs to be
-            var nukiesToSelect = _antagSelection.CalculateAntagCount(_playerManager.PlayerCount, nukeops.PlayersPerOperative, nukeops.MaxOps);
-
-            //Select Nukies
-            //Select Commander, priority : commanderEligible, agentEligible, operativeEligible, all players
-            var selectedCommander = _antagSelection.ChooseAntags(1, commanderEligible, agentEligible, operativeEligible, ev.PlayerPool).FirstOrDefault();
-            //Select Agent, priority : agentEligible, operativeEligible, all players
-            var selectedAgent = _antagSelection.ChooseAntags(1, agentEligible, operativeEligible, ev.PlayerPool).FirstOrDefault();
-            //Select Operatives, priority : operativeEligible, all players
-            var selectedOperatives = _antagSelection.ChooseAntags(nukiesToSelect - 2, operativeEligible, ev.PlayerPool);
-
-            //Create the team!
-            //If the session is null, they will be spawned as ghost roles (provided the cvar is set)
-            var operatives = new List<NukieSpawn> { new NukieSpawn(selectedCommander, nukeops.CommanderSpawnDetails) };
-            if (nukiesToSelect > 1)
-                operatives.Add(new NukieSpawn(selectedAgent, nukeops.AgentSpawnDetails));
-
-            for (var i = 0; i < nukiesToSelect - 2; i++)
-            {
-                //Use up all available sessions first, then spawn the rest as ghost roles (if enabled)
-                if (selectedOperatives.Count > i)
-                {
-                    operatives.Add(new NukieSpawn(selectedOperatives[i], nukeops.OperativeSpawnDetails));
-                }
-                else
-                {
-                    operatives.Add(new NukieSpawn(null, nukeops.OperativeSpawnDetails));
-                }
-            }
-
-            SpawnOperatives(operatives, _cfg.GetCVar(CCVars.NukeopsSpawnGhostRoles), nukeops);
+            eligible.Add((eligibleUid, eligibleComp, member));
+        }
 
-            foreach (var nukieSpawn in operatives)
-            {
-                if (nukieSpawn.Session == null)
-                    continue;
+        if (eligible.Count == 0)
+            return;
 
-                GameTicker.PlayerJoinGame(nukieSpawn.Session);
-            }
-        }
+        component.TargetStation = RobustRandom.Pick(eligible);
     }
 
-    private void OnRoundEndText(RoundEndTextAppendEvent ev)
+    #region Event Handlers
+    protected override void AppendRoundEndText(EntityUid uid, NukeopsRuleComponent component, GameRuleComponent gameRule,
+        ref RoundEndTextAppendEvent args)
     {
-        var ruleQuery = QueryActiveRules();
-        while (ruleQuery.MoveNext(out _, out _, out var nukeops, out _))
-        {
-            var winText = Loc.GetString($"nukeops-{nukeops.WinType.ToString().ToLower()}");
-            ev.AddLine(winText);
+        var winText = Loc.GetString($"nukeops-{component.WinType.ToString().ToLower()}");
+        args.AddLine(winText);
 
-            foreach (var cond in nukeops.WinConditions)
-            {
-                var text = Loc.GetString($"nukeops-cond-{cond.ToString().ToLower()}");
-                ev.AddLine(text);
-            }
+        foreach (var cond in component.WinConditions)
+        {
+            var text = Loc.GetString($"nukeops-cond-{cond.ToString().ToLower()}");
+            args.AddLine(text);
         }
 
-        ev.AddLine(Loc.GetString("nukeops-list-start"));
+        args.AddLine(Loc.GetString("nukeops-list-start"));
 
-        var nukiesQuery = EntityQueryEnumerator<NukeopsRoleComponent, MindContainerComponent>();
-        while (nukiesQuery.MoveNext(out var nukeopsUid, out _, out var mindContainer))
-        {
-            if (!_mind.TryGetMind(nukeopsUid, out _, out var mind, mindContainer))
-                continue;
+        var antags =_antag.GetAntagIdentifiers(uid);
 
-            ev.AddLine(mind.Session != null
-                ? Loc.GetString("nukeops-list-name-user", ("name", Name(nukeopsUid)), ("user", mind.Session.Name))
-                : Loc.GetString("nukeops-list-name", ("name", Name(nukeopsUid))));
+        foreach (var (_, sessionData, name) in antags)
+        {
+            args.AddLine(Loc.GetString("nukeops-list-name-user", ("name", name), ("user", sessionData.UserName)));
         }
     }
 
@@ -224,10 +124,10 @@ private void OnNukeExploded(NukeExplodedEvent ev)
         {
             if (ev.OwningStation != null)
             {
-                if (ev.OwningStation == nukeops.NukieOutpost)
+                if (ev.OwningStation == GetOutpost(uid))
                 {
                     nukeops.WinConditions.Add(WinCondition.NukeExplodedOnNukieOutpost);
-                    SetWinType(uid, WinType.CrewMajor, nukeops);
+                    SetWinType((uid, nukeops), WinType.CrewMajor);
                     continue;
                 }
 
@@ -242,7 +142,7 @@ private void OnNukeExploded(NukeExplodedEvent ev)
                         }
 
                         nukeops.WinConditions.Add(WinCondition.NukeExplodedOnCorrectStation);
-                        SetWinType(uid, WinType.OpsMajor, nukeops);
+                        SetWinType((uid, nukeops), WinType.OpsMajor);
                         correctStation = true;
                     }
 
@@ -263,19 +163,85 @@ private void OnNukeExploded(NukeExplodedEvent ev)
 
     private void OnRunLevelChanged(GameRunLevelChangedEvent ev)
     {
+        if (ev.New is not GameRunLevel.PostRound)
+            return;
+
         var query = QueryActiveRules();
         while (query.MoveNext(out var uid, out _, out var nukeops, out _))
         {
-            switch (ev.New)
+            OnRoundEnd((uid, nukeops));
+        }
+    }
+
+    private void OnRoundEnd(Entity<NukeopsRuleComponent> ent)
+    {
+        // If the win condition was set to operative/crew major win, ignore.
+        if (ent.Comp.WinType == WinType.OpsMajor || ent.Comp.WinType == WinType.CrewMajor)
+            return;
+
+        var nukeQuery = AllEntityQuery<NukeComponent, TransformComponent>();
+        var centcomms = _emergency.GetCentcommMaps();
+
+        while (nukeQuery.MoveNext(out var nuke, out var nukeTransform))
+        {
+            if (nuke.Status != NukeStatus.ARMED)
+                continue;
+
+            // UH OH
+            if (nukeTransform.MapUid != null && centcomms.Contains(nukeTransform.MapUid.Value))
             {
-                case GameRunLevel.InRound:
-                    OnRoundStart(uid, nukeops);
-                    break;
-                case GameRunLevel.PostRound:
-                    OnRoundEnd(uid, nukeops);
-                    break;
+                ent.Comp.WinConditions.Add(WinCondition.NukeActiveAtCentCom);
+                SetWinType((ent, ent), WinType.OpsMajor);
+                return;
             }
+
+            if (nukeTransform.GridUid == null || ent.Comp.TargetStation == null)
+                continue;
+
+            if (!TryComp(ent.Comp.TargetStation.Value, out StationDataComponent? data))
+                continue;
+
+            foreach (var grid in data.Grids)
+            {
+                if (grid != nukeTransform.GridUid)
+                    continue;
+
+                ent.Comp.WinConditions.Add(WinCondition.NukeActiveInStation);
+                SetWinType(ent, WinType.OpsMajor);
+                return;
+            }
+        }
+
+        if (_antag.AllAntagsAlive(ent.Owner))
+        {
+            SetWinType(ent, WinType.OpsMinor);
+            ent.Comp.WinConditions.Add(WinCondition.AllNukiesAlive);
+            return;
         }
+
+        ent.Comp.WinConditions.Add(_antag.AnyAliveAntags(ent.Owner)
+            ? WinCondition.SomeNukiesAlive
+            : WinCondition.AllNukiesDead);
+
+        var diskAtCentCom = false;
+        var diskQuery = AllEntityQuery<NukeDiskComponent, TransformComponent>();
+        while (diskQuery.MoveNext(out _, out var transform))
+        {
+            diskAtCentCom = transform.MapUid != null && centcomms.Contains(transform.MapUid.Value);
+
+            // TODO: The target station should be stored, and the nuke disk should store its original station.
+            // This is fine for now, because we can assume a single station in base SS14.
+            break;
+        }
+
+        // If the disk is currently at Central Command, the crew wins - just slightly.
+        // This also implies that some nuclear operatives have died.
+        SetWinType(ent, diskAtCentCom
+            ? WinType.CrewMinor
+            : WinType.OpsMinor);
+        ent.Comp.WinConditions.Add(diskAtCentCom
+            ? WinCondition.NukeDiskOnCentCom
+            : WinCondition.NukeDiskNotOnCentCom);
     }
 
     private void OnNukeDisarm(NukeDisarmSuccessEvent ev)
@@ -294,66 +260,31 @@ private void OnMobStateChanged(EntityUid uid, NukeOperativeComponent component,
             CheckRoundShouldEnd();
     }
 
-    private void OnPlayersGhostSpawning(EntityUid uid, NukeOperativeComponent component, GhostRoleSpawnerUsedEvent args)
+    private void OnOperativeZombified(EntityUid uid, NukeOperativeComponent component, ref EntityZombifiedEvent args)
     {
-        var spawner = args.Spawner;
-
-        if (!TryComp<NukeOperativeSpawnerComponent>(spawner, out var nukeOpSpawner))
-            return;
-
-        HumanoidCharacterProfile? profile = null;
-        if (TryComp(args.Spawned, out ActorComponent? actor))
-            profile = _prefs.GetPreferences(actor.PlayerSession.UserId).SelectedCharacter as HumanoidCharacterProfile;
-
-        // TODO: this is kinda awful for multi-nukies
-        foreach (var nukeops in EntityQuery<NukeopsRuleComponent>())
-        {
-            SetupOperativeEntity(uid, nukeOpSpawner.OperativeName, nukeOpSpawner.SpawnDetails, profile);
-
-            nukeops.OperativeMindPendingData.Add(uid, nukeOpSpawner.SpawnDetails.AntagRoleProto);
-        }
+        RemCompDeferred(uid, component);
     }
 
-    private void OnMindAdded(EntityUid uid, NukeOperativeComponent component, MindAddedMessage args)
+    private void OnMapInit(Entity<NukeOpsShuttleComponent> ent, ref MapInitEvent args)
     {
-        if (!_mind.TryGetMind(uid, out var mindId, out var mind))
-            return;
+        var map = Transform(ent).MapID;
 
-        var query = QueryActiveRules();
-        while (query.MoveNext(out _, out _, out var nukeops, out _))
+        var rules = EntityQueryEnumerator<NukeopsRuleComponent, LoadMapRuleComponent>();
+        while (rules.MoveNext(out var uid, out _, out var mapRule))
         {
-            if (nukeops.OperativeMindPendingData.TryGetValue(uid, out var role) || !nukeops.SpawnOutpost ||
-                nukeops.RoundEndBehavior == RoundEndBehavior.Nothing)
-            {
-                role ??= nukeops.OperativeSpawnDetails.AntagRoleProto;
-                _roles.MindAddRole(mindId, new NukeopsRoleComponent { PrototypeId = role });
-                nukeops.OperativeMindPendingData.Remove(uid);
-            }
-
-            if (mind.Session is not { } playerSession)
-                return;
-
-            if (GameTicker.RunLevel != GameRunLevel.InRound)
-                return;
-
-            if (nukeops.TargetStation != null && !string.IsNullOrEmpty(Name(nukeops.TargetStation.Value)))
-            {
-                NotifyNukie(playerSession, component, nukeops);
-            }
+            if (map != mapRule.Map)
+                continue;
+            ent.Comp.AssociatedRule = uid;
+            break;
         }
     }
 
-    private void OnOperativeZombified(EntityUid uid, NukeOperativeComponent component, ref EntityZombifiedEvent args)
-    {
-        RemCompDeferred(uid, component);
-    }
-
     private void OnShuttleFTLAttempt(ref ConsoleFTLAttemptEvent ev)
     {
         var query = QueryActiveRules();
-        while (query.MoveNext(out _, out _, out var nukeops, out _))
+        while (query.MoveNext(out var uid, out _, out var nukeops, out _))
         {
-            if (ev.Uid != nukeops.NukieShuttle)
+            if (ev.Uid != GetShuttle((uid, nukeops)))
                 continue;
 
             if (nukeops.WarDeclaredTime != null)
@@ -397,12 +328,12 @@ private void OnWarDeclared(ref WarDeclaredEvent ev)
     {
         // TODO: this is VERY awful for multi-nukies
         var query = QueryActiveRules();
-        while (query.MoveNext(out _, out _, out var nukeops, out _))
+        while (query.MoveNext(out var uid, out _, out var nukeops, out _))
         {
             if (nukeops.WarDeclaredTime != null)
                 continue;
 
-            if (Transform(ev.DeclaratorEntity).MapID != nukeops.NukiePlanet)
+            if (TryComp<LoadMapRuleComponent>(uid, out var mapComp) && Transform(ev.DeclaratorEntity).MapID != mapComp.Map)
                 continue;
 
             var newStatus = GetWarCondition(nukeops, ev.Status);
@@ -413,7 +344,7 @@ private void OnWarDeclared(ref WarDeclaredEvent ev)
                 var timeRemain = nukeops.WarNukieArriveDelay + Timing.CurTime;
                 ev.DeclaratorEntity.Comp.ShuttleDisabledTime = timeRemain;
 
-                DistributeExtraTc(nukeops);
+                DistributeExtraTc((uid, nukeops));
             }
         }
     }
@@ -440,7 +371,7 @@ public WarConditionStatus GetWarCondition(NukeopsRuleComponent nukieRule, WarCon
         return WarConditionStatus.YesWar;
     }
 
-    private void DistributeExtraTc(NukeopsRuleComponent nukieRule)
+    private void DistributeExtraTc(Entity<NukeopsRuleComponent> nukieRule)
     {
         var enumerator = EntityQueryEnumerator<StoreComponent>();
         while (enumerator.MoveNext(out var uid, out var component))
@@ -448,161 +379,22 @@ private void DistributeExtraTc(NukeopsRuleComponent nukieRule)
             if (!_tag.HasTag(uid, NukeOpsUplinkTagPrototype))
                 continue;
 
-            if (!nukieRule.NukieOutpost.HasValue)
+            if (GetOutpost(nukieRule.Owner) is not { } outpost)
                 continue;
 
-            if (Transform(uid).MapID != Transform(nukieRule.NukieOutpost.Value).MapID) // Will receive bonus TC only on their start outpost
+            if (Transform(uid).MapID != Transform(outpost).MapID) // Will receive bonus TC only on their start outpost
                 continue;
 
-            _store.TryAddCurrency(new () { { TelecrystalCurrencyPrototype, nukieRule.WarTCAmountPerNukie } }, uid, component);
+            _store.TryAddCurrency(new () { { TelecrystalCurrencyPrototype, nukieRule.Comp.WarTcAmountPerNukie } }, uid, component);
 
             var msg = Loc.GetString("store-currency-war-boost-given", ("target", uid));
             _popupSystem.PopupEntity(msg, uid);
         }
     }
 
-    private void OnRoundStart(EntityUid uid, NukeopsRuleComponent? component = null)
+    private void SetWinType(Entity<NukeopsRuleComponent> ent, WinType type, bool endRound = true)
     {
-        if (!Resolve(uid, ref component))
-            return;
-
-        // TODO: This needs to try and target a Nanotrasen station. At the very least,
-        // we can only currently guarantee that NT stations are the only station to
-        // exist in the base game.
-
-        var eligible = new List<Entity<StationEventEligibleComponent, NpcFactionMemberComponent>>();
-        var eligibleQuery = EntityQueryEnumerator<StationEventEligibleComponent, NpcFactionMemberComponent>();
-        while (eligibleQuery.MoveNext(out var eligibleUid, out var eligibleComp, out var member))
-        {
-            if (!_npcFaction.IsFactionHostile(component.Faction, eligibleUid, member))
-                continue;
-
-            eligible.Add((eligibleUid, eligibleComp, member));
-        }
-
-        if (eligible.Count == 0)
-            return;
-
-        component.TargetStation = RobustRandom.Pick(eligible);
-        component.OperationName = _randomMetadata.GetRandomFromSegments([OperationPrefixDataset, OperationSuffixDataset], " ");
-
-        var filter = Filter.Empty();
-        var query = EntityQueryEnumerator<NukeOperativeComponent, ActorComponent>();
-        while (query.MoveNext(out _, out var nukeops, out var actor))
-        {
-            NotifyNukie(actor.PlayerSession, nukeops, component);
-            filter.AddPlayer(actor.PlayerSession);
-        }
-    }
-
-    private void OnRoundEnd(EntityUid uid, NukeopsRuleComponent? component = null)
-    {
-        if (!Resolve(uid, ref component))
-            return;
-
-        // If the win condition was set to operative/crew major win, ignore.
-        if (component.WinType == WinType.OpsMajor || component.WinType == WinType.CrewMajor)
-            return;
-
-        var nukeQuery = AllEntityQuery<NukeComponent, TransformComponent>();
-        var centcomms = _emergency.GetCentcommMaps();
-
-        while (nukeQuery.MoveNext(out var nuke, out var nukeTransform))
-        {
-            if (nuke.Status != NukeStatus.ARMED)
-                continue;
-
-            // UH OH
-            if (nukeTransform.MapUid != null && centcomms.Contains(nukeTransform.MapUid.Value))
-            {
-                component.WinConditions.Add(WinCondition.NukeActiveAtCentCom);
-                SetWinType(uid, WinType.OpsMajor, component);
-                return;
-            }
-
-            if (nukeTransform.GridUid == null || component.TargetStation == null)
-                continue;
-
-            if (!TryComp(component.TargetStation.Value, out StationDataComponent? data))
-                continue;
-
-            foreach (var grid in data.Grids)
-            {
-                if (grid != nukeTransform.GridUid)
-                    continue;
-
-                component.WinConditions.Add(WinCondition.NukeActiveInStation);
-                SetWinType(uid, WinType.OpsMajor, component);
-                return;
-            }
-        }
-
-        var allAlive = true;
-        var query = EntityQueryEnumerator<NukeopsRoleComponent, MindContainerComponent, MobStateComponent>();
-        while (query.MoveNext(out var nukeopsUid, out _, out var mindContainer, out var mobState))
-        {
-            // mind got deleted somehow so ignore it
-            if (!_mind.TryGetMind(nukeopsUid, out _, out var mind, mindContainer))
-                continue;
-
-            // check if player got gibbed or ghosted or something - count as dead
-            if (mind.OwnedEntity != null &&
-                // if the player somehow isn't a mob anymore that also counts as dead
-                // have to be alive, not crit or dead
-                mobState.CurrentState is MobState.Alive)
-            {
-                continue;
-            }
-
-            allAlive = false;
-            break;
-        }
-
-        // If all nuke ops were alive at the end of the round,
-        // the nuke ops win. This is to prevent people from
-        // running away the moment nuke ops appear.
-        if (allAlive)
-        {
-            SetWinType(uid, WinType.OpsMinor, component);
-            component.WinConditions.Add(WinCondition.AllNukiesAlive);
-            return;
-        }
-
-        component.WinConditions.Add(WinCondition.SomeNukiesAlive);
-
-        var diskAtCentCom = false;
-        var diskQuery = AllEntityQuery<NukeDiskComponent, TransformComponent>();
-
-        while (diskQuery.MoveNext(out _, out var transform))
-        {
-            diskAtCentCom = transform.MapUid != null && centcomms.Contains(transform.MapUid.Value);
-
-            // TODO: The target station should be stored, and the nuke disk should store its original station.
-            // This is fine for now, because we can assume a single station in base SS14.
-            break;
-        }
-
-        // If the disk is currently at Central Command, the crew wins - just slightly.
-        // This also implies that some nuclear operatives have died.
-        if (diskAtCentCom)
-        {
-            SetWinType(uid, WinType.CrewMinor, component);
-            component.WinConditions.Add(WinCondition.NukeDiskOnCentCom);
-        }
-        // Otherwise, the nuke ops win.
-        else
-        {
-            SetWinType(uid, WinType.OpsMinor, component);
-            component.WinConditions.Add(WinCondition.NukeDiskNotOnCentCom);
-        }
-    }
-
-    private void SetWinType(EntityUid uid, WinType type, NukeopsRuleComponent? component = null, bool endRound = true)
-    {
-        if (!Resolve(uid, ref component))
-            return;
-
-        component.WinType = type;
+        ent.Comp.WinType = type;
 
         if (endRound && (type == WinType.CrewMajor || type == WinType.OpsMajor))
             _roundEndSystem.EndRound();
@@ -613,243 +405,130 @@ private void CheckRoundShouldEnd()
         var query = QueryActiveRules();
         while (query.MoveNext(out var uid, out _, out var nukeops, out _))
         {
-            if (nukeops.RoundEndBehavior == RoundEndBehavior.Nothing || nukeops.WinType == WinType.CrewMajor || nukeops.WinType == WinType.OpsMajor)
-                continue;
-
-            // If there are any nuclear bombs that are active, immediately return. We're not over yet.
-            var armed = false;
-            foreach (var nuke in EntityQuery<NukeComponent>())
-            {
-                if (nuke.Status == NukeStatus.ARMED)
-                {
-                    armed = true;
-                    break;
-                }
-            }
-            if (armed)
-                continue;
-
-            MapId? shuttleMapId = Exists(nukeops.NukieShuttle)
-                ? Transform(nukeops.NukieShuttle.Value).MapID
-                : null;
-
-            MapId? targetStationMap = null;
-            if (nukeops.TargetStation != null && TryComp(nukeops.TargetStation, out StationDataComponent? data))
-            {
-                var grid = data.Grids.FirstOrNull();
-                targetStationMap = grid != null
-                    ? Transform(grid.Value).MapID
-                    : null;
-            }
-
-            // Check if there are nuke operatives still alive on the same map as the shuttle,
-            // or on the same map as the station.
-            // If there are, the round can continue.
-            var operatives = EntityQuery<NukeOperativeComponent, MobStateComponent, TransformComponent>(true);
-            var operativesAlive = operatives
-                .Where(ent =>
-                    ent.Item3.MapID == shuttleMapId
-                    || ent.Item3.MapID == targetStationMap)
-                .Any(ent => ent.Item2.CurrentState == MobState.Alive && ent.Item1.Running);
-
-            if (operativesAlive)
-                continue; // There are living operatives than can access the shuttle, or are still on the station's map.
-
-            // Check that there are spawns available and that they can access the shuttle.
-            var spawnsAvailable = EntityQuery<NukeOperativeSpawnerComponent>(true).Any();
-            if (spawnsAvailable && shuttleMapId == nukeops.NukiePlanet)
-                continue; // Ghost spawns can still access the shuttle. Continue the round.
-
-            // The shuttle is inaccessible to both living nuke operatives and yet to spawn nuke operatives,
-            // and there are no nuclear operatives on the target station's map.
-            nukeops.WinConditions.Add(spawnsAvailable
-                ? WinCondition.NukiesAbandoned
-                : WinCondition.AllNukiesDead);
-
-            SetWinType(uid, WinType.CrewMajor, nukeops, false);
-            _roundEndSystem.DoRoundEndBehavior(
-                nukeops.RoundEndBehavior, nukeops.EvacShuttleTime, nukeops.RoundEndTextSender, nukeops.RoundEndTextShuttleCall, nukeops.RoundEndTextAnnouncement);
-
-            // prevent it called multiple times
-            nukeops.RoundEndBehavior = RoundEndBehavior.Nothing;
-        }
-    }
-
-    private bool SpawnMap(Entity<NukeopsRuleComponent> ent)
-    {
-        if (!ent.Comp.SpawnOutpost
-            || ent.Comp.NukiePlanet != null)
-            return true;
-
-        ent.Comp.NukiePlanet = _mapManager.CreateMap();
-        var gameMap = _prototypeManager.Index(ent.Comp.OutpostMapPrototype);
-        ent.Comp.NukieOutpost = GameTicker.LoadGameMap(gameMap, ent.Comp.NukiePlanet.Value, null)[0];
-        var query = EntityQueryEnumerator<NukeOpsShuttleComponent, TransformComponent>();
-        while (query.MoveNext(out var grid, out _, out var shuttleTransform))
-        {
-            if (shuttleTransform.MapID != ent.Comp.NukiePlanet)
-                continue;
-
-            ent.Comp.NukieShuttle = grid;
-            break;
+            CheckRoundShouldEnd((uid, nukeops));
         }
-
-        return true;
     }
 
-    /// <summary>
-    ///     Adds missing nuke operative components, equips starting gear and renames the entity.
-    /// </summary>
-    private void SetupOperativeEntity(EntityUid mob, string name, NukeopSpawnPreset spawnDetails, HumanoidCharacterProfile? profile)
+    private void CheckRoundShouldEnd(Entity<NukeopsRuleComponent> ent)
     {
-        _metaData.SetEntityName(mob, name);
-        EnsureComp<NukeOperativeComponent>(mob);
-
-        if (profile != null)
-            _humanoid.LoadProfile(mob, profile);
-
-        var gear = _prototypeManager.Index(spawnDetails.GearProto);
-        _stationSpawning.EquipStartingGear(mob, gear, profile);
+        var nukeops = ent.Comp;
 
-        _npcFaction.RemoveFaction(mob, "NanoTrasen", false);
-        _npcFaction.AddFaction(mob, "Syndicate");
-    }
-
-    private void SpawnOperatives(List<NukieSpawn> sessions, bool spawnGhostRoles, NukeopsRuleComponent component)
-    {
-        if (component.NukieOutpost is not { Valid: true } outpostUid)
+        if (nukeops.RoundEndBehavior == RoundEndBehavior.Nothing || nukeops.WinType == WinType.CrewMajor || nukeops.WinType == WinType.OpsMajor)
             return;
 
-        var spawns = new List<EntityCoordinates>();
-        foreach (var (_, meta, xform) in EntityQuery<SpawnPointComponent, MetaDataComponent, TransformComponent>(true))
-        {
-            if (meta.EntityPrototype?.ID != component.SpawnPointProto.Id)
-                continue;
-
-            if (xform.ParentUid != component.NukieOutpost)
-                continue;
-
-            spawns.Add(xform.Coordinates);
-            break;
-        }
 
-        //Fallback, spawn at the centre of the map
-        if (spawns.Count == 0)
+        // If there are any nuclear bombs that are active, immediately return. We're not over yet.
+        foreach (var nuke in EntityQuery<NukeComponent>())
         {
-            spawns.Add(Transform(outpostUid).Coordinates);
-            _sawmill.Warning($"Fell back to default spawn for nukies!");
+            if (nuke.Status == NukeStatus.ARMED)
+                return;
         }
 
-        //Spawn the team
-        foreach (var nukieSession in sessions)
-        {
-            var name = $"{Loc.GetString(nukieSession.Type.NamePrefix)} {RobustRandom.PickAndTake(_prototypeManager.Index(nukieSession.Type.NameList).Values.ToList())}";
+        var shuttle = GetShuttle((ent, ent));
 
-            var nukeOpsAntag = _prototypeManager.Index(nukieSession.Type.AntagRoleProto);
+        MapId? shuttleMapId = Exists(shuttle)
+            ? Transform(shuttle.Value).MapID
+            : null;
 
-            //If a session is available, spawn mob and transfer mind into it
-            if (nukieSession.Session != null)
-            {
-                var profile = _prefs.GetPreferences(nukieSession.Session.UserId).SelectedCharacter as HumanoidCharacterProfile;
-                if (!_prototypeManager.TryIndex(profile?.Species ?? SharedHumanoidAppearanceSystem.DefaultSpecies, out SpeciesPrototype? species))
-                {
-                    species = _prototypeManager.Index<SpeciesPrototype>(SharedHumanoidAppearanceSystem.DefaultSpecies);
-                }
-
-                var mob = Spawn(species.Prototype, RobustRandom.Pick(spawns));
-                SetupOperativeEntity(mob, name, nukieSession.Type, profile);
-
-                var newMind = _mind.CreateMind(nukieSession.Session.UserId, name);
-                _mind.SetUserId(newMind, nukieSession.Session.UserId);
-                _roles.MindAddRole(newMind, new NukeopsRoleComponent { PrototypeId = nukieSession.Type.AntagRoleProto });
-
-                _mind.TransferTo(newMind, mob);
-            }
-            //Otherwise, spawn as a ghost role
-            else if (spawnGhostRoles)
-            {
-                var spawnPoint = Spawn(component.GhostSpawnPointProto, RobustRandom.Pick(spawns));
-                var ghostRole = EnsureComp<GhostRoleComponent>(spawnPoint);
-                EnsureComp<GhostRoleMobSpawnerComponent>(spawnPoint);
-                ghostRole.RoleName = Loc.GetString(nukeOpsAntag.Name);
-                ghostRole.RoleDescription = Loc.GetString(nukeOpsAntag.Objective);
-
-                var nukeOpSpawner = EnsureComp<NukeOperativeSpawnerComponent>(spawnPoint);
-                nukeOpSpawner.OperativeName = name;
-                nukeOpSpawner.SpawnDetails = nukieSession.Type;
-            }
+        MapId? targetStationMap = null;
+        if (nukeops.TargetStation != null && TryComp(nukeops.TargetStation, out StationDataComponent? data))
+        {
+            var grid = data.Grids.FirstOrNull();
+            targetStationMap = grid != null
+                ? Transform(grid.Value).MapID
+                : null;
         }
-    }
 
-    /// <summary>
-    /// Display a greeting message and play a sound for a nukie
-    /// </summary>
-    private void NotifyNukie(ICommonSession session, NukeOperativeComponent nukeop, NukeopsRuleComponent nukeopsRule)
-    {
-        if (nukeopsRule.TargetStation is not { } station)
-            return;
-
-        _antagSelection.SendBriefing(session, Loc.GetString("nukeops-welcome", ("station", station), ("name", nukeopsRule.OperationName)), Color.Red, nukeop.GreetSoundNotification);
+        // Check if there are nuke operatives still alive on the same map as the shuttle,
+        // or on the same map as the station.
+        // If there are, the round can continue.
+        var operatives = EntityQuery<NukeOperativeComponent, MobStateComponent, TransformComponent>(true);
+        var operativesAlive = operatives
+            .Where(op =>
+                op.Item3.MapID == shuttleMapId
+                || op.Item3.MapID == targetStationMap)
+            .Any(op => op.Item2.CurrentState == MobState.Alive && op.Item1.Running);
+
+        if (operativesAlive)
+            return; // There are living operatives than can access the shuttle, or are still on the station's map.
+
+        // Check that there are spawns available and that they can access the shuttle.
+        var spawnsAvailable = EntityQuery<NukeOperativeSpawnerComponent>(true).Any();
+        if (spawnsAvailable && CompOrNull<LoadMapRuleComponent>(ent)?.Map == shuttleMapId)
+            return; // Ghost spawns can still access the shuttle. Continue the round.
+
+        // The shuttle is inaccessible to both living nuke operatives and yet to spawn nuke operatives,
+        // and there are no nuclear operatives on the target station's map.
+        nukeops.WinConditions.Add(spawnsAvailable
+            ? WinCondition.NukiesAbandoned
+            : WinCondition.AllNukiesDead);
+
+        SetWinType(ent, WinType.CrewMajor, false);
+        _roundEndSystem.DoRoundEndBehavior(
+            nukeops.RoundEndBehavior, nukeops.EvacShuttleTime, nukeops.RoundEndTextSender, nukeops.RoundEndTextShuttleCall, nukeops.RoundEndTextAnnouncement);
+
+        // prevent it called multiple times
+        nukeops.RoundEndBehavior = RoundEndBehavior.Nothing;
     }
 
-    /// <summary>
-    /// Spawn nukie ghost roles if this gamerule was started mid round
-    /// </summary>
-    private void SpawnOperativesForGhostRoles(EntityUid uid, NukeopsRuleComponent? component = null)
+    // this should really go anywhere else but im tired.
+    private void OnAntagSelectEntity(Entity<NukeopsRuleComponent> ent, ref AntagSelectEntityEvent args)
     {
-        if (!Resolve(uid, ref component))
+        if (args.Handled)
             return;
 
-        if (!SpawnMap((uid, component)))
+        var profile = args.Session != null
+            ? _prefs.GetPreferences(args.Session.UserId).SelectedCharacter as HumanoidCharacterProfile
+            : HumanoidCharacterProfile.RandomWithSpecies();
+        if (!_prototypeManager.TryIndex(profile?.Species ?? SharedHumanoidAppearanceSystem.DefaultSpecies, out SpeciesPrototype? species))
         {
-            _sawmill.Info("Failed to load map for nukeops");
-            return;
+            species = _prototypeManager.Index<SpeciesPrototype>(SharedHumanoidAppearanceSystem.DefaultSpecies);
         }
 
-        var numNukies = _antagSelection.CalculateAntagCount(_playerManager.PlayerCount, component.PlayersPerOperative, component.MaxOps);
+        args.Entity = Spawn(species.Prototype);
+        _humanoid.LoadProfile(args.Entity.Value, profile);
+    }
 
-        //Dont continue if we have no nukies to spawn
-        if (numNukies == 0)
+    private void OnAfterAntagEntSelected(Entity<NukeopsRuleComponent> ent, ref AfterAntagEntitySelectedEvent args)
+    {
+        if (ent.Comp.TargetStation is not { } station)
             return;
 
-        //Fill the ranks, commander first, then agent, then operatives
-        //TODO: Possible alternative team compositions? Like multiple commanders or agents
-        var operatives = new List<NukieSpawn>();
-        if (numNukies >= 1)
-            operatives.Add(new NukieSpawn(null, component.CommanderSpawnDetails));
-        if (numNukies >= 2)
-            operatives.Add(new NukieSpawn(null, component.AgentSpawnDetails));
-        if (numNukies >= 3)
-        {
-            for (var i = 2; i < numNukies; i++)
-            {
-                operatives.Add(new NukieSpawn(null, component.OperativeSpawnDetails));
-            }
-        }
-
-        SpawnOperatives(operatives, true, component);
+        _antag.SendBriefing(args.Session, Loc.GetString("nukeops-welcome",
+                ("station", station),
+                ("name", Name(ent))),
+            Color.Red,
+            ent.Comp.GreetSoundNotification);
     }
 
-    //For admins forcing someone to nukeOps.
-    public void MakeLoneNukie(EntityUid entity)
+    /// <remarks>
+    /// Is this method the shitty glue holding together the last of my sanity? yes.
+    /// Do i have a better solution? not presently.
+    /// </remarks>
+    private EntityUid? GetOutpost(Entity<LoadMapRuleComponent?> ent)
     {
-        if (!_mind.TryGetMind(entity, out var mindId, out var mindComponent))
-            return;
+        if (!Resolve(ent, ref ent.Comp, false))
+            return null;
 
-        //ok hardcoded value bad but so is everything else here
-        _roles.MindAddRole(mindId, new NukeopsRoleComponent { PrototypeId = NukeopsId }, mindComponent);
-        SetOutfitCommand.SetOutfit(entity, "SyndicateOperativeGearFull", EntityManager);
+        return ent.Comp.MapGrids.Where(e => HasComp<StationMemberComponent>(e) && !HasComp<NukeOpsShuttleComponent>(e)).FirstOrNull();
     }
 
-    private sealed class NukieSpawn
+    /// <remarks>
+    /// Is this method the shitty glue holding together the last of my sanity? yes.
+    /// Do i have a better solution? not presently.
+    /// </remarks>
+    private EntityUid? GetShuttle(Entity<NukeopsRuleComponent?> ent)
     {
-        public ICommonSession? Session { get; private set; }
-        public NukeopSpawnPreset Type { get; private set; }
+        if (!Resolve(ent, ref ent.Comp, false))
+            return null;
 
-        public NukieSpawn(ICommonSession? session, NukeopSpawnPreset type)
+        var query = EntityQueryEnumerator<NukeOpsShuttleComponent>();
+        while (query.MoveNext(out var uid, out var comp))
         {
-            Session = session;
-            Type = type;
+            if (comp.AssociatedRule == ent.Owner)
+                return uid;
         }
+
+        return null;
     }
 }
diff --git a/Content.Server/GameTicking/Rules/PiratesRuleSystem.cs b/Content.Server/GameTicking/Rules/PiratesRuleSystem.cs
index 128f1123043..e69de29bb2d 100644
--- a/Content.Server/GameTicking/Rules/PiratesRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/PiratesRuleSystem.cs
@@ -1,321 +0,0 @@
-using System.Linq;
-using System.Numerics;
-using Content.Server.Administration.Commands;
-using Content.Server.Cargo.Systems;
-using Content.Server.Chat.Managers;
-using Content.Server.GameTicking.Rules.Components;
-using Content.Server.NPC.Components;
-using Content.Server.NPC.Systems;
-using Content.Server.Preferences.Managers;
-using Content.Server.Spawners.Components;
-using Content.Server.Station.Components;
-using Content.Server.Station.Systems;
-using Content.Shared.CCVar;
-using Content.Shared.Humanoid;
-using Content.Shared.Humanoid.Prototypes;
-using Content.Shared.Mind;
-using Content.Shared.Preferences;
-using Content.Shared.Roles;
-using Robust.Server.GameObjects;
-using Robust.Server.Maps;
-using Robust.Server.Player;
-using Robust.Shared.Audio;
-using Robust.Shared.Audio.Systems;
-using Robust.Shared.Configuration;
-using Robust.Shared.Enums;
-using Robust.Shared.Map;
-using Robust.Shared.Map.Components;
-using Robust.Shared.Player;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Random;
-using Robust.Shared.Utility;
-
-namespace Content.Server.GameTicking.Rules;
-
-/// <summary>
-/// This handles the Pirates minor antag, which is designed to coincide with other modes on occasion.
-/// </summary>
-public sealed class PiratesRuleSystem : GameRuleSystem<PiratesRuleComponent>
-{
-    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-    [Dependency] private readonly IRobustRandom _random = default!;
-    [Dependency] private readonly IConfigurationManager _cfg = default!;
-    [Dependency] private readonly IChatManager _chatManager = default!;
-    [Dependency] private readonly IMapManager _mapManager = default!;
-    [Dependency] private readonly IServerPreferencesManager _prefs = default!;
-    [Dependency] private readonly StationSpawningSystem _stationSpawningSystem = default!;
-    [Dependency] private readonly PricingSystem _pricingSystem = default!;
-    [Dependency] private readonly MapLoaderSystem _map = default!;
-    [Dependency] private readonly NamingSystem _namingSystem = default!;
-    [Dependency] private readonly NpcFactionSystem _npcFaction = default!;
-    [Dependency] private readonly SharedMindSystem _mindSystem = default!;
-    [Dependency] private readonly SharedAudioSystem _audioSystem = default!;
-    [Dependency] private readonly MetaDataSystem _metaData = default!;
-
-    [ValidatePrototypeId<EntityPrototype>]
-    private const string GameRuleId = "Pirates";
-
-    [ValidatePrototypeId<EntityPrototype>]
-    private const string MobId = "MobHuman";
-
-    [ValidatePrototypeId<SpeciesPrototype>]
-    private const string SpeciesId = "Human";
-
-    [ValidatePrototypeId<NpcFactionPrototype>]
-    private const string PirateFactionId = "Syndicate";
-
-    [ValidatePrototypeId<NpcFactionPrototype>]
-    private const string EnemyFactionId = "NanoTrasen";
-
-    [ValidatePrototypeId<StartingGearPrototype>]
-    private const string GearId = "PirateGear";
-
-    [ValidatePrototypeId<EntityPrototype>]
-    private const string SpawnPointId = "SpawnPointPirates";
-
-    /// <inheritdoc/>
-    public override void Initialize()
-    {
-        base.Initialize();
-
-        SubscribeLocalEvent<RulePlayerSpawningEvent>(OnPlayerSpawningEvent);
-        SubscribeLocalEvent<RoundEndTextAppendEvent>(OnRoundEndTextEvent);
-        SubscribeLocalEvent<RoundStartAttemptEvent>(OnStartAttempt);
-    }
-
-    private void OnRoundEndTextEvent(RoundEndTextAppendEvent ev)
-    {
-        var query = EntityQueryEnumerator<PiratesRuleComponent, GameRuleComponent>();
-        while (query.MoveNext(out var uid, out var pirates, out var gameRule))
-        {
-            if (Deleted(pirates.PirateShip))
-            {
-                // Major loss, the ship somehow got annihilated.
-                ev.AddLine(Loc.GetString("pirates-no-ship"));
-            }
-            else
-            {
-                List<(double, EntityUid)> mostValuableThefts = new();
-
-                var comp1 = pirates;
-                var finalValue = _pricingSystem.AppraiseGrid(pirates.PirateShip, uid =>
-                {
-                    foreach (var mindId in comp1.Pirates)
-                    {
-                        if (TryComp(mindId, out MindComponent? mind) && mind.CurrentEntity == uid)
-                            return false; // Don't appraise the pirates twice, we count them in separately.
-                    }
-
-                    return true;
-                }, (uid, price) =>
-                {
-                    if (comp1.InitialItems.Contains(uid))
-                        return;
-
-                    mostValuableThefts.Add((price, uid));
-                    mostValuableThefts.Sort((i1, i2) => i2.Item1.CompareTo(i1.Item1));
-                    if (mostValuableThefts.Count > 5)
-                        mostValuableThefts.Pop();
-                });
-
-                foreach (var mindId in pirates.Pirates)
-                {
-                    if (TryComp(mindId, out MindComponent? mind) && mind.CurrentEntity is not null)
-                        finalValue += _pricingSystem.GetPrice(mind.CurrentEntity.Value);
-                }
-
-                var score = finalValue - pirates.InitialShipValue;
-
-                ev.AddLine(Loc.GetString("pirates-final-score", ("score", $"{score:F2}")));
-                ev.AddLine(Loc.GetString("pirates-final-score-2", ("finalPrice", $"{finalValue:F2}")));
-
-                ev.AddLine("");
-                ev.AddLine(Loc.GetString("pirates-most-valuable"));
-
-                foreach (var (price, obj) in mostValuableThefts)
-                {
-                    ev.AddLine(Loc.GetString("pirates-stolen-item-entry", ("entity", obj), ("credits", $"{price:F2}")));
-                }
-
-                if (mostValuableThefts.Count == 0)
-                    ev.AddLine(Loc.GetString("pirates-stole-nothing"));
-            }
-
-            ev.AddLine("");
-            ev.AddLine(Loc.GetString("pirates-list-start"));
-            foreach (var pirate in pirates.Pirates)
-            {
-                if (TryComp(pirate, out MindComponent? mind))
-                {
-                    ev.AddLine($"- {mind.CharacterName} ({mind.Session?.Name})");
-                }
-            }
-        }
-    }
-
-    private void OnPlayerSpawningEvent(RulePlayerSpawningEvent ev)
-    {
-        var query = EntityQueryEnumerator<PiratesRuleComponent, GameRuleComponent>();
-        while (query.MoveNext(out var uid, out var pirates, out var gameRule))
-        {
-            // Forgive me for copy-pasting nukies.
-            if (!GameTicker.IsGameRuleAdded(uid, gameRule))
-                return;
-
-            pirates.Pirates.Clear();
-            pirates.InitialItems.Clear();
-
-            // Between 1 and <max pirate count>: needs at least n players per op.
-            var numOps = Math.Max(1,
-                (int) Math.Min(
-                    Math.Floor((double) ev.PlayerPool.Count / _cfg.GetCVar(CCVars.PiratesPlayersPerOp)),
-                    _cfg.GetCVar(CCVars.PiratesMaxOps)));
-            var ops = new ICommonSession[numOps];
-            for (var i = 0; i < numOps; i++)
-            {
-                ops[i] = _random.PickAndTake(ev.PlayerPool);
-            }
-
-            var map = "/Maps/Shuttles/pirate.yml";
-            var xformQuery = GetEntityQuery<TransformComponent>();
-
-            var aabbs = EntityQuery<StationDataComponent>().SelectMany(x =>
-                    x.Grids.Select(x =>
-                        xformQuery.GetComponent(x).WorldMatrix.TransformBox(Comp<MapGridComponent>(x).LocalAABB)))
-                .ToArray();
-
-            var aabb = aabbs[0];
-
-            for (var i = 1; i < aabbs.Length; i++)
-            {
-                aabb.Union(aabbs[i]);
-            }
-
-            // (Not commented?)
-            var a = MathF.Max(aabb.Height / 2f, aabb.Width / 2f) * 2.5f;
-
-            var gridId = _map.LoadGrid(GameTicker.DefaultMap, map, new MapLoadOptions
-            {
-                Offset = aabb.Center + new Vector2(a, a),
-                LoadMap = false,
-            });
-
-            if (!gridId.HasValue)
-            {
-                Log.Error($"Gridid was null when loading \"{map}\", aborting.");
-                foreach (var session in ops)
-                {
-                    ev.PlayerPool.Add(session);
-                }
-
-                return;
-            }
-
-            pirates.PirateShip = gridId.Value;
-
-            // TODO: Loot table or something
-            var pirateGear = _prototypeManager.Index<StartingGearPrototype>(GearId); // YARRR
-
-            var spawns = new List<EntityCoordinates>();
-
-            // Forgive me for hardcoding prototypes
-            foreach (var (_, meta, xform) in
-                     EntityQuery<SpawnPointComponent, MetaDataComponent, TransformComponent>(true))
-            {
-                if (meta.EntityPrototype?.ID != SpawnPointId || xform.ParentUid != pirates.PirateShip)
-                    continue;
-
-                spawns.Add(xform.Coordinates);
-            }
-
-            if (spawns.Count == 0)
-            {
-                spawns.Add(Transform(pirates.PirateShip).Coordinates);
-                Log.Warning($"Fell back to default spawn for pirates!");
-            }
-
-            for (var i = 0; i < ops.Length; i++)
-            {
-                var sex = _random.Prob(0.5f) ? Sex.Male : Sex.Female;
-                var gender = sex == Sex.Male ? Gender.Male : Gender.Female;
-
-                var name = _namingSystem.GetName(SpeciesId, gender);
-
-                var session = ops[i];
-                var newMind = _mindSystem.CreateMind(session.UserId, name);
-                _mindSystem.SetUserId(newMind, session.UserId);
-
-                var mob = Spawn(MobId, _random.Pick(spawns));
-                _metaData.SetEntityName(mob, name);
-
-                _mindSystem.TransferTo(newMind, mob);
-                var profile = _prefs.GetPreferences(session.UserId).SelectedCharacter as HumanoidCharacterProfile;
-                _stationSpawningSystem.EquipStartingGear(mob, pirateGear, profile);
-
-                _npcFaction.RemoveFaction(mob, EnemyFactionId, false);
-                _npcFaction.AddFaction(mob, PirateFactionId);
-
-                pirates.Pirates.Add(newMind);
-
-                // Notificate every player about a pirate antagonist role with sound
-                _audioSystem.PlayGlobal(pirates.PirateAlertSound, session);
-
-                GameTicker.PlayerJoinGame(session);
-            }
-
-            pirates.InitialShipValue = _pricingSystem.AppraiseGrid(pirates.PirateShip, uid =>
-            {
-                pirates.InitialItems.Add(uid);
-                return true;
-            }); // Include the players in the appraisal.
-        }
-    }
-
-    //Forcing one player to be a pirate.
-    public void MakePirate(EntityUid entity)
-    {
-        if (!_mindSystem.TryGetMind(entity, out var mindId, out var mind))
-            return;
-
-        SetOutfitCommand.SetOutfit(entity, GearId, EntityManager);
-
-        var pirateRule = EntityQuery<PiratesRuleComponent>().FirstOrDefault();
-        if (pirateRule == null)
-        {
-            //todo fuck me this shit is awful
-            GameTicker.StartGameRule(GameRuleId, out var ruleEntity);
-            pirateRule = Comp<PiratesRuleComponent>(ruleEntity);
-        }
-
-        // Notificate every player about a pirate antagonist role with sound
-        if (mind.Session != null)
-        {
-            _audioSystem.PlayGlobal(pirateRule.PirateAlertSound, mind.Session);
-        }
-    }
-
-    private void OnStartAttempt(RoundStartAttemptEvent ev)
-    {
-        var query = EntityQueryEnumerator<PiratesRuleComponent, GameRuleComponent>();
-        while (query.MoveNext(out var uid, out var pirates, out var gameRule))
-        {
-            if (!GameTicker.IsGameRuleActive(uid, gameRule))
-                return;
-
-            var minPlayers = _cfg.GetCVar(CCVars.PiratesMinPlayers);
-            if (!ev.Forced && ev.Players.Length < minPlayers)
-            {
-                _chatManager.SendAdminAnnouncement(Loc.GetString("nukeops-not-enough-ready-players",
-                    ("readyPlayersCount", ev.Players.Length), ("minimumPlayers", minPlayers)));
-                ev.Cancel();
-                return;
-            }
-
-            if (ev.Players.Length == 0)
-            {
-                _chatManager.DispatchServerAnnouncement(Loc.GetString("nukeops-no-one-ready"));
-                ev.Cancel();
-            }
-        }
-    }
-}
diff --git a/Content.Server/GameTicking/Rules/RespawnRuleSystem.cs b/Content.Server/GameTicking/Rules/RespawnRuleSystem.cs
index b11c28fb2b0..5215da96aa8 100644
--- a/Content.Server/GameTicking/Rules/RespawnRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/RespawnRuleSystem.cs
@@ -1,4 +1,5 @@
 using Content.Server.Chat.Managers;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Station.Systems;
 using Content.Shared.Chat;
diff --git a/Content.Server/GameTicking/Rules/RevolutionaryRuleSystem.cs b/Content.Server/GameTicking/Rules/RevolutionaryRuleSystem.cs
index d20775c7343..7e6901e6c48 100644
--- a/Content.Server/GameTicking/Rules/RevolutionaryRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/RevolutionaryRuleSystem.cs
@@ -16,7 +16,6 @@
 using Content.Shared.Database;
 using Content.Shared.Humanoid;
 using Content.Shared.IdentityManagement;
-using Content.Shared.Inventory;
 using Content.Shared.Mind;
 using Content.Shared.Mind.Components;
 using Content.Shared.Mindshield.Components;
@@ -24,12 +23,11 @@
 using Content.Shared.Mobs.Components;
 using Content.Shared.Mobs.Systems;
 using Content.Shared.Revolutionary.Components;
-using Content.Shared.Roles;
 using Content.Shared.Stunnable;
 using Content.Shared.Zombies;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Timing;
-using System.Linq;
+using Content.Server.GameTicking.Components;
 
 namespace Content.Server.GameTicking.Rules;
 
@@ -40,7 +38,7 @@ public sealed class RevolutionaryRuleSystem : GameRuleSystem<RevolutionaryRuleCo
 {
     [Dependency] private readonly IAdminLogManager _adminLogManager = default!;
     [Dependency] private readonly IGameTiming _timing = default!;
-    [Dependency] private readonly AntagSelectionSystem _antagSelection = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
     [Dependency] private readonly EuiManager _euiMan = default!;
     [Dependency] private readonly MindSystem _mind = default!;
     [Dependency] private readonly MobStateSystem _mobState = default!;
@@ -51,7 +49,6 @@ public sealed class RevolutionaryRuleSystem : GameRuleSystem<RevolutionaryRuleCo
     [Dependency] private readonly RoundEndSystem _roundEnd = default!;
     [Dependency] private readonly StationSystem _stationSystem = default!;
     [Dependency] private readonly EmergencyShuttleSystem _emergencyShuttle = default!;
-    [Dependency] private readonly InventorySystem _inventory = default!;
 
     //Used in OnPostFlash, no reference to the rule component is available
     public readonly ProtoId<NpcFactionPrototype> RevolutionaryNpcFaction = "Revolutionary";
@@ -60,23 +57,12 @@ public sealed class RevolutionaryRuleSystem : GameRuleSystem<RevolutionaryRuleCo
     public override void Initialize()
     {
         base.Initialize();
-        SubscribeLocalEvent<RoundStartAttemptEvent>(OnStartAttempt);
-        SubscribeLocalEvent<RulePlayerJobsAssignedEvent>(OnPlayerJobAssigned);
         SubscribeLocalEvent<CommandStaffComponent, MobStateChangedEvent>(OnCommandMobStateChanged);
         SubscribeLocalEvent<HeadRevolutionaryComponent, MobStateChangedEvent>(OnHeadRevMobStateChanged);
-        SubscribeLocalEvent<RoundEndTextAppendEvent>(OnRoundEndText);
         SubscribeLocalEvent<RevolutionaryRoleComponent, GetBriefingEvent>(OnGetBriefing);
         SubscribeLocalEvent<HeadRevolutionaryComponent, AfterFlashedEvent>(OnPostFlash);
     }
 
-    //Set miniumum players
-    protected override void Added(EntityUid uid, RevolutionaryRuleComponent component, GameRuleComponent gameRule, GameRuleAddedEvent args)
-    {
-        base.Added(uid, component, gameRule, args);
-
-        gameRule.MinPlayers = component.MinPlayers;
-    }
-
     protected override void Started(EntityUid uid, RevolutionaryRuleComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
     {
         base.Started(uid, component, gameRule, args);
@@ -98,40 +84,29 @@ protected override void ActiveTick(EntityUid uid, RevolutionaryRuleComponent com
         }
     }
 
-    private void OnRoundEndText(RoundEndTextAppendEvent ev)
+    protected override void AppendRoundEndText(EntityUid uid, RevolutionaryRuleComponent component, GameRuleComponent gameRule,
+        ref RoundEndTextAppendEvent args)
     {
+        base.AppendRoundEndText(uid, component, gameRule, ref args);
+
         var revsLost = CheckRevsLose();
         var commandLost = CheckCommandLose();
-        var query = AllEntityQuery<RevolutionaryRuleComponent>();
-        while (query.MoveNext(out var headrev))
+        // This is (revsLost, commandsLost) concatted together
+        // (moony wrote this comment idk what it means)
+        var index = (commandLost ? 1 : 0) | (revsLost ? 2 : 0);
+        args.AddLine(Loc.GetString(Outcomes[index]));
+
+        var sessionData = _antag.GetAntagIdentifiers(uid);
+        args.AddLine(Loc.GetString("rev-headrev-count", ("initialCount", sessionData.Count)));
+        foreach (var (mind, data, name) in sessionData)
         {
-            // This is (revsLost, commandsLost) concatted together
-            // (moony wrote this comment idk what it means)
-            var index = (commandLost ? 1 : 0) | (revsLost ? 2 : 0);
-            ev.AddLine(Loc.GetString(Outcomes[index]));
-
-            ev.AddLine(Loc.GetString("rev-headrev-count", ("initialCount", headrev.HeadRevs.Count)));
-            foreach (var player in headrev.HeadRevs)
-            {
-                // TODO: when role entities are a thing this has to change
-                var count = CompOrNull<RevolutionaryRoleComponent>(player.Value)?.ConvertedCount ?? 0;
-
-                _mind.TryGetSession(player.Value, out var session);
-                var username = session?.Name;
-                if (username != null)
-                {
-                    ev.AddLine(Loc.GetString("rev-headrev-name-user",
-                    ("name", player.Key),
-                    ("username", username), ("count", count)));
-                }
-                else
-                {
-                    ev.AddLine(Loc.GetString("rev-headrev-name",
-                    ("name", player.Key), ("count", count)));
-                }
+            var count = CompOrNull<RevolutionaryRoleComponent>(mind)?.ConvertedCount ?? 0;
+            args.AddLine(Loc.GetString("rev-headrev-name-user",
+                ("name", name),
+                ("username", data.UserName),
+                ("count", count)));
 
-                // TODO: someone suggested listing all alive? revs maybe implement at some point
-            }
+            // TODO: someone suggested listing all alive? revs maybe implement at some point
         }
     }
 
@@ -144,57 +119,6 @@ private void OnGetBriefing(EntityUid uid, RevolutionaryRoleComponent comp, ref G
         args.Append(Loc.GetString(head ? "head-rev-briefing" : "rev-briefing"));
     }
 
-    //Check for enough players to start rule
-    private void OnStartAttempt(RoundStartAttemptEvent ev)
-    {
-        TryRoundStartAttempt(ev, Loc.GetString("roles-antag-rev-name"));
-    }
-
-    private void OnPlayerJobAssigned(RulePlayerJobsAssignedEvent ev)
-    {
-        var query = QueryActiveRules();
-        while (query.MoveNext(out var uid, out var activeGameRule, out var comp, out var gameRule))
-        {
-            var eligiblePlayers = _antagSelection.GetEligiblePlayers(ev.Players, comp.HeadRevPrototypeId);
-
-            if (eligiblePlayers.Count == 0)
-                continue;
-
-            var headRevCount = _antagSelection.CalculateAntagCount(ev.Players.Length, comp.PlayersPerHeadRev, comp.MaxHeadRevs);
-
-            var headRevs = _antagSelection.ChooseAntags(headRevCount, eligiblePlayers);
-
-            GiveHeadRev(headRevs, comp.HeadRevPrototypeId, comp);
-        }
-    }
-
-    private void GiveHeadRev(IEnumerable<EntityUid> chosen, ProtoId<AntagPrototype> antagProto, RevolutionaryRuleComponent comp)
-    {
-        foreach (var headRev in chosen)
-            GiveHeadRev(headRev, antagProto, comp);
-    }
-    private void GiveHeadRev(EntityUid chosen, ProtoId<AntagPrototype> antagProto, RevolutionaryRuleComponent comp)
-    {
-        RemComp<CommandStaffComponent>(chosen);
-
-        var inCharacterName = MetaData(chosen).EntityName;
-
-        if (!_mind.TryGetMind(chosen, out var mind, out _))
-            return;
-
-        if (!_role.MindHasRole<RevolutionaryRoleComponent>(mind))
-        {
-            _role.MindAddRole(mind, new RevolutionaryRoleComponent { PrototypeId = antagProto }, silent: true);
-        }
-
-        comp.HeadRevs.Add(inCharacterName, mind);
-        _inventory.SpawnItemsOnEntity(chosen, comp.StartingGear);
-        var revComp = EnsureComp<RevolutionaryComponent>(chosen);
-        EnsureComp<HeadRevolutionaryComponent>(chosen);
-
-        _antagSelection.SendBriefing(chosen, Loc.GetString("head-rev-role-greeting"), Color.CornflowerBlue, revComp.RevStartSound);
-    }
-
     /// <summary>
     /// Called when a Head Rev uses a flash in melee to convert somebody else.
     /// </summary>
@@ -233,22 +157,7 @@ private void OnPostFlash(EntityUid uid, HeadRevolutionaryComponent comp, ref Aft
         }
 
         if (mind?.Session != null)
-            _antagSelection.SendBriefing(mind.Session, Loc.GetString("rev-role-greeting"), Color.Red, revComp.RevStartSound);
-    }
-
-    public void OnHeadRevAdmin(EntityUid entity)
-    {
-        if (HasComp<HeadRevolutionaryComponent>(entity))
-            return;
-
-        var revRule = EntityQuery<RevolutionaryRuleComponent>().FirstOrDefault();
-        if (revRule == null)
-        {
-            GameTicker.StartGameRule("Revolutionary", out var ruleEnt);
-            revRule = Comp<RevolutionaryRuleComponent>(ruleEnt);
-        }
-
-        GiveHeadRev(entity, revRule.HeadRevPrototypeId, revRule);
+            _antag.SendBriefing(mind.Session, Loc.GetString("rev-role-greeting"), Color.Red, revComp.RevStartSound);
     }
 
     //TODO: Enemies of the revolution
@@ -309,7 +218,7 @@ private bool CheckRevsLose()
                 _popup.PopupEntity(Loc.GetString("rev-break-control", ("name", Identity.Entity(uid, EntityManager))), uid);
                 _adminLogManager.Add(LogType.Mind, LogImpact.Medium, $"{ToPrettyString(uid)} was deconverted due to all Head Revolutionaries dying.");
 
-                if (!_mind.TryGetMind(uid, out var mindId, out var mind, mc))
+                if (!_mind.TryGetMind(uid, out var mindId, out _, mc))
                     continue;
 
                 // remove their antag role
diff --git a/Content.Server/GameTicking/Rules/RoundstartStationVariationRuleSystem.cs b/Content.Server/GameTicking/Rules/RoundstartStationVariationRuleSystem.cs
index 7755f684be2..f09ed3ebc3c 100644
--- a/Content.Server/GameTicking/Rules/RoundstartStationVariationRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/RoundstartStationVariationRuleSystem.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Shuttles.Systems;
 using Content.Server.Station.Components;
diff --git a/Content.Server/GameTicking/Rules/SandboxRuleSystem.cs b/Content.Server/GameTicking/Rules/SandboxRuleSystem.cs
index a26a2d783c7..c60670a3ad7 100644
--- a/Content.Server/GameTicking/Rules/SandboxRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/SandboxRuleSystem.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Sandbox;
 
diff --git a/Content.Server/GameTicking/Rules/SecretRuleSystem.cs b/Content.Server/GameTicking/Rules/SecretRuleSystem.cs
index fa5f17b4f37..95bf5986a5a 100644
--- a/Content.Server/GameTicking/Rules/SecretRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/SecretRuleSystem.cs
@@ -1,14 +1,17 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Content.Server.Administration.Logs;
+using Content.Server.GameTicking.Components;
 using Content.Server.Chat.Managers;
 using Content.Server.GameTicking.Presets;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Shared.Random;
-using Content.Shared.Random.Helpers;
 using Content.Shared.CCVar;
 using Content.Shared.Database;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using Robust.Shared.Configuration;
+using Robust.Shared.Utility;
 
 namespace Content.Server.GameTicking.Rules;
 
@@ -19,11 +22,46 @@ public sealed class SecretRuleSystem : GameRuleSystem<SecretRuleComponent>
     [Dependency] private readonly IConfigurationManager _configurationManager = default!;
     [Dependency] private readonly IAdminLogManager _adminLogger = default!;
     [Dependency] private readonly IChatManager _chatManager = default!;
+    [Dependency] private readonly IComponentFactory _compFact = default!;
+
+    private string _ruleCompName = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _ruleCompName = _compFact.GetComponentName(typeof(GameRuleComponent));
+    }
 
     protected override void Added(EntityUid uid, SecretRuleComponent component, GameRuleComponent gameRule, GameRuleAddedEvent args)
     {
         base.Added(uid, component, gameRule, args);
-        PickRule(component);
+        var weights = _configurationManager.GetCVar(CCVars.SecretWeightPrototype);
+
+        if (!TryPickPreset(weights, out var preset))
+        {
+            Log.Error($"{ToPrettyString(uid)} failed to pick any preset. Removing rule.");
+            Del(uid);
+            return;
+        }
+
+        Log.Info($"Selected {preset.ID} as the secret preset.");
+        _adminLogger.Add(LogType.EventStarted, $"Selected {preset.ID} as the secret preset.");
+        _chatManager.SendAdminAnnouncement(Loc.GetString("rule-secret-selected-preset", ("preset", preset.ID)));
+
+        foreach (var rule in preset.Rules)
+        {
+            EntityUid ruleEnt;
+
+            // if we're pre-round (i.e. will only be added)
+            // then just add rules. if we're added in the middle of the round (or at any other point really)
+            // then we want to start them as well
+            if (GameTicker.RunLevel <= GameRunLevel.InRound)
+                ruleEnt = GameTicker.AddGameRule(rule);
+            else
+                GameTicker.StartGameRule(rule, out ruleEnt);
+
+            component.AdditionalGameRules.Add(ruleEnt);
+        }
     }
 
     protected override void Ended(EntityUid uid, SecretRuleComponent component, GameRuleComponent gameRule, GameRuleEndedEvent args)
@@ -36,32 +74,101 @@ protected override void Ended(EntityUid uid, SecretRuleComponent component, Game
         }
     }
 
-    private void PickRule(SecretRuleComponent component)
+    private bool TryPickPreset(ProtoId<WeightedRandomPrototype> weights, [NotNullWhen(true)] out GamePresetPrototype? preset)
     {
-        // TODO: This doesn't consider what can't start due to minimum player count,
-        // but currently there's no way to know anyway as they use cvars.
-        var presetString = _configurationManager.GetCVar(CCVars.SecretWeightPrototype);
-        var preset = _prototypeManager.Index<WeightedRandomPrototype>(presetString).Pick(_random);
-        Log.Info($"Selected {preset} for secret.");
-        _adminLogger.Add(LogType.EventStarted, $"Selected {preset} for secret.");
-        _chatManager.SendAdminAnnouncement(Loc.GetString("rule-secret-selected-preset", ("preset", preset)));
-
-        var rules = _prototypeManager.Index<GamePresetPrototype>(preset).Rules;
-        foreach (var rule in rules)
+        var options = _prototypeManager.Index(weights).Weights.ShallowClone();
+        var players = GameTicker.ReadyPlayerCount();
+
+        GamePresetPrototype? selectedPreset = null;
+        var sum = options.Values.Sum();
+        while (options.Count > 0)
         {
-            EntityUid ruleEnt;
+            var accumulated = 0f;
+            var rand = _random.NextFloat(sum);
+            foreach (var (key, weight) in options)
+            {
+                accumulated += weight;
+                if (accumulated < rand)
+                    continue;
 
-            // if we're pre-round (i.e. will only be added)
-            // then just add rules. if we're added in the middle of the round (or at any other point really)
-            // then we want to start them as well
-            if (GameTicker.RunLevel <= GameRunLevel.InRound)
-                ruleEnt = GameTicker.AddGameRule(rule);
-            else
+                if (!_prototypeManager.TryIndex(key, out selectedPreset))
+                    Log.Error($"Invalid preset {selectedPreset} in secret rule weights: {weights}");
+
+                options.Remove(key);
+                sum -= weight;
+                break;
+            }
+
+            if (CanPick(selectedPreset, players))
             {
-                GameTicker.StartGameRule(rule, out ruleEnt);
+                preset = selectedPreset;
+                return true;
             }
 
-            component.AdditionalGameRules.Add(ruleEnt);
+            if (selectedPreset != null)
+                Log.Info($"Excluding {selectedPreset.ID} from secret preset selection.");
+        }
+
+        preset = null;
+        return false;
+    }
+
+    public bool CanPickAny()
+    {
+        var secretPresetId = _configurationManager.GetCVar(CCVars.SecretWeightPrototype);
+        return CanPickAny(secretPresetId);
+    }
+
+    /// <summary>
+    /// Can any of the given presets be picked, taking into account the currently available player count?
+    /// </summary>
+    public bool CanPickAny(ProtoId<WeightedRandomPrototype> weightedPresets)
+    {
+        var ids = _prototypeManager.Index(weightedPresets).Weights.Keys
+            .Select(x => new ProtoId<GamePresetPrototype>(x));
+
+        return CanPickAny(ids);
+    }
+
+    /// <summary>
+    /// Can any of the given presets be picked, taking into account the currently available player count?
+    /// </summary>
+    public bool CanPickAny(IEnumerable<ProtoId<GamePresetPrototype>> protos)
+    {
+        var players = GameTicker.ReadyPlayerCount();
+        foreach (var id in protos)
+        {
+            if (!_prototypeManager.TryIndex(id, out var selectedPreset))
+                Log.Error($"Invalid preset {selectedPreset} in secret rule weights: {id}");
+
+            if (CanPick(selectedPreset, players))
+                return true;
         }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Can the given preset be picked, taking into account the currently available player count?
+    /// </summary>
+    private bool CanPick([NotNullWhen(true)] GamePresetPrototype? selected, int players)
+    {
+        if (selected == null)
+            return false;
+
+        foreach (var ruleId in selected.Rules)
+        {
+            if (!_prototypeManager.TryIndex(ruleId, out EntityPrototype? rule)
+                || !rule.TryGetComponent(_ruleCompName, out GameRuleComponent? ruleComp))
+            {
+                Log.Error($"Encountered invalid rule {ruleId} in preset {selected.ID}");
+                return false;
+            }
+
+            if (ruleComp.MinPlayers > players)
+                return false;
+        }
+
+        return true;
     }
 }
diff --git a/Content.Server/GameTicking/Rules/SubGamemodesSystem.cs b/Content.Server/GameTicking/Rules/SubGamemodesSystem.cs
index 42e7e82335c..4486ee40fbb 100644
--- a/Content.Server/GameTicking/Rules/SubGamemodesSystem.cs
+++ b/Content.Server/GameTicking/Rules/SubGamemodesSystem.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Shared.Storage;
 
diff --git a/Content.Server/GameTicking/Rules/ThiefRuleSystem.cs b/Content.Server/GameTicking/Rules/ThiefRuleSystem.cs
index 32f9040f89f..083085fa0d8 100644
--- a/Content.Server/GameTicking/Rules/ThiefRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/ThiefRuleSystem.cs
@@ -3,118 +3,38 @@
 using Content.Server.Mind;
 using Content.Server.Objectives;
 using Content.Server.Roles;
-using Content.Shared.Antag;
-using Content.Shared.CombatMode.Pacification;
 using Content.Shared.Humanoid;
-using Content.Shared.Inventory;
 using Content.Shared.Mind;
 using Content.Shared.Objectives.Components;
-using Content.Shared.Roles;
 using Robust.Shared.Random;
-using System.Linq;
 
 namespace Content.Server.GameTicking.Rules;
 
 public sealed class ThiefRuleSystem : GameRuleSystem<ThiefRuleComponent>
 {
     [Dependency] private readonly IRobustRandom _random = default!;
-    [Dependency] private readonly AntagSelectionSystem _antagSelection = default!;
     [Dependency] private readonly MindSystem _mindSystem = default!;
-    [Dependency] private readonly SharedRoleSystem _roleSystem = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
     [Dependency] private readonly ObjectivesSystem _objectives = default!;
-    [Dependency] private readonly InventorySystem _inventory = default!;
 
     public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<RulePlayerJobsAssignedEvent>(OnPlayersSpawned);
+        SubscribeLocalEvent<ThiefRuleComponent, AfterAntagEntitySelectedEvent>(AfterAntagSelected);
 
         SubscribeLocalEvent<ThiefRoleComponent, GetBriefingEvent>(OnGetBriefing);
         SubscribeLocalEvent<ThiefRuleComponent, ObjectivesTextGetInfoEvent>(OnObjectivesTextGetInfo);
     }
 
-    private void OnPlayersSpawned(RulePlayerJobsAssignedEvent ev)
+    private void AfterAntagSelected(Entity<ThiefRuleComponent> ent, ref AfterAntagEntitySelectedEvent args)
     {
-        var query = QueryActiveRules();
-        while (query.MoveNext(out var uid, out _, out var comp, out var gameRule))
-        {
-            //Get all players eligible for this role, allow selecting existing antags
-            //TO DO: When voxes specifies are added, increase their chance of becoming a thief by 4 times >:)
-            var eligiblePlayers = _antagSelection.GetEligiblePlayers(ev.Players, comp.ThiefPrototypeId, acceptableAntags: AntagAcceptability.All, allowNonHumanoids: true);
-
-            //Abort if there are none
-            if (eligiblePlayers.Count == 0)
-            {
-                Log.Warning($"No eligible thieves found, ending game rule {ToPrettyString(uid):rule}");
-                GameTicker.EndGameRule(uid, gameRule);
-                continue;
-            }
-
-            //Calculate number of thieves to choose
-            var thiefCount = _random.Next(1, comp.MaxAllowThief + 1);
-
-            //Select our theives
-            var thieves = _antagSelection.ChooseAntags(thiefCount, eligiblePlayers);
-
-            MakeThief(thieves, comp, comp.PacifistThieves);
-        }
-    }
-
-    public void MakeThief(List<EntityUid> players, ThiefRuleComponent thiefRule, bool addPacified)
-    {
-        foreach (var thief in players)
-        {
-            MakeThief(thief, thiefRule, addPacified);
-        }
-    }
-
-    public void MakeThief(EntityUid thief, ThiefRuleComponent thiefRule, bool addPacified)
-    {
-        if (!_mindSystem.TryGetMind(thief, out var mindId, out var mind))
+        if (!_mindSystem.TryGetMind(args.EntityUid, out var mindId, out var mind))
             return;
 
-        if (HasComp<ThiefRoleComponent>(mindId))
-            return;
-
-        // Assign thief roles
-        _roleSystem.MindAddRole(mindId, new ThiefRoleComponent
-        {
-            PrototypeId = thiefRule.ThiefPrototypeId,
-        }, silent: true);
-
-        //Add Pacified  
-        //To Do: Long-term this should just be using the antag code to add components.
-        if (addPacified) //This check is important because some servers may want to disable the thief's pacifism. Do not remove.
-        {
-            EnsureComp<PacifiedComponent>(thief);
-        }
-
         //Generate objectives
-        GenerateObjectives(mindId, mind, thiefRule);
-
-        //Send briefing here to account for humanoid/animal
-        _antagSelection.SendBriefing(thief, MakeBriefing(thief), null, thiefRule.GreetingSound);
-
-        // Give starting items
-        _inventory.SpawnItemsOnEntity(thief, thiefRule.StarterItems);
-
-        thiefRule.ThievesMinds.Add(mindId);
-    }
-
-    public void AdminMakeThief(EntityUid entity, bool addPacified)
-    {
-        var thiefRule = EntityQuery<ThiefRuleComponent>().FirstOrDefault();
-        if (thiefRule == null)
-        {
-            GameTicker.StartGameRule("Thief", out var ruleEntity);
-            thiefRule = Comp<ThiefRuleComponent>(ruleEntity);
-        }
-
-        if (HasComp<ThiefRoleComponent>(entity))
-            return;
-
-        MakeThief(entity, thiefRule, addPacified);
+        GenerateObjectives(mindId, mind, ent);
+        _antag.SendBriefing(args.EntityUid, MakeBriefing(args.EntityUid), null, null);
     }
 
     private void GenerateObjectives(EntityUid mindId, MindComponent mind, ThiefRuleComponent thiefRule)
@@ -160,8 +80,7 @@ private void OnGetBriefing(Entity<ThiefRoleComponent> thief, ref GetBriefingEven
     private string MakeBriefing(EntityUid thief)
     {
         var isHuman = HasComp<HumanoidAppearanceComponent>(thief);
-        var briefing = "\n";
-        briefing = isHuman
+        var briefing = isHuman
             ? Loc.GetString("thief-role-greeting-human")
             : Loc.GetString("thief-role-greeting-animal");
 
@@ -169,9 +88,9 @@ private string MakeBriefing(EntityUid thief)
         return briefing;
     }
 
-    private void OnObjectivesTextGetInfo(Entity<ThiefRuleComponent> thiefs, ref ObjectivesTextGetInfoEvent args)
+    private void OnObjectivesTextGetInfo(Entity<ThiefRuleComponent> ent, ref ObjectivesTextGetInfoEvent args)
     {
-        args.Minds = thiefs.Comp.ThievesMinds;
+        args.Minds = _antag.GetAntagMindEntityUids(ent.Owner);
         args.AgentName = Loc.GetString("thief-round-end-agent-name");
     }
 }
diff --git a/Content.Server/GameTicking/Rules/TraitorRuleSystem.cs b/Content.Server/GameTicking/Rules/TraitorRuleSystem.cs
index a6f8522346f..aff49510d9f 100644
--- a/Content.Server/GameTicking/Rules/TraitorRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/TraitorRuleSystem.cs
@@ -6,97 +6,62 @@
 using Content.Server.PDA.Ringer;
 using Content.Server.Roles;
 using Content.Server.Traitor.Uplink;
-using Content.Shared.CCVar;
-using Content.Shared.Dataset;
 using Content.Shared.Mind;
-using Content.Shared.Mobs.Systems;
 using Content.Shared.Objectives.Components;
 using Content.Shared.PDA;
 using Content.Shared.Roles;
 using Content.Shared.Roles.Jobs;
-using Robust.Server.Player;
-using Robust.Shared.Configuration;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
-using Robust.Shared.Timing;
 using System.Linq;
 using System.Text;
 using Content.Shared.Mood;
+using Content.Server.GameTicking.Components;
+using Content.Server.Traitor.Components;
 
 namespace Content.Server.GameTicking.Rules;
 
 public sealed class TraitorRuleSystem : GameRuleSystem<TraitorRuleComponent>
 {
-    [Dependency] private readonly AntagSelectionSystem _antagSelection = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly IRobustRandom _random = default!;
-    [Dependency] private readonly IConfigurationManager _cfg = default!;
-    [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly NpcFactionSystem _npcFaction = default!;
-    [Dependency] private readonly MobStateSystem _mobStateSystem = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
     [Dependency] private readonly UplinkSystem _uplink = default!;
     [Dependency] private readonly MindSystem _mindSystem = default!;
     [Dependency] private readonly SharedRoleSystem _roleSystem = default!;
     [Dependency] private readonly SharedJobSystem _jobs = default!;
     [Dependency] private readonly ObjectivesSystem _objectives = default!;
-    [Dependency] private readonly IGameTiming _timing = default!;
 
-    private int PlayersPerTraitor => _cfg.GetCVar(CCVars.TraitorPlayersPerTraitor);
-    private int MaxTraitors => _cfg.GetCVar(CCVars.TraitorMaxTraitors);
+    public const int MaxPicks = 20;
 
     public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<RoundStartAttemptEvent>(OnStartAttempt);
-        SubscribeLocalEvent<RulePlayerJobsAssignedEvent>(OnPlayersSpawned);
-        SubscribeLocalEvent<PlayerSpawnCompleteEvent>(HandleLatejoin);
+        SubscribeLocalEvent<TraitorRuleComponent, AfterAntagEntitySelectedEvent>(AfterEntitySelected);
 
         SubscribeLocalEvent<TraitorRuleComponent, ObjectivesTextGetInfoEvent>(OnObjectivesTextGetInfo);
         SubscribeLocalEvent<TraitorRuleComponent, ObjectivesTextPrependEvent>(OnObjectivesTextPrepend);
     }
 
-    //Set min players on game rule
     protected override void Added(EntityUid uid, TraitorRuleComponent component, GameRuleComponent gameRule, GameRuleAddedEvent args)
     {
         base.Added(uid, component, gameRule, args);
-
-        gameRule.MinPlayers = _cfg.GetCVar(CCVars.TraitorMinPlayers);
-    }
-
-    protected override void Started(EntityUid uid, TraitorRuleComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
-    {
-        base.Started(uid, component, gameRule, args);
         MakeCodewords(component);
     }
 
-    protected override void ActiveTick(EntityUid uid, TraitorRuleComponent component, GameRuleComponent gameRule, float frameTime)
-    {
-        base.ActiveTick(uid, component, gameRule, frameTime);
-
-        if (component.SelectionStatus < TraitorRuleComponent.SelectionState.Started && component.AnnounceAt < _timing.CurTime)
-        {
-            DoTraitorStart(component);
-            component.SelectionStatus = TraitorRuleComponent.SelectionState.Started;
-        }
-    }
-
-    /// <summary>
-    /// Check for enough players
-    /// </summary>
-    /// <param name="ev"></param>
-    private void OnStartAttempt(RoundStartAttemptEvent ev)
+    private void AfterEntitySelected(Entity<TraitorRuleComponent> ent, ref AfterAntagEntitySelectedEvent args)
     {
-        TryRoundStartAttempt(ev, Loc.GetString("traitor-title"));
+        MakeTraitor(args.EntityUid, ent);
     }
 
     private void MakeCodewords(TraitorRuleComponent component)
     {
-        var codewordCount = _cfg.GetCVar(CCVars.TraitorCodewordCount);
-        var adjectives = _prototypeManager.Index<DatasetPrototype>(component.CodewordAdjectives).Values;
-        var verbs = _prototypeManager.Index<DatasetPrototype>(component.CodewordVerbs).Values;
+        var adjectives = _prototypeManager.Index(component.CodewordAdjectives).Values;
+        var verbs = _prototypeManager.Index(component.CodewordVerbs).Values;
         var codewordPool = adjectives.Concat(verbs).ToList();
-        var finalCodewordCount = Math.Min(codewordCount, codewordPool.Count);
+        var finalCodewordCount = Math.Min(component.CodewordCount, codewordPool.Count);
         component.Codewords = new string[finalCodewordCount];
         for (var i = 0; i < finalCodewordCount; i++)
         {
@@ -104,66 +69,25 @@ private void MakeCodewords(TraitorRuleComponent component)
         }
     }
 
-    private void DoTraitorStart(TraitorRuleComponent component)
-    {
-        var eligiblePlayers = _antagSelection.GetEligiblePlayers(_playerManager.Sessions, component.TraitorPrototypeId);
-
-        if (eligiblePlayers.Count == 0)
-            return;
-
-        var traitorsToSelect = _antagSelection.CalculateAntagCount(_playerManager.PlayerCount, PlayersPerTraitor, MaxTraitors);
-
-        var selectedTraitors = _antagSelection.ChooseAntags(traitorsToSelect, eligiblePlayers);
-
-        MakeTraitor(selectedTraitors, component);
-    }
-
-    private void OnPlayersSpawned(RulePlayerJobsAssignedEvent ev)
-    {
-        //Start the timer
-        var query = QueryActiveRules();
-        while (query.MoveNext(out _, out var comp, out var gameRuleComponent))
-        {
-            var delay = TimeSpan.FromSeconds(
-                _cfg.GetCVar(CCVars.TraitorStartDelay) +
-                _random.NextFloat(0f, _cfg.GetCVar(CCVars.TraitorStartDelayVariance)));
-
-            //Set the delay for choosing traitors
-            comp.AnnounceAt = _timing.CurTime + delay;
-
-            comp.SelectionStatus = TraitorRuleComponent.SelectionState.ReadyToStart;
-        }
-    }
-
-    public bool MakeTraitor(List<EntityUid> traitors, TraitorRuleComponent component, bool giveUplink = true, bool giveObjectives = true)
-    {
-        foreach (var traitor in traitors)
-        {
-            MakeTraitor(traitor, component, giveUplink, giveObjectives);
-        }
-
-        return true;
-    }
-
     public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component, bool giveUplink = true, bool giveObjectives = true)
     {
         //Grab the mind if it wasnt provided
         if (!_mindSystem.TryGetMind(traitor, out var mindId, out var mind))
             return false;
 
-        if (HasComp<TraitorRoleComponent>(mindId))
+        var briefing = Loc.GetString("traitor-role-codewords-short", ("codewords", string.Join(", ", component.Codewords)));
+
+        if (TryComp<AutoTraitorComponent>(traitor, out var autoTraitorComponent))
         {
-            Log.Error($"Player {mind.CharacterName} is already a traitor.");
-            return false;
+            giveUplink = autoTraitorComponent.GiveUplink;
+            giveObjectives = autoTraitorComponent.GiveObjectives;
         }
 
-        var briefing = Loc.GetString("traitor-role-codewords-short", ("codewords", string.Join(", ", component.Codewords)));
-
         Note[]? code = null;
         if (giveUplink)
         {
             // Calculate the amount of currency on the uplink.
-            var startingBalance = _cfg.GetCVar(CCVars.TraitorStartingBalance);
+            var startingBalance = component.StartingBalance;
             if (_jobs.MindTryGetJob(mindId, out _, out var prototype))
                 startingBalance = Math.Max(startingBalance - prototype.AntagAdvantage, 0);
 
@@ -181,19 +105,14 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component, bool
                 Loc.GetString("traitor-role-uplink-code-short", ("code", string.Join("-", code).Replace("sharp", "#"))));
         }
 
-        _antagSelection.SendBriefing(traitor, GenerateBriefing(component.Codewords, code), null, component.GreetSoundNotification);
+        _antag.SendBriefing(traitor, GenerateBriefing(component.Codewords, code), null, component.GreetSoundNotification);
 
         component.TraitorMinds.Add(mindId);
 
-        // Assign traitor roles
-        _roleSystem.MindAddRole(mindId, new TraitorRoleComponent
-        {
-            PrototypeId = component.TraitorPrototypeId
-        }, mind, true);
         // Assign briefing
         _roleSystem.MindAddRole(mindId, new RoleBriefingComponent
         {
-            Briefing = briefing.ToString()
+            Briefing = briefing
         }, mind, true);
 
         // Change the faction
@@ -205,11 +124,8 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component, bool
         // Give traitors their objectives
         if (giveObjectives)
         {
-            var maxDifficulty = _cfg.GetCVar(CCVars.TraitorMaxDifficulty);
-            var maxPicks = _cfg.GetCVar(CCVars.TraitorMaxPicks);
             var difficulty = 0f;
-            Log.Debug($"Attempting {maxPicks} objective picks with {maxDifficulty} difficulty");
-            for (var pick = 0; pick < maxPicks && maxDifficulty > difficulty; pick++)
+            for (var pick = 0; pick < MaxPicks && component.MaxDifficulty > difficulty; pick++)
             {
                 var objective = _objectives.GetRandomObjective(mindId, mind, component.ObjectiveGroup);
                 if (objective == null)
@@ -225,53 +141,9 @@ public bool MakeTraitor(EntityUid traitor, TraitorRuleComponent component, bool
         return true;
     }
 
-    private void HandleLatejoin(PlayerSpawnCompleteEvent ev)
-    {
-        var query = QueryActiveRules();
-        while (query.MoveNext(out _, out var comp, out _))
-        {
-            if (comp.TotalTraitors >= MaxTraitors)
-                continue;
-
-            if (!ev.LateJoin)
-                continue;
-
-            if (!_antagSelection.IsPlayerEligible(ev.Player, comp.TraitorPrototypeId))
-                continue;
-
-            //If its before we have selected traitors, continue
-            if (comp.SelectionStatus < TraitorRuleComponent.SelectionState.Started)
-                continue;
-
-            // the nth player we adjust our probabilities around
-            var target = PlayersPerTraitor * comp.TotalTraitors + 1;
-            var chance = 1f / PlayersPerTraitor;
-
-            // If we have too many traitors, divide by how many players below target for next traitor we are.
-            if (ev.JoinOrder < target)
-            {
-                chance /= (target - ev.JoinOrder);
-            }
-            else // Tick up towards 100% chance.
-            {
-                chance *= ((ev.JoinOrder + 1) - target);
-            }
-
-            if (chance > 1)
-                chance = 1;
-
-            // Now that we've calculated our chance, roll and make them a traitor if we roll under.
-            // You get one shot.
-            if (_random.Prob(chance))
-            {
-                MakeTraitor(ev.Mob, comp);
-            }
-        }
-    }
-
     private void OnObjectivesTextGetInfo(EntityUid uid, TraitorRuleComponent comp, ref ObjectivesTextGetInfoEvent args)
     {
-        args.Minds = comp.TraitorMinds;
+        args.Minds = _antag.GetAntagMindEntityUids(uid);
         args.AgentName = Loc.GetString("traitor-round-end-agent-name");
     }
 
@@ -280,27 +152,6 @@ private void OnObjectivesTextPrepend(EntityUid uid, TraitorRuleComponent comp, r
         args.Text += "\n" + Loc.GetString("traitor-round-end-codewords", ("codewords", string.Join(", ", comp.Codewords)));
     }
 
-    /// <summary>
-    /// Start this game rule manually
-    /// </summary>
-    public TraitorRuleComponent StartGameRule()
-    {
-        var comp = EntityQuery<TraitorRuleComponent>().FirstOrDefault();
-        if (comp == null)
-        {
-            GameTicker.StartGameRule("Traitor", out var ruleEntity);
-            comp = Comp<TraitorRuleComponent>(ruleEntity);
-        }
-
-        return comp;
-    }
-
-    public void MakeTraitorAdmin(EntityUid entity, bool giveUplink, bool giveObjectives)
-    {
-        var traitorRule = StartGameRule();
-        MakeTraitor(entity, traitorRule, giveUplink, giveObjectives);
-    }
-
     private string GenerateBriefing(string[] codewords, Note[]? uplinkCode)
     {
         var sb = new StringBuilder();
@@ -315,9 +166,11 @@ private string GenerateBriefing(string[] codewords, Note[]? uplinkCode)
     public List<(EntityUid Id, MindComponent Mind)> GetOtherTraitorMindsAliveAndConnected(MindComponent ourMind)
     {
         List<(EntityUid Id, MindComponent Mind)> allTraitors = new();
-        foreach (var traitor in EntityQuery<TraitorRuleComponent>())
+
+        var query = EntityQueryEnumerator<TraitorRuleComponent>();
+        while (query.MoveNext(out var uid, out var traitor))
         {
-            foreach (var role in GetOtherTraitorMindsAliveAndConnected(ourMind, traitor))
+            foreach (var role in GetOtherTraitorMindsAliveAndConnected(ourMind, (uid, traitor)))
             {
                 if (!allTraitors.Contains(role))
                     allTraitors.Add(role);
@@ -327,20 +180,15 @@ private string GenerateBriefing(string[] codewords, Note[]? uplinkCode)
         return allTraitors;
     }
 
-    private List<(EntityUid Id, MindComponent Mind)> GetOtherTraitorMindsAliveAndConnected(MindComponent ourMind, TraitorRuleComponent component)
+    private List<(EntityUid Id, MindComponent Mind)> GetOtherTraitorMindsAliveAndConnected(MindComponent ourMind, Entity<TraitorRuleComponent> rule)
     {
         var traitors = new List<(EntityUid Id, MindComponent Mind)>();
-        foreach (var traitor in component.TraitorMinds)
+        foreach (var mind in _antag.GetAntagMinds(rule.Owner))
         {
-            if (TryComp(traitor, out MindComponent? mind) &&
-                mind.OwnedEntity != null &&
-                mind.Session != null &&
-                mind != ourMind &&
-                _mobStateSystem.IsAlive(mind.OwnedEntity.Value) &&
-                mind.CurrentEntity == mind.OwnedEntity)
-            {
-                traitors.Add((traitor, mind));
-            }
+            if (mind.Comp == ourMind)
+                continue;
+
+            traitors.Add((mind, mind));
         }
 
         return traitors;
diff --git a/Content.Server/GameTicking/Rules/ZombieRuleSystem.cs b/Content.Server/GameTicking/Rules/ZombieRuleSystem.cs
index 5714337d4db..f62d0b79ffb 100644
--- a/Content.Server/GameTicking/Rules/ZombieRuleSystem.cs
+++ b/Content.Server/GameTicking/Rules/ZombieRuleSystem.cs
@@ -1,46 +1,35 @@
-using Content.Server.Actions;
 using Content.Server.Antag;
 using Content.Server.Chat.Systems;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Popups;
-using Content.Server.Roles;
 using Content.Server.RoundEnd;
 using Content.Server.Station.Components;
 using Content.Server.Station.Systems;
 using Content.Server.Zombies;
-using Content.Shared.CCVar;
 using Content.Shared.Humanoid;
 using Content.Shared.Mind;
 using Content.Shared.Mobs;
 using Content.Shared.Mobs.Components;
 using Content.Shared.Mobs.Systems;
-using Content.Shared.Roles;
 using Content.Shared.Zombies;
-using Robust.Server.Player;
-using Robust.Shared.Configuration;
 using Robust.Shared.Player;
-using Robust.Shared.Random;
 using Robust.Shared.Timing;
 using System.Globalization;
 using Content.Server.Announcements.Systems;
+using Content.Server.GameTicking.Components;
 
 namespace Content.Server.GameTicking.Rules;
 
 public sealed class ZombieRuleSystem : GameRuleSystem<ZombieRuleComponent>
 {
-    [Dependency] private readonly IRobustRandom _random = default!;
-    [Dependency] private readonly IConfigurationManager _cfg = default!;
-    [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly ChatSystem _chat = default!;
     [Dependency] private readonly RoundEndSystem _roundEnd = default!;
     [Dependency] private readonly PopupSystem _popup = default!;
-    [Dependency] private readonly ActionsSystem _action = default!;
     [Dependency] private readonly MobStateSystem _mobState = default!;
     [Dependency] private readonly ZombieSystem _zombie = default!;
     [Dependency] private readonly SharedMindSystem _mindSystem = default!;
-    [Dependency] private readonly SharedRoleSystem _roles = default!;
     [Dependency] private readonly StationSystem _station = default!;
-    [Dependency] private readonly AntagSelectionSystem _antagSelection = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
     [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly AnnouncerSystem _announcer = default!;
     [Dependency] private readonly GameTicker _gameTicker = default!;
@@ -49,67 +38,56 @@ public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<RoundStartAttemptEvent>(OnStartAttempt);
-        SubscribeLocalEvent<RoundEndTextAppendEvent>(OnRoundEndText);
         SubscribeLocalEvent<PendingZombieComponent, ZombifySelfActionEvent>(OnZombifySelf);
     }
 
-    /// <summary>
-    /// Set the required minimum players for this gamemode to start
-    /// </summary>
-    protected override void Added(EntityUid uid, ZombieRuleComponent component, GameRuleComponent gameRule, GameRuleAddedEvent args)
+    protected override void AppendRoundEndText(EntityUid uid, ZombieRuleComponent component, GameRuleComponent gameRule,
+        ref RoundEndTextAppendEvent args)
     {
-        base.Added(uid, component, gameRule, args);
-
-        gameRule.MinPlayers = _cfg.GetCVar(CCVars.ZombieMinPlayers);
-    }
-
-    private void OnRoundEndText(RoundEndTextAppendEvent ev)
-    {
-        foreach (var zombie in EntityQuery<ZombieRuleComponent>())
+        base.AppendRoundEndText(uid, component, gameRule, ref args);
+
+        // This is just the general condition thing used for determining the win/lose text
+        var fraction = GetInfectedFraction(true, true);
+
+        if (fraction <= 0)
+            args.AddLine(Loc.GetString("zombie-round-end-amount-none"));
+        else if (fraction <= 0.25)
+            args.AddLine(Loc.GetString("zombie-round-end-amount-low"));
+        else if (fraction <= 0.5)
+            args.AddLine(Loc.GetString("zombie-round-end-amount-medium", ("percent", Math.Round((fraction * 100), 2).ToString(CultureInfo.InvariantCulture))));
+        else if (fraction < 1)
+            args.AddLine(Loc.GetString("zombie-round-end-amount-high", ("percent", Math.Round((fraction * 100), 2).ToString(CultureInfo.InvariantCulture))));
+        else
+            args.AddLine(Loc.GetString("zombie-round-end-amount-all"));
+
+        var antags = _antag.GetAntagIdentifiers(uid);
+        args.AddLine(Loc.GetString("zombie-round-end-initial-count", ("initialCount", antags.Count)));
+        foreach (var (_, data, entName) in antags)
         {
-            // This is just the general condition thing used for determining the win/lose text
-            var fraction = GetInfectedFraction(true, true);
-
-            if (fraction <= 0)
-                ev.AddLine(Loc.GetString("zombie-round-end-amount-none"));
-            else if (fraction <= 0.25)
-                ev.AddLine(Loc.GetString("zombie-round-end-amount-low"));
-            else if (fraction <= 0.5)
-                ev.AddLine(Loc.GetString("zombie-round-end-amount-medium", ("percent", Math.Round((fraction * 100), 2).ToString(CultureInfo.InvariantCulture))));
-            else if (fraction < 1)
-                ev.AddLine(Loc.GetString("zombie-round-end-amount-high", ("percent", Math.Round((fraction * 100), 2).ToString(CultureInfo.InvariantCulture))));
-            else
-                ev.AddLine(Loc.GetString("zombie-round-end-amount-all"));
+            args.AddLine(Loc.GetString("zombie-round-end-user-was-initial",
+                ("name", entName),
+                ("username", data.UserName)));
+        }
 
-            ev.AddLine(Loc.GetString("zombie-round-end-initial-count", ("initialCount", zombie.InitialInfectedNames.Count)));
-            foreach (var player in zombie.InitialInfectedNames)
+        var healthy = GetHealthyHumans();
+        // Gets a bunch of the living players and displays them if they're under a threshold.
+        // InitialInfected is used for the threshold because it scales with the player count well.
+        if (healthy.Count <= 0 || healthy.Count > 2 * antags.Count)
+            return;
+        args.AddLine("");
+        args.AddLine(Loc.GetString("zombie-round-end-survivor-count", ("count", healthy.Count)));
+        foreach (var survivor in healthy)
+        {
+            var meta = MetaData(survivor);
+            var username = string.Empty;
+            if (_mindSystem.TryGetMind(survivor, out _, out var mind) && mind.Session != null)
             {
-                ev.AddLine(Loc.GetString("zombie-round-end-user-was-initial",
-                    ("name", player.Key),
-                    ("username", player.Value)));
+                username = mind.Session.Name;
             }
 
-            var healthy = GetHealthyHumans(true);
-            // Gets a bunch of the living players and displays them if they're under a threshold.
-            // InitialInfected is used for the threshold because it scales with the player count well.
-            if (healthy.Count <= 0 || healthy.Count > 2 * zombie.InitialInfectedNames.Count)
-                continue;
-            ev.AddLine("");
-            ev.AddLine(Loc.GetString("zombie-round-end-survivor-count", ("count", healthy.Count)));
-            foreach (var survivor in healthy)
-            {
-                var meta = MetaData(survivor);
-                var username = string.Empty;
-                if (_mindSystem.TryGetMind(survivor, out _, out var mind) && mind.Session != null)
-                {
-                    username = mind.Session.Name;
-                }
-
-                ev.AddLine(Loc.GetString("zombie-round-end-user-was-survivor",
-                    ("name", meta.EntityName),
-                    ("username", username)));
-            }
+            args.AddLine(Loc.GetString("zombie-round-end-user-was-survivor",
+                ("name", meta.EntityName),
+                ("username", username)));
         }
     }
 
@@ -139,38 +117,20 @@ private void CheckRoundEnd(ZombieRuleComponent zombieRuleComponent)
             _roundEnd.EndRound();
     }
 
-    /// <summary>
-    /// Check we have enough players to start this game mode, if not - cancel and announce
-    /// </summary>
-    private void OnStartAttempt(RoundStartAttemptEvent ev)
-    {
-        TryRoundStartAttempt(ev, Loc.GetString("zombie-title"));
-    }
-
     protected override void Started(EntityUid uid, ZombieRuleComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
     {
         base.Started(uid, component, gameRule, args);
 
-        var delay = _random.Next(component.MinStartDelay, component.MaxStartDelay);
-        component.StartTime = _timing.CurTime + delay;
+        component.NextRoundEndCheck = _timing.CurTime + component.EndCheckDelay;
     }
 
     protected override void ActiveTick(EntityUid uid, ZombieRuleComponent component, GameRuleComponent gameRule, float frameTime)
     {
         base.ActiveTick(uid, component, gameRule, frameTime);
-
-        if (component.StartTime.HasValue && component.StartTime < _timing.CurTime)
-        {
-            InfectInitialPlayers(component);
-            component.StartTime = null;
-            component.NextRoundEndCheck = _timing.CurTime + component.EndCheckDelay;
-        }
-
-        if (component.NextRoundEndCheck.HasValue && component.NextRoundEndCheck < _timing.CurTime)
-        {
-            CheckRoundEnd(component);
-            component.NextRoundEndCheck = _timing.CurTime + component.EndCheckDelay;
-        }
+        if (!component.NextRoundEndCheck.HasValue || component.NextRoundEndCheck > _timing.CurTime)
+            return;
+        CheckRoundEnd(component);
+        component.NextRoundEndCheck = _timing.CurTime + component.EndCheckDelay;
     }
 
     private void OnZombifySelf(EntityUid uid, PendingZombieComponent component, ZombifySelfActionEvent args)
@@ -235,81 +195,4 @@ private List<EntityUid> GetHealthyHumans(bool includeOffStation = false)
         }
         return healthy;
     }
-
-    /// <summary>
-    ///     Infects the first players with the passive zombie virus.
-    ///     Also records their names for the end of round screen.
-    /// </summary>
-    /// <remarks>
-    ///     The reason this code is written separately is to facilitate
-    ///     allowing this gamemode to be started midround. As such, it doesn't need
-    ///     any information besides just running.
-    /// </remarks>
-    private void InfectInitialPlayers(ZombieRuleComponent component)
-    {
-        //Get all players with initial infected enabled, and exclude those with the ZombieImmuneComponent and roles with CanBeAntag = False
-        var eligiblePlayers = _antagSelection.GetEligiblePlayers(
-            _playerManager.Sessions,
-            component.PatientZeroPrototypeId,
-            includeAllJobs: false,
-            customExcludeCondition: player => HasComp<ZombieImmuneComponent>(player) || HasComp<InitialInfectedExemptComponent>(player)
-            );
-
-        //And get all players, excluding ZombieImmune and roles with CanBeAntag = False - to fill any leftover initial infected slots
-        var allPlayers = _antagSelection.GetEligiblePlayers(
-            _playerManager.Sessions,
-            component.PatientZeroPrototypeId,
-            acceptableAntags: Shared.Antag.AntagAcceptability.All,
-            includeAllJobs: false ,
-            ignorePreferences: true,
-            customExcludeCondition: HasComp<ZombieImmuneComponent>
-            );
-
-        //If there are no players to choose, abort
-        if (allPlayers.Count == 0)
-            return;
-
-        //How many initial infected should we select
-        var initialInfectedCount = _antagSelection.CalculateAntagCount(_playerManager.PlayerCount, component.PlayersPerInfected, component.MaxInitialInfected);
-
-        //Choose the required number of initial infected from the eligible players, making up any shortfall by choosing from all players
-        var initialInfected = _antagSelection.ChooseAntags(initialInfectedCount, eligiblePlayers, allPlayers);
-
-        //Make brain craving
-        MakeZombie(initialInfected, component);
-
-        //Send the briefing, play greeting sound
-        _antagSelection.SendBriefing(initialInfected, Loc.GetString("zombie-patientzero-role-greeting"), Color.Plum, component.InitialInfectedSound);
-    }
-
-    private void MakeZombie(List<EntityUid> entities, ZombieRuleComponent component)
-    {
-        foreach (var entity in entities)
-        {
-            MakeZombie(entity, component);
-        }
-    }
-    private void MakeZombie(EntityUid entity, ZombieRuleComponent component)
-    {
-        if (!_mindSystem.TryGetMind(entity, out var mind, out var mindComponent))
-            return;
-
-        //Add the role to the mind silently (to avoid repeating job assignment)
-        _roles.MindAddRole(mind, new InitialInfectedRoleComponent { PrototypeId = component.PatientZeroPrototypeId }, silent: true);
-        EnsureComp<InitialInfectedComponent>(entity);
-
-        //Add the zombie components and grace period
-        var pending = EnsureComp<PendingZombieComponent>(entity);
-        pending.GracePeriod = _random.Next(component.MinInitialInfectedGrace, component.MaxInitialInfectedGrace);
-        EnsureComp<ZombifyOnDeathComponent>(entity);
-        EnsureComp<IncurableZombieComponent>(entity);
-
-        //Add the zombify action
-        _action.AddAction(entity, ref pending.Action, component.ZombifySelfActionPrototype, entity);
-
-        //Get names for the round end screen, incase they leave mid-round
-        var inCharacterName = MetaData(entity).EntityName;
-        var accountName = mindComponent.Session == null ? string.Empty : mindComponent.Session.Name;
-        component.InitialInfectedNames.Add(inCharacterName, accountName);
-    }
 }
diff --git a/Content.Server/IoC/ServerContentIoC.cs b/Content.Server/IoC/ServerContentIoC.cs
index fa263e059de..bc399977358 100644
--- a/Content.Server/IoC/ServerContentIoC.cs
+++ b/Content.Server/IoC/ServerContentIoC.cs
@@ -5,10 +5,10 @@
 using Content.Server.Afk;
 using Content.Server.Chat.Managers;
 using Content.Server.Connection;
-using Content.Server.DiscordAuth;
 using Content.Server.JoinQueue;
 using Content.Server.Database;
 using Content.Server.Discord;
+using Content.Server.DiscordAuth;
 using Content.Server.EUI;
 using Content.Server.GhostKick;
 using Content.Server.Info;
diff --git a/Content.Server/Nyanotrasen/StationEvents/Events/MidRoundAntagRule.cs b/Content.Server/Nyanotrasen/StationEvents/Events/MidRoundAntagRule.cs
index 7abbdcdab3b..94a488bd84b 100644
--- a/Content.Server/Nyanotrasen/StationEvents/Events/MidRoundAntagRule.cs
+++ b/Content.Server/Nyanotrasen/StationEvents/Events/MidRoundAntagRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Robust.Shared.Random;
diff --git a/Content.Server/Objectives/ObjectivesSystem.cs b/Content.Server/Objectives/ObjectivesSystem.cs
index 20205b8b72f..47fe4eb5f88 100644
--- a/Content.Server/Objectives/ObjectivesSystem.cs
+++ b/Content.Server/Objectives/ObjectivesSystem.cs
@@ -1,10 +1,7 @@
 using Content.Server.GameTicking;
-using Content.Server.GameTicking.Rules.Components;
-using Content.Server.Mind;
 using Content.Server.Shuttles.Systems;
 using Content.Shared.Cuffs.Components;
 using Content.Shared.Mind;
-using Content.Shared.Mobs.Systems;
 using Content.Shared.Objectives.Components;
 using Content.Shared.Objectives.Systems;
 using Content.Shared.Random;
@@ -12,7 +9,9 @@
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using System.Text;
+using Robust.Server.Player;
 
 namespace Content.Server.Objectives;
 
@@ -20,8 +19,8 @@ public sealed class ObjectivesSystem : SharedObjectivesSystem
 {
     [Dependency] private readonly GameTicker _gameTicker = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
     [Dependency] private readonly IRobustRandom _random = default!;
-    [Dependency] private readonly MindSystem _mind = default!;
     [Dependency] private readonly EmergencyShuttleSystem _emergencyShuttle = default!;
 
     public override void Initialize()
@@ -179,7 +178,9 @@ private void AddSummary(StringBuilder result, string agent, List<EntityUid> mind
                                        .ThenByDescending(x => x.completedObjectives);
 
         foreach (var (summary, _, _) in sortedAgents)
+        {
             result.AppendLine(summary);
+        }
     }
 
     public EntityUid? GetRandomObjective(EntityUid mindId, MindComponent mind, string objectiveGroupProto)
@@ -244,8 +245,14 @@ private bool IsInCustody(EntityUid mindId, MindComponent? mind = null)
             return null;
 
         var name = mind.CharacterName;
-        _mind.TryGetSession(mindId, out var session);
-        var username = session?.Name;
+        var username = (string?) null;
+
+        if (mind.OriginalOwnerUserId != null &&
+            _player.TryGetPlayerData(mind.OriginalOwnerUserId.Value, out var sessionData))
+        {
+            username = sessionData.UserName;
+        }
+
 
         if (username != null)
         {
diff --git a/Content.Server/Power/EntitySystems/PowerMonitoringConsoleSystem.cs b/Content.Server/Power/EntitySystems/PowerMonitoringConsoleSystem.cs
index 107d09c8980..0e20f007d71 100644
--- a/Content.Server/Power/EntitySystems/PowerMonitoringConsoleSystem.cs
+++ b/Content.Server/Power/EntitySystems/PowerMonitoringConsoleSystem.cs
@@ -17,6 +17,7 @@
 using Robust.Shared.Utility;
 using System.Linq;
 using System.Diagnostics.CodeAnalysis;
+using Content.Server.GameTicking.Components;
 
 namespace Content.Server.Power.EntitySystems;
 
@@ -723,8 +724,8 @@ private void GetLoadsForNode(EntityUid uid, Node node, out List<PowerMonitoringC
         }
     }
 
-    // Designates a supplied entity as a 'collection master'. Other entities which share this 
-    // entities collection name and are attached on the same load network are assigned this entity 
+    // Designates a supplied entity as a 'collection master'. Other entities which share this
+    // entities collection name and are attached on the same load network are assigned this entity
     // as the master that represents them on the console UI. This way you can have one device
     // represent multiple connected devices
     private void AssignEntityAsCollectionMaster
diff --git a/Content.Server/Preferences/Managers/IServerPreferencesManager.cs b/Content.Server/Preferences/Managers/IServerPreferencesManager.cs
index a36b053717f..f26c998495f 100644
--- a/Content.Server/Preferences/Managers/IServerPreferencesManager.cs
+++ b/Content.Server/Preferences/Managers/IServerPreferencesManager.cs
@@ -16,7 +16,10 @@ public interface IServerPreferencesManager
 
         bool TryGetCachedPreferences(NetUserId userId, [NotNullWhen(true)] out PlayerPreferences? playerPreferences);
         PlayerPreferences GetPreferences(NetUserId userId);
+        PlayerPreferences? GetPreferencesOrNull(NetUserId? userId);
         IEnumerable<KeyValuePair<NetUserId, ICharacterProfile>> GetSelectedProfilesForPlayers(List<NetUserId> userIds);
         bool HavePreferencesLoaded(ICommonSession session);
+
+        Task SetProfile(NetUserId userId, int slot, ICharacterProfile profile);
     }
 }
diff --git a/Content.Server/Preferences/Managers/ServerPreferencesManager.cs b/Content.Server/Preferences/Managers/ServerPreferencesManager.cs
index e262fde64d2..95eb9591fbc 100644
--- a/Content.Server/Preferences/Managers/ServerPreferencesManager.cs
+++ b/Content.Server/Preferences/Managers/ServerPreferencesManager.cs
@@ -3,17 +3,12 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Content.Server.Database;
-using Content.Server.Humanoid;
 using Content.Shared.CCVar;
-using Content.Shared.Humanoid.Prototypes;
 using Content.Shared.Preferences;
-using Content.Shared.Roles;
 using Robust.Server.Player;
 using Robust.Shared.Configuration;
 using Robust.Shared.Network;
 using Robust.Shared.Player;
-using Robust.Shared.Prototypes;
-
 
 namespace Content.Server.Preferences.Managers
 {
@@ -27,12 +22,14 @@ public sealed class ServerPreferencesManager : IServerPreferencesManager
         [Dependency] private readonly IConfigurationManager _cfg = default!;
         [Dependency] private readonly IServerDbManager _db = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
-        [Dependency] private readonly IPrototypeManager _protos = default!;
+        [Dependency] private readonly ILogManager _log = default!;
 
         // Cache player prefs on the server so we don't need as much async hell related to them.
         private readonly Dictionary<NetUserId, PlayerPrefData> _cachedPlayerPrefs =
             new();
 
+        private ISawmill _sawmill = default!;
+
         private int MaxCharacterSlots => _cfg.GetCVar(CCVars.GameMaxCharacterSlots);
 
         public void Init()
@@ -41,6 +38,7 @@ public void Init()
             _netManager.RegisterNetMessage<MsgSelectCharacter>(HandleSelectCharacterMessage);
             _netManager.RegisterNetMessage<MsgUpdateCharacter>(HandleUpdateCharacterMessage);
             _netManager.RegisterNetMessage<MsgDeleteCharacter>(HandleDeleteCharacterMessage);
+            _sawmill = _log.GetSawmill("prefs");
         }
 
         private async void HandleSelectCharacterMessage(MsgSelectCharacter message)
@@ -77,27 +75,25 @@ private async void HandleSelectCharacterMessage(MsgSelectCharacter message)
 
         private async void HandleUpdateCharacterMessage(MsgUpdateCharacter message)
         {
-            var slot = message.Slot;
-            var profile = message.Profile;
             var userId = message.MsgChannel.UserId;
 
-            if (profile == null)
-            {
-                Logger.WarningS("prefs",
-                    $"User {userId} sent a {nameof(MsgUpdateCharacter)} with a null profile in slot {slot}.");
-                return;
-            }
+            // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+            if (message.Profile == null)
+                _sawmill.Error($"User {userId} sent a {nameof(MsgUpdateCharacter)} with a null profile in slot {message.Slot}.");
+            else
+                await SetProfile(userId, message.Slot, message.Profile);
+        }
 
+        public async Task SetProfile(NetUserId userId, int slot, ICharacterProfile profile)
+        {
             if (!_cachedPlayerPrefs.TryGetValue(userId, out var prefsData) || !prefsData.PrefsLoaded)
             {
-                Logger.WarningS("prefs", $"User {userId} tried to modify preferences before they loaded.");
+                _sawmill.Error($"Tried to modify user {userId} preferences before they loaded.");
                 return;
             }
 
             if (slot < 0 || slot >= MaxCharacterSlots)
-            {
                 return;
-            }
 
             var curPrefs = prefsData.Prefs!;
             var session = _playerManager.GetSessionById(userId);
@@ -112,10 +108,8 @@ private async void HandleUpdateCharacterMessage(MsgUpdateCharacter message)
 
             prefsData.Prefs = new PlayerPreferences(profiles, slot, curPrefs.AdminOOCColor);
 
-            if (ShouldStorePrefs(message.MsgChannel.AuthType))
-            {
-                await _db.SaveCharacterSlotAsync(message.MsgChannel.UserId, message.Profile, message.Slot);
-            }
+            if (ShouldStorePrefs(session.Channel.AuthType))
+                await _db.SaveCharacterSlotAsync(userId, profile, slot);
         }
 
         private async void HandleDeleteCharacterMessage(MsgDeleteCharacter message)
@@ -142,7 +136,7 @@ private async void HandleDeleteCharacterMessage(MsgDeleteCharacter message)
             if (curPrefs.SelectedCharacterIndex == slot)
             {
                 // That ! on the end is because Rider doesn't like .NET 5.
-                var (ns, profile) = curPrefs.Characters.FirstOrDefault(p => p.Key != message.Slot)!;
+                var (ns, profile) = curPrefs.Characters.FirstOrDefault(p => p.Key != message.Slot);
                 if (profile == null)
                 {
                     // Only slot left, can't delete.
@@ -157,16 +151,18 @@ private async void HandleDeleteCharacterMessage(MsgDeleteCharacter message)
 
             prefsData.Prefs = new PlayerPreferences(arr, nextSlot ?? curPrefs.SelectedCharacterIndex, curPrefs.AdminOOCColor);
 
-            if (ShouldStorePrefs(message.MsgChannel.AuthType))
+            if (!ShouldStorePrefs(message.MsgChannel.AuthType))
             {
-                if (nextSlot != null)
-                {
-                    await _db.DeleteSlotAndSetSelectedIndex(userId, slot, nextSlot.Value);
-                }
-                else
-                {
-                    await _db.SaveCharacterSlotAsync(userId, null, slot);
-                }
+                return;
+            }
+
+            if (nextSlot != null)
+            {
+                await _db.DeleteSlotAndSetSelectedIndex(userId, slot, nextSlot.Value);
+            }
+            else
+            {
+                await _db.SaveCharacterSlotAsync(userId, null, slot);
             }
         }
 
@@ -200,11 +196,13 @@ async Task LoadPrefs()
                     prefsData.Prefs = prefs;
                     prefsData.PrefsLoaded = true;
 
-                    var msg = new MsgPreferencesAndSettings();
-                    msg.Preferences = prefs;
-                    msg.Settings = new GameSettings
+                    var msg = new MsgPreferencesAndSettings
                     {
-                        MaxCharacterSlots = MaxCharacterSlots
+                        Preferences = prefs,
+                        Settings = new GameSettings
+                        {
+                            MaxCharacterSlots = MaxCharacterSlots
+                        }
                     };
                     _netManager.ServerSendMessage(msg, session.Channel);
                 }
@@ -221,7 +219,6 @@ public bool HavePreferencesLoaded(ICommonSession session)
             return _cachedPlayerPrefs.ContainsKey(session.UserId);
         }
 
-
         /// <summary>
         /// Tries to get the preferences from the cache
         /// </summary>
@@ -256,6 +253,20 @@ public PlayerPreferences GetPreferences(NetUserId userId)
             return prefs;
         }
 
+        /// <summary>
+        /// Retrieves preferences for the given username from storage or returns null.
+        /// Creates and saves default preferences if they are not found, then returns them.
+        /// </summary>
+        public PlayerPreferences? GetPreferencesOrNull(NetUserId? userId)
+        {
+            if (userId == null)
+                return null;
+
+            if (_cachedPlayerPrefs.TryGetValue(userId.Value, out var pref))
+                return pref.Prefs;
+            return null;
+        }
+
         private async Task<PlayerPreferences> GetOrCreatePreferencesAsync(NetUserId userId)
         {
             var prefs = await _db.GetPlayerPreferencesAsync(userId);
@@ -275,10 +286,8 @@ private PlayerPreferences SanitizePreferences(ICommonSession session, PlayerPref
         {
             // Clean up preferences in case of changes to the game,
             // such as removed jobs still being selected.
-            return new PlayerPreferences(prefs.Characters.Select(p =>
-            {
-                return new KeyValuePair<int, ICharacterProfile>(p.Key, p.Value.Validated(session, collection));
-            }), prefs.SelectedCharacterIndex, prefs.AdminOOCColor);
+            return new PlayerPreferences(prefs.Characters.Select(p => new KeyValuePair<int, ICharacterProfile>(p.Key,
+                    p.Value.Validated(session, collection))), prefs.SelectedCharacterIndex, prefs.AdminOOCColor);
         }
 
         public IEnumerable<KeyValuePair<NetUserId, ICharacterProfile>> GetSelectedProfilesForPlayers(
diff --git a/Content.Server/RandomMetadata/RandomMetadataSystem.cs b/Content.Server/RandomMetadata/RandomMetadataSystem.cs
index c088d57fd96..0c254c52ac0 100644
--- a/Content.Server/RandomMetadata/RandomMetadataSystem.cs
+++ b/Content.Server/RandomMetadata/RandomMetadataSystem.cs
@@ -1,4 +1,4 @@
-using Content.Shared.Dataset;
+using Content.Shared.Dataset;
 using JetBrains.Annotations;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
@@ -47,9 +47,12 @@ public string GetRandomFromSegments(List<string> segments, string? separator)
         var outputSegments = new List<string>();
         foreach (var segment in segments)
         {
-            outputSegments.Add(_prototype.TryIndex<DatasetPrototype>(segment, out var proto)
-                ? Loc.GetString(_random.Pick(proto.Values))
-                : Loc.GetString(segment));
+            if (_prototype.TryIndex<DatasetPrototype>(segment, out var proto))
+                outputSegments.Add(_random.Pick(proto.Values));
+            else if (Loc.TryGetString(segment, out var localizedSegment))
+                outputSegments.Add(localizedSegment);
+            else
+                outputSegments.Add(segment);
         }
         return string.Join(separator, outputSegments);
     }
diff --git a/Content.Server/Spawners/EntitySystems/ConditionalSpawnerSystem.cs b/Content.Server/Spawners/EntitySystems/ConditionalSpawnerSystem.cs
index 506fd61d559..75f86187989 100644
--- a/Content.Server/Spawners/EntitySystems/ConditionalSpawnerSystem.cs
+++ b/Content.Server/Spawners/EntitySystems/ConditionalSpawnerSystem.cs
@@ -1,5 +1,6 @@
 using System.Numerics;
 using Content.Server.GameTicking;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Spawners.Components;
 using JetBrains.Annotations;
diff --git a/Content.Server/Station/Systems/StationSpawningSystem.cs b/Content.Server/Station/Systems/StationSpawningSystem.cs
index 2e6edfab611..61fc1e0a51b 100644
--- a/Content.Server/Station/Systems/StationSpawningSystem.cs
+++ b/Content.Server/Station/Systems/StationSpawningSystem.cs
@@ -173,7 +173,7 @@ public EntityUid SpawnPlayerMob(
         if (prototype?.StartingGear != null)
         {
             var startingGear = _prototypeManager.Index<StartingGearPrototype>(prototype.StartingGear);
-            EquipStartingGear(entity.Value, startingGear, profile);
+            EquipStartingGear(entity.Value, startingGear);
             if (profile != null)
                 EquipIdCard(entity.Value, profile.Name, prototype, station);
                 InternalEncryptionKeySpawner.TryInsertEncryptionKey(entity.Value, startingGear, EntityManager, profile); // Parkstation - IPC
diff --git a/Content.Server/StationEvents/BasicStationEventSchedulerSystem.cs b/Content.Server/StationEvents/BasicStationEventSchedulerSystem.cs
index 0243a00c9a7..b9eb3b7b09d 100644
--- a/Content.Server/StationEvents/BasicStationEventSchedulerSystem.cs
+++ b/Content.Server/StationEvents/BasicStationEventSchedulerSystem.cs
@@ -1,5 +1,6 @@
 using System.Linq;
 using Content.Server.Administration;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Components/LoneOpsSpawnRuleComponent.cs b/Content.Server/StationEvents/Components/LoneOpsSpawnRuleComponent.cs
deleted file mode 100644
index 92911e08584..00000000000
--- a/Content.Server/StationEvents/Components/LoneOpsSpawnRuleComponent.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using Content.Server.StationEvents.Events;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
-
-namespace Content.Server.StationEvents.Components;
-
-[RegisterComponent, Access(typeof(LoneOpsSpawnRule))]
-public sealed partial class LoneOpsSpawnRuleComponent : Component
-{
-    [DataField("loneOpsShuttlePath")]
-    public string LoneOpsShuttlePath = "Maps/Shuttles/striker.yml";
-
-    [DataField("gameRuleProto", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>))]
-    public string GameRuleProto = "Nukeops";
-
-    [DataField("additionalRule")]
-    public EntityUid? AdditionalRule;
-}
diff --git a/Content.Server/StationEvents/Events/AnomalySpawnRule.cs b/Content.Server/StationEvents/Events/AnomalySpawnRule.cs
index 4cd94d3e719..98d5aa76a6a 100644
--- a/Content.Server/StationEvents/Events/AnomalySpawnRule.cs
+++ b/Content.Server/StationEvents/Events/AnomalySpawnRule.cs
@@ -1,4 +1,5 @@
 using Content.Server.Anomaly;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Station.Components;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Events/BluespaceArtifactRule.cs b/Content.Server/StationEvents/Events/BluespaceArtifactRule.cs
index b25c1d6561c..29c18976576 100644
--- a/Content.Server/StationEvents/Events/BluespaceArtifactRule.cs
+++ b/Content.Server/StationEvents/Events/BluespaceArtifactRule.cs
@@ -1,4 +1,5 @@
-using Content.Server.GameTicking.Rules.Components;
+using Content.Server.GameTicking.Components;
+using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Robust.Shared.Random;
 using Content.Server.Announcements.Systems;
diff --git a/Content.Server/StationEvents/Events/BluespaceLockerRule.cs b/Content.Server/StationEvents/Events/BluespaceLockerRule.cs
index 709b750334e..eef9850e739 100644
--- a/Content.Server/StationEvents/Events/BluespaceLockerRule.cs
+++ b/Content.Server/StationEvents/Events/BluespaceLockerRule.cs
@@ -1,4 +1,5 @@
-using Content.Server.GameTicking.Rules.Components;
+using Content.Server.GameTicking.Components;
+using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Resist;
 using Content.Server.Station.Components;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Events/BreakerFlipRule.cs b/Content.Server/StationEvents/Events/BreakerFlipRule.cs
index e7574f27ad5..3b2368556be 100644
--- a/Content.Server/StationEvents/Events/BreakerFlipRule.cs
+++ b/Content.Server/StationEvents/Events/BreakerFlipRule.cs
@@ -1,4 +1,5 @@
-using Content.Server.GameTicking.Rules.Components;
+using Content.Server.GameTicking.Components;
+using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Power.Components;
 using Content.Server.Power.EntitySystems;
 using Content.Server.Station.Components;
diff --git a/Content.Server/StationEvents/Events/BureaucraticErrorRule.cs b/Content.Server/StationEvents/Events/BureaucraticErrorRule.cs
index feb88d9b848..282e28e4991 100644
--- a/Content.Server/StationEvents/Events/BureaucraticErrorRule.cs
+++ b/Content.Server/StationEvents/Events/BureaucraticErrorRule.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Station.Components;
 using Content.Server.Station.Systems;
diff --git a/Content.Server/StationEvents/Events/CargoGiftsRule.cs b/Content.Server/StationEvents/Events/CargoGiftsRule.cs
index 80af23c6fa4..62f01f58fe6 100644
--- a/Content.Server/StationEvents/Events/CargoGiftsRule.cs
+++ b/Content.Server/StationEvents/Events/CargoGiftsRule.cs
@@ -2,6 +2,7 @@
 using Content.Server.Cargo.Components;
 using Content.Server.Cargo.Systems;
 using Content.Server.GameTicking;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Station.Components;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Events/ClericalErrorRule.cs b/Content.Server/StationEvents/Events/ClericalErrorRule.cs
index dd4473952cb..854ee685b33 100644
--- a/Content.Server/StationEvents/Events/ClericalErrorRule.cs
+++ b/Content.Server/StationEvents/Events/ClericalErrorRule.cs
@@ -1,4 +1,5 @@
-using Content.Server.GameTicking.Rules.Components;
+using Content.Server.GameTicking.Components;
+using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Content.Server.StationRecords;
 using Content.Server.StationRecords.Systems;
diff --git a/Content.Server/StationEvents/Events/FalseAlarmRule.cs b/Content.Server/StationEvents/Events/FalseAlarmRule.cs
index cd434a721b1..2d129b35584 100644
--- a/Content.Server/StationEvents/Events/FalseAlarmRule.cs
+++ b/Content.Server/StationEvents/Events/FalseAlarmRule.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using JetBrains.Annotations;
diff --git a/Content.Server/StationEvents/Events/FreeProberRule.cs b/Content.Server/StationEvents/Events/FreeProberRule.cs
index 0aa8ecc47cc..a5dfdd6b6ea 100644
--- a/Content.Server/StationEvents/Events/FreeProberRule.cs
+++ b/Content.Server/StationEvents/Events/FreeProberRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Robust.Shared.Map;
 using Robust.Shared.Random;
 using Content.Server.GameTicking.Rules.Components;
diff --git a/Content.Server/StationEvents/Events/GasLeakRule.cs b/Content.Server/StationEvents/Events/GasLeakRule.cs
index 68544e416c3..1221612171d 100644
--- a/Content.Server/StationEvents/Events/GasLeakRule.cs
+++ b/Content.Server/StationEvents/Events/GasLeakRule.cs
@@ -1,4 +1,5 @@
 using Content.Server.Atmos.EntitySystems;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Robust.Shared.Audio;
diff --git a/Content.Server/StationEvents/Events/GlimmerEventSystem.cs b/Content.Server/StationEvents/Events/GlimmerEventSystem.cs
index a3d36ae7157..3e0762c8346 100644
--- a/Content.Server/StationEvents/Events/GlimmerEventSystem.cs
+++ b/Content.Server/StationEvents/Events/GlimmerEventSystem.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Psionics.Glimmer;
 using Content.Shared.Psionics.Glimmer;
diff --git a/Content.Server/StationEvents/Events/GlimmerRandomSentienceRule.cs b/Content.Server/StationEvents/Events/GlimmerRandomSentienceRule.cs
index 152ff77853e..a288710356a 100644
--- a/Content.Server/StationEvents/Events/GlimmerRandomSentienceRule.cs
+++ b/Content.Server/StationEvents/Events/GlimmerRandomSentienceRule.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Ghost.Roles.Components;
 using Content.Shared.Abilities.Psionics;
diff --git a/Content.Server/StationEvents/Events/GlimmerRevenantSpawnRule.cs b/Content.Server/StationEvents/Events/GlimmerRevenantSpawnRule.cs
index 8bab321db75..152d6d9fe59 100644
--- a/Content.Server/StationEvents/Events/GlimmerRevenantSpawnRule.cs
+++ b/Content.Server/StationEvents/Events/GlimmerRevenantSpawnRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Robust.Shared.Random;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Psionics.Glimmer;
diff --git a/Content.Server/StationEvents/Events/GlimmerWispSpawnRule.cs b/Content.Server/StationEvents/Events/GlimmerWispSpawnRule.cs
index 66eea988aeb..c2cb4eca6d4 100644
--- a/Content.Server/StationEvents/Events/GlimmerWispSpawnRule.cs
+++ b/Content.Server/StationEvents/Events/GlimmerWispSpawnRule.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Robust.Shared.Random;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.NPC.Components;
diff --git a/Content.Server/StationEvents/Events/ImmovableRodRule.cs b/Content.Server/StationEvents/Events/ImmovableRodRule.cs
index a61c6b69e1a..781d0368f47 100644
--- a/Content.Server/StationEvents/Events/ImmovableRodRule.cs
+++ b/Content.Server/StationEvents/Events/ImmovableRodRule.cs
@@ -1,4 +1,5 @@
 using System.Numerics;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.ImmovableRod;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Events/IonStormRule.cs b/Content.Server/StationEvents/Events/IonStormRule.cs
index cd3cd63ae86..8361cc6048a 100644
--- a/Content.Server/StationEvents/Events/IonStormRule.cs
+++ b/Content.Server/StationEvents/Events/IonStormRule.cs
@@ -1,5 +1,5 @@
+using Content.Server.GameTicking.Components;
 using System.Linq;
-using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Silicons.Laws;
 using Content.Server.Station.Components;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Events/KudzuGrowthRule.cs b/Content.Server/StationEvents/Events/KudzuGrowthRule.cs
index 3fa12cd4e9f..5b56e03846f 100644
--- a/Content.Server/StationEvents/Events/KudzuGrowthRule.cs
+++ b/Content.Server/StationEvents/Events/KudzuGrowthRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 
diff --git a/Content.Server/StationEvents/Events/LoneOpsSpawnRule.cs b/Content.Server/StationEvents/Events/LoneOpsSpawnRule.cs
deleted file mode 100644
index 4b15e590997..00000000000
--- a/Content.Server/StationEvents/Events/LoneOpsSpawnRule.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using Robust.Server.GameObjects;
-using Robust.Server.Maps;
-using Content.Server.GameTicking.Rules.Components;
-using Content.Server.StationEvents.Components;
-using Content.Server.RoundEnd;
-
-namespace Content.Server.StationEvents.Events;
-
-public sealed class LoneOpsSpawnRule : StationEventSystem<LoneOpsSpawnRuleComponent>
-{
-    [Dependency] private readonly MapLoaderSystem _map = default!;
-
-    protected override void Started(EntityUid uid, LoneOpsSpawnRuleComponent component, GameRuleComponent gameRule, GameRuleStartedEvent args)
-    {
-        base.Started(uid, component, gameRule, args);
-
-        // Loneops can only spawn if there is no nukeops active
-        if (GameTicker.IsGameRuleAdded<NukeopsRuleComponent>())
-        {
-            ForceEndSelf(uid, gameRule);
-            return;
-        }
-
-        var shuttleMap = MapManager.CreateMap();
-        var options = new MapLoadOptions
-        {
-            LoadMap = true,
-        };
-
-        _map.TryLoad(shuttleMap, component.LoneOpsShuttlePath, out _, options);
-
-        var nukeopsEntity = GameTicker.AddGameRule(component.GameRuleProto);
-        component.AdditionalRule = nukeopsEntity;
-        var nukeopsComp = Comp<NukeopsRuleComponent>(nukeopsEntity);
-        nukeopsComp.SpawnOutpost = false;
-        nukeopsComp.RoundEndBehavior = RoundEndBehavior.Nothing;
-        GameTicker.StartGameRule(nukeopsEntity);
-    }
-
-    protected override void Ended(EntityUid uid, LoneOpsSpawnRuleComponent component, GameRuleComponent gameRule, GameRuleEndedEvent args)
-    {
-        base.Ended(uid, component, gameRule, args);
-
-        if (component.AdditionalRule != null)
-            GameTicker.EndGameRule(component.AdditionalRule.Value);
-    }
-}
diff --git a/Content.Server/StationEvents/Events/MassHallucinationsRule.cs b/Content.Server/StationEvents/Events/MassHallucinationsRule.cs
index 4fc158f8646..2239db7f701 100644
--- a/Content.Server/StationEvents/Events/MassHallucinationsRule.cs
+++ b/Content.Server/StationEvents/Events/MassHallucinationsRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Content.Server.Traits.Assorted;
diff --git a/Content.Server/StationEvents/Events/MassMindSwapRule.cs b/Content.Server/StationEvents/Events/MassMindSwapRule.cs
index c7e9f1e0298..beb08eb8a79 100644
--- a/Content.Server/StationEvents/Events/MassMindSwapRule.cs
+++ b/Content.Server/StationEvents/Events/MassMindSwapRule.cs
@@ -1,6 +1,7 @@
 using Robust.Server.GameObjects;
 using Robust.Shared.Random;
 using Content.Server.Abilities.Psionics;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Psionics;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Events/MeteorSwarmRule.cs b/Content.Server/StationEvents/Events/MeteorSwarmRule.cs
index ad56479b379..455011259dc 100644
--- a/Content.Server/StationEvents/Events/MeteorSwarmRule.cs
+++ b/Content.Server/StationEvents/Events/MeteorSwarmRule.cs
@@ -1,4 +1,5 @@
 using System.Numerics;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Robust.Shared.Map;
diff --git a/Content.Server/StationEvents/Events/NinjaSpawnRule.cs b/Content.Server/StationEvents/Events/NinjaSpawnRule.cs
index 8ad5c8602e3..d9d68a386cf 100644
--- a/Content.Server/StationEvents/Events/NinjaSpawnRule.cs
+++ b/Content.Server/StationEvents/Events/NinjaSpawnRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Ninja.Systems;
 using Content.Server.Station.Components;
diff --git a/Content.Server/StationEvents/Events/NoosphericFryRule.cs b/Content.Server/StationEvents/Events/NoosphericFryRule.cs
index c04543d2195..85f98d6f4be 100644
--- a/Content.Server/StationEvents/Events/NoosphericFryRule.cs
+++ b/Content.Server/StationEvents/Events/NoosphericFryRule.cs
@@ -3,6 +3,7 @@
 using Robust.Shared.Player;
 using Content.Server.Atmos.Components;
 using Content.Server.Atmos.EntitySystems;
+using Content.Server.GameTicking.Components;
 using Content.Shared.Construction.EntitySystems;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Popups;
diff --git a/Content.Server/StationEvents/Events/NoosphericStormRule.cs b/Content.Server/StationEvents/Events/NoosphericStormRule.cs
index 2465cb37fa5..1de8bad89b5 100644
--- a/Content.Server/StationEvents/Events/NoosphericStormRule.cs
+++ b/Content.Server/StationEvents/Events/NoosphericStormRule.cs
@@ -1,5 +1,6 @@
 using Robust.Shared.Random;
 using Content.Server.Abilities.Psionics;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Content.Server.Psionics;
diff --git a/Content.Server/StationEvents/Events/NoosphericZapRule.cs b/Content.Server/StationEvents/Events/NoosphericZapRule.cs
index a452f55ed2a..4be7b6e63fc 100644
--- a/Content.Server/StationEvents/Events/NoosphericZapRule.cs
+++ b/Content.Server/StationEvents/Events/NoosphericZapRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Popups;
 using Content.Server.Psionics;
diff --git a/Content.Server/StationEvents/Events/PowerGridCheckRule.cs b/Content.Server/StationEvents/Events/PowerGridCheckRule.cs
index 97e89484612..b0a0bbc9fe0 100644
--- a/Content.Server/StationEvents/Events/PowerGridCheckRule.cs
+++ b/Content.Server/StationEvents/Events/PowerGridCheckRule.cs
@@ -1,4 +1,5 @@
 using System.Threading;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Power.Components;
 using Content.Server.Power.EntitySystems;
diff --git a/Content.Server/StationEvents/Events/PsionicCatGotYourTongueRule.cs b/Content.Server/StationEvents/Events/PsionicCatGotYourTongueRule.cs
index f5afa1e4587..b92097b28d0 100644
--- a/Content.Server/StationEvents/Events/PsionicCatGotYourTongueRule.cs
+++ b/Content.Server/StationEvents/Events/PsionicCatGotYourTongueRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Robust.Shared.Random;
 using Robust.Shared.Player;
 using Content.Server.GameTicking.Rules.Components;
diff --git a/Content.Server/StationEvents/Events/RandomEntityStorageSpawnRule.cs b/Content.Server/StationEvents/Events/RandomEntityStorageSpawnRule.cs
index c3cd719cc4c..87d50fc8b2a 100644
--- a/Content.Server/StationEvents/Events/RandomEntityStorageSpawnRule.cs
+++ b/Content.Server/StationEvents/Events/RandomEntityStorageSpawnRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 using Content.Server.Storage.Components;
diff --git a/Content.Server/StationEvents/Events/RandomSentienceRule.cs b/Content.Server/StationEvents/Events/RandomSentienceRule.cs
index f667ad79750..7b9173241f7 100644
--- a/Content.Server/StationEvents/Events/RandomSentienceRule.cs
+++ b/Content.Server/StationEvents/Events/RandomSentienceRule.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Ghost.Roles.Components;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/StationEvents/Events/RandomSpawnRule.cs b/Content.Server/StationEvents/Events/RandomSpawnRule.cs
index c514acc6236..77744d44e46 100644
--- a/Content.Server/StationEvents/Events/RandomSpawnRule.cs
+++ b/Content.Server/StationEvents/Events/RandomSpawnRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 
diff --git a/Content.Server/StationEvents/Events/SolarFlareRule.cs b/Content.Server/StationEvents/Events/SolarFlareRule.cs
index a4ec74b43ba..0370b4ee61d 100644
--- a/Content.Server/StationEvents/Events/SolarFlareRule.cs
+++ b/Content.Server/StationEvents/Events/SolarFlareRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Radio;
 using Robust.Shared.Random;
diff --git a/Content.Server/StationEvents/Events/StationEventSystem.cs b/Content.Server/StationEvents/Events/StationEventSystem.cs
index 6de8024bd0a..257babd0d2c 100644
--- a/Content.Server/StationEvents/Events/StationEventSystem.cs
+++ b/Content.Server/StationEvents/Events/StationEventSystem.cs
@@ -1,5 +1,6 @@
 using Content.Server.Administration.Logs;
 using Content.Server.Chat.Systems;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Station.Systems;
diff --git a/Content.Server/StationEvents/Events/VentClogRule.cs b/Content.Server/StationEvents/Events/VentClogRule.cs
index e263a5f4f69..867f41dcccf 100644
--- a/Content.Server/StationEvents/Events/VentClogRule.cs
+++ b/Content.Server/StationEvents/Events/VentClogRule.cs
@@ -6,6 +6,7 @@
 using Robust.Shared.Random;
 using System.Linq;
 using Content.Server.Fluids.EntitySystems;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
 
diff --git a/Content.Server/StationEvents/Events/VentCrittersRule.cs b/Content.Server/StationEvents/Events/VentCrittersRule.cs
index cdcf2bf6ff2..c2605039bce 100644
--- a/Content.Server/StationEvents/Events/VentCrittersRule.cs
+++ b/Content.Server/StationEvents/Events/VentCrittersRule.cs
@@ -1,3 +1,4 @@
+using Content.Server.GameTicking.Components;
 using Content.Server.StationEvents.Components;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Station.Components;
diff --git a/Content.Server/StationEvents/RampingStationEventSchedulerSystem.cs b/Content.Server/StationEvents/RampingStationEventSchedulerSystem.cs
index aa0c9b214b4..a6c38ef765f 100644
--- a/Content.Server/StationEvents/RampingStationEventSchedulerSystem.cs
+++ b/Content.Server/StationEvents/RampingStationEventSchedulerSystem.cs
@@ -1,4 +1,5 @@
 using Content.Server.GameTicking;
+using Content.Server.GameTicking.Components;
 using Content.Server.GameTicking.Rules;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
diff --git a/Content.Server/Traitor/Components/AutoTraitorComponent.cs b/Content.Server/Traitor/Components/AutoTraitorComponent.cs
index ab4bee2f267..473441ccec2 100644
--- a/Content.Server/Traitor/Components/AutoTraitorComponent.cs
+++ b/Content.Server/Traitor/Components/AutoTraitorComponent.cs
@@ -11,12 +11,12 @@ public sealed partial class AutoTraitorComponent : Component
     /// <summary>
     /// Whether to give the traitor an uplink or not.
     /// </summary>
-    [DataField("giveUplink"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
     public bool GiveUplink = true;
 
     /// <summary>
     /// Whether to give the traitor objectives or not.
     /// </summary>
-    [DataField("giveObjectives"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField, ViewVariables(VVAccess.ReadWrite)]
     public bool GiveObjectives = true;
 }
diff --git a/Content.Server/Traitor/Systems/AutoTraitorSystem.cs b/Content.Server/Traitor/Systems/AutoTraitorSystem.cs
index 15deae25529..e9307effbc6 100644
--- a/Content.Server/Traitor/Systems/AutoTraitorSystem.cs
+++ b/Content.Server/Traitor/Systems/AutoTraitorSystem.cs
@@ -1,6 +1,7 @@
-using Content.Server.GameTicking.Rules;
+using Content.Server.Antag;
 using Content.Server.Traitor.Components;
 using Content.Shared.Mind.Components;
+using Robust.Shared.Prototypes;
 
 namespace Content.Server.Traitor.Systems;
 
@@ -9,7 +10,10 @@ namespace Content.Server.Traitor.Systems;
 /// </summary>
 public sealed class AutoTraitorSystem : EntitySystem
 {
-    [Dependency] private readonly TraitorRuleSystem _traitorRule = default!;
+    [Dependency] private readonly AntagSelectionSystem _antag = default!;
+
+    [ValidatePrototypeId<EntityPrototype>]
+    private const string DefaultTraitorRule = "Traitor";
 
     public override void Initialize()
     {
@@ -20,44 +24,6 @@ public override void Initialize()
 
     private void OnMindAdded(EntityUid uid, AutoTraitorComponent comp, MindAddedMessage args)
     {
-        TryMakeTraitor(uid, comp);
-    }
-
-    /// <summary>
-    /// Sets the GiveUplink field.
-    /// </summary>
-    public void SetGiveUplink(EntityUid uid, bool giveUplink, AutoTraitorComponent? comp = null)
-    {
-        if (!Resolve(uid, ref comp))
-            return;
-
-        comp.GiveUplink = giveUplink;
-    }
-
-    /// <summary>
-    /// Sets the GiveObjectives field.
-    /// </summary>
-    public void SetGiveObjectives(EntityUid uid, bool giveObjectives, AutoTraitorComponent? comp = null)
-    {
-        if (!Resolve(uid, ref comp))
-            return;
-
-        comp.GiveObjectives = giveObjectives;
-    }
-
-    /// <summary>
-    /// Checks if there is a mind, then makes it a traitor using the options.
-    /// </summary>
-    public bool TryMakeTraitor(EntityUid uid, AutoTraitorComponent? comp = null)
-    {
-        if (!Resolve(uid, ref comp))
-            return false;
-
-        //Start the rule if it has not already been started
-        var traitorRuleComponent = _traitorRule.StartGameRule();
-        _traitorRule.MakeTraitor(uid, traitorRuleComponent, giveUplink: comp.GiveUplink, giveObjectives: comp.GiveObjectives);
-        // prevent spamming anything if it fails
-        RemComp<AutoTraitorComponent>(uid);
-        return true;
+        _antag.ForceMakeAntag<AutoTraitorComponent>(args.Mind.Comp.Session, DefaultTraitorRule);
     }
 }
diff --git a/Content.Server/Traitor/Uplink/Commands/AddUplinkCommand.cs b/Content.Server/Traitor/Uplink/Commands/AddUplinkCommand.cs
index cdaed3f928e..79192f6b496 100644
--- a/Content.Server/Traitor/Uplink/Commands/AddUplinkCommand.cs
+++ b/Content.Server/Traitor/Uplink/Commands/AddUplinkCommand.cs
@@ -83,12 +83,9 @@ public void Execute(IConsoleShell shell, string argStr, string[] args)
                 uplinkEntity = eUid;
             }
 
-            // Get TC count
-            var tcCount = _cfgManager.GetCVar(CCVars.TraitorStartingBalance);
-            Logger.Debug(_entManager.ToPrettyString(user));
             // Finally add uplink
             var uplinkSys = _entManager.System<UplinkSystem>();
-            if (!uplinkSys.AddUplink(user, FixedPoint2.New(tcCount), uplinkEntity: uplinkEntity))
+            if (!uplinkSys.AddUplink(user, 20, uplinkEntity: uplinkEntity))
             {
                 shell.WriteLine(Loc.GetString("add-uplink-command-error-2"));
             }
diff --git a/Content.Server/Zombies/PendingZombieComponent.cs b/Content.Server/Zombies/PendingZombieComponent.cs
index a49b424c53f..1bb0ef28720 100644
--- a/Content.Server/Zombies/PendingZombieComponent.cs
+++ b/Content.Server/Zombies/PendingZombieComponent.cs
@@ -1,4 +1,5 @@
 using Content.Shared.Damage;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 
 namespace Content.Server.Zombies;
@@ -35,6 +36,21 @@ public sealed partial class PendingZombieComponent : Component
     [DataField("gracePeriod"), ViewVariables(VVAccess.ReadWrite)]
     public TimeSpan GracePeriod = TimeSpan.Zero;
 
+    /// <summary>
+    /// The minimum amount of time initial infected have before they start taking infection damage.
+    /// </summary>
+    [DataField]
+    public TimeSpan MinInitialInfectedGrace = TimeSpan.FromMinutes(12.5f);
+
+    /// <summary>
+    /// The maximum amount of time initial infected have before they start taking damage.
+    /// </summary>
+    [DataField]
+    public TimeSpan MaxInitialInfectedGrace = TimeSpan.FromMinutes(15f);
+
+    [DataField]
+    public EntProtoId ZombifySelfActionPrototype = "ActionTurnUndead";
+
     /// <summary>
     /// The chance each second that a warning will be shown.
     /// </summary>
diff --git a/Content.Server/Zombies/ZombieSystem.cs b/Content.Server/Zombies/ZombieSystem.cs
index 080bef44e7a..09c8fa26db6 100644
--- a/Content.Server/Zombies/ZombieSystem.cs
+++ b/Content.Server/Zombies/ZombieSystem.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Server.Actions;
 using Content.Server.Body.Systems;
 using Content.Server.Chat;
 using Content.Server.Chat.Systems;
@@ -30,6 +31,7 @@ public sealed partial class ZombieSystem : SharedZombieSystem
         [Dependency] private readonly BloodstreamSystem _bloodstream = default!;
         [Dependency] private readonly DamageableSystem _damageable = default!;
         [Dependency] private readonly ChatSystem _chat = default!;
+        [Dependency] private readonly ActionsSystem _actions = default!;
         [Dependency] private readonly AutoEmoteSystem _autoEmote = default!;
         [Dependency] private readonly EmoteOnDamageSystem _emoteOnDamage = default!;
         [Dependency] private readonly MetaDataSystem _metaData = default!;
@@ -74,6 +76,8 @@ private void OnPendingMapInit(EntityUid uid, PendingZombieComponent component, M
             }
 
             component.NextTick = _timing.CurTime + TimeSpan.FromSeconds(1f);
+            component.GracePeriod = _random.Next(component.MinInitialInfectedGrace, component.MaxInitialInfectedGrace);
+            _actions.AddAction(uid, ref component.Action, component.ZombifySelfActionPrototype);
         }
 
         public override void Update(float frameTime)
diff --git a/Content.Shared/Antag/AntagAcceptability.cs b/Content.Shared/Antag/AntagAcceptability.cs
index 98abe713ebe..f56be975033 100644
--- a/Content.Shared/Antag/AntagAcceptability.cs
+++ b/Content.Shared/Antag/AntagAcceptability.cs
@@ -20,3 +20,16 @@ public enum AntagAcceptability
     All
 }
 
+public enum AntagSelectionTime : byte
+{
+    /// <summary>
+    /// Antag roles are assigned before players are assigned jobs and spawned in.
+    /// This prevents antag selection from happening if the round is on-going.
+    /// </summary>
+    PrePlayerSpawn,
+
+    /// <summary>
+    /// Antag roles get assigned after players have been assigned jobs and have spawned in.
+    /// </summary>
+    PostPlayerSpawn
+}
diff --git a/Content.Shared/CCVar/CCVars.cs b/Content.Shared/CCVar/CCVars.cs
index 099f358105f..7d0d51b320d 100644
--- a/Content.Shared/CCVar/CCVars.cs
+++ b/Content.Shared/CCVar/CCVars.cs
@@ -543,91 +543,6 @@ public static readonly CVarDef<bool>
         public static readonly CVarDef<string> DiscordAuthApiKey =
             CVarDef.Create("discord.auth_api_key", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);
 
-
-        /*
-         * Suspicion
-         */
-
-        public static readonly CVarDef<int> SuspicionMinPlayers =
-            CVarDef.Create("suspicion.min_players", 5);
-
-        public static readonly CVarDef<int> SuspicionMinTraitors =
-            CVarDef.Create("suspicion.min_traitors", 2);
-
-        public static readonly CVarDef<int> SuspicionPlayersPerTraitor =
-            CVarDef.Create("suspicion.players_per_traitor", 6);
-
-        public static readonly CVarDef<int> SuspicionStartingBalance =
-            CVarDef.Create("suspicion.starting_balance", 20);
-
-        public static readonly CVarDef<int> SuspicionMaxTimeSeconds =
-            CVarDef.Create("suspicion.max_time_seconds", 300);
-
-        /*
-         * Traitor
-         */
-
-        public static readonly CVarDef<int> TraitorMinPlayers =
-            CVarDef.Create("traitor.min_players", 5);
-
-        public static readonly CVarDef<int> TraitorMaxTraitors =
-            CVarDef.Create("traitor.max_traitors", 12); // Assuming average server maxes somewhere from like 50-80 people
-
-        public static readonly CVarDef<int> TraitorPlayersPerTraitor =
-            CVarDef.Create("traitor.players_per_traitor", 10);
-
-        public static readonly CVarDef<int> TraitorCodewordCount =
-            CVarDef.Create("traitor.codeword_count", 4);
-
-        public static readonly CVarDef<int> TraitorStartingBalance =
-            CVarDef.Create("traitor.starting_balance", 20);
-
-        public static readonly CVarDef<int> TraitorMaxDifficulty =
-            CVarDef.Create("traitor.max_difficulty", 5);
-
-        public static readonly CVarDef<int> TraitorMaxPicks =
-            CVarDef.Create("traitor.max_picks", 20);
-
-        public static readonly CVarDef<float> TraitorStartDelay =
-            CVarDef.Create("traitor.start_delay", 4f * 60f);
-
-        public static readonly CVarDef<float> TraitorStartDelayVariance =
-            CVarDef.Create("traitor.start_delay_variance", 3f * 60f);
-
-        /*
-         * TraitorDeathMatch
-         */
-
-        public static readonly CVarDef<int> TraitorDeathMatchStartingBalance =
-            CVarDef.Create("traitordm.starting_balance", 20);
-
-        /*
-         * Zombie
-         */
-
-        public static readonly CVarDef<int> ZombieMinPlayers =
-            CVarDef.Create("zombie.min_players", 20);
-
-        /*
-         * Pirates
-         */
-
-        public static readonly CVarDef<int> PiratesMinPlayers =
-            CVarDef.Create("pirates.min_players", 25);
-
-        public static readonly CVarDef<int> PiratesMaxOps =
-            CVarDef.Create("pirates.max_pirates", 6);
-
-        public static readonly CVarDef<int> PiratesPlayersPerOp =
-            CVarDef.Create("pirates.players_per_pirate", 5);
-
-        /*
-         * Nukeops
-         */
-
-        public static readonly CVarDef<bool> NukeopsSpawnGhostRoles =
-            CVarDef.Create("nukeops.spawn_ghost_roles", false);
-
         /*
          * Tips
          */
diff --git a/Content.Shared/Clothing/Loadouts/Systems/LoadoutSystem.cs b/Content.Shared/Clothing/Loadouts/Systems/LoadoutSystem.cs
index e7a0eef80ee..08ca204372f 100644
--- a/Content.Shared/Clothing/Loadouts/Systems/LoadoutSystem.cs
+++ b/Content.Shared/Clothing/Loadouts/Systems/LoadoutSystem.cs
@@ -34,7 +34,7 @@ private void OnMapInit(EntityUid uid, LoadoutComponent component, MapInitEvent a
             return;
 
         var proto = _prototype.Index<StartingGearPrototype>(_random.Pick(component.Prototypes));
-        _station.EquipStartingGear(uid, proto, null);
+        _station.EquipStartingGear(uid, proto);
     }
 
 
diff --git a/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs b/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
index ece4b59e91a..ce49f80af3b 100644
--- a/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
+++ b/Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs
@@ -328,8 +328,11 @@ public void SetScale(EntityUid uid, Vector2 scale, bool sync = true, HumanoidApp
     /// <param name="uid">The mob's entity UID.</param>
     /// <param name="profile">The character profile to load.</param>
     /// <param name="humanoid">Humanoid component of the entity</param>
-    public virtual void LoadProfile(EntityUid uid, HumanoidCharacterProfile profile, HumanoidAppearanceComponent? humanoid = null)
+    public virtual void LoadProfile(EntityUid uid, HumanoidCharacterProfile? profile, HumanoidAppearanceComponent? humanoid = null)
     {
+        if (profile == null)
+            return;
+
         if (!Resolve(uid, ref humanoid))
         {
             return;
diff --git a/Content.Shared/Inventory/InventorySystem.Helpers.cs b/Content.Shared/Inventory/InventorySystem.Helpers.cs
index 811387d3750..7e325abe216 100644
--- a/Content.Shared/Inventory/InventorySystem.Helpers.cs
+++ b/Content.Shared/Inventory/InventorySystem.Helpers.cs
@@ -1,8 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using Content.Shared.Hands.Components;
 using Content.Shared.Storage.EntitySystems;
-using Robust.Shared.Containers;
 using Robust.Shared.Prototypes;
 
 namespace Content.Shared.Inventory;
@@ -96,7 +94,7 @@ bool DeleteItem()
     /// </summary>
     /// <param name="entity">The entity that you want to spawn an item on</param>
     /// <param name="items">A list of prototype IDs that you want to spawn in the bag.</param>
-    public void SpawnItemsOnEntity(EntityUid entity, List<EntProtoId> items)
+    public void SpawnItemsOnEntity(EntityUid entity, List<string> items)
     {
         foreach (var item in items)
         {
diff --git a/Content.Shared/NukeOps/NukeOperativeComponent.cs b/Content.Shared/NukeOps/NukeOperativeComponent.cs
index cdbefece9d6..d19f0ae3e9d 100644
--- a/Content.Shared/NukeOps/NukeOperativeComponent.cs
+++ b/Content.Shared/NukeOps/NukeOperativeComponent.cs
@@ -13,14 +13,9 @@ namespace Content.Shared.NukeOps;
 [RegisterComponent, NetworkedComponent]
 public sealed partial class NukeOperativeComponent : Component
 {
-    /// <summary>
-    ///     Path to antagonist alert sound.
-    /// </summary>
-    [DataField("greetSoundNotification")]
-    public SoundSpecifier GreetSoundNotification = new SoundPathSpecifier("/Audio/Ambience/Antag/nukeops_start.ogg");
 
     /// <summary>
-    ///     
+    ///
     /// </summary>
     [DataField("syndStatusIcon", customTypeSerializer: typeof(PrototypeIdSerializer<StatusIconPrototype>))]
     public string SyndStatusIcon = "SyndicateFaction";
diff --git a/Content.Shared/Roles/Jobs/SharedJobSystem.cs b/Content.Shared/Roles/Jobs/SharedJobSystem.cs
index 04ac45c4c5f..fcf76052785 100644
--- a/Content.Shared/Roles/Jobs/SharedJobSystem.cs
+++ b/Content.Shared/Roles/Jobs/SharedJobSystem.cs
@@ -146,8 +146,10 @@ public string MindTryGetJobName([NotNullWhen(true)] EntityUid? mindId)
 
     public bool CanBeAntag(ICommonSession player)
     {
+        // If the player does not have any mind associated with them (e.g., has not spawned in or is in the lobby), then
+        // they are eligible to be given an antag role/entity.
         if (_playerSystem.ContentData(player) is not { Mind: { } mindId })
-            return false;
+            return true;
 
         if (!MindTryGetJob(mindId, out _, out var prototype))
             return true;
diff --git a/Content.Shared/Roles/SharedRoleSystem.cs b/Content.Shared/Roles/SharedRoleSystem.cs
index e8053e4c678..94ad32164b3 100644
--- a/Content.Shared/Roles/SharedRoleSystem.cs
+++ b/Content.Shared/Roles/SharedRoleSystem.cs
@@ -1,3 +1,4 @@
+using System.Linq;
 using Content.Shared.Administration.Logs;
 using Content.Shared.Database;
 using Content.Shared.Mind;
@@ -62,6 +63,64 @@ protected void SubscribeAntagEvents<T>() where T : AntagonistRoleComponent
         _antagTypes.Add(typeof(T));
     }
 
+    public void MindAddRoles(EntityUid mindId, ComponentRegistry components, MindComponent? mind = null, bool silent = false)
+    {
+        if (!Resolve(mindId, ref mind))
+            return;
+
+        EntityManager.AddComponents(mindId, components);
+        var antagonist = false;
+        foreach (var compReg in components.Values)
+        {
+            var compType = compReg.Component.GetType();
+
+            var comp = EntityManager.ComponentFactory.GetComponent(compType);
+            if (IsAntagonistRole(comp.GetType()))
+            {
+                antagonist = true;
+                break;
+            }
+        }
+
+        var mindEv = new MindRoleAddedEvent(silent);
+        RaiseLocalEvent(mindId, ref mindEv);
+
+        var message = new RoleAddedEvent(mindId, mind, antagonist, silent);
+        if (mind.OwnedEntity != null)
+        {
+            RaiseLocalEvent(mind.OwnedEntity.Value, message, true);
+        }
+
+        _adminLogger.Add(LogType.Mind, LogImpact.Low,
+            $"Role components {string.Join(components.Keys.ToString(), ", ")} added to mind of {_minds.MindOwnerLoggingString(mind)}");
+    }
+
+    public void MindAddRole(EntityUid mindId, Component component, MindComponent? mind = null, bool silent = false)
+    {
+        if (!Resolve(mindId, ref mind))
+            return;
+
+        if (HasComp(mindId, component.GetType()))
+        {
+            throw new ArgumentException($"We already have this role: {component}");
+        }
+
+        EntityManager.AddComponent(mindId, component);
+        var antagonist = IsAntagonistRole(component.GetType());
+
+        var mindEv = new MindRoleAddedEvent(silent);
+        RaiseLocalEvent(mindId, ref mindEv);
+
+        var message = new RoleAddedEvent(mindId, mind, antagonist, silent);
+        if (mind.OwnedEntity != null)
+        {
+            RaiseLocalEvent(mind.OwnedEntity.Value, message, true);
+        }
+
+        _adminLogger.Add(LogType.Mind, LogImpact.Low,
+            $"'Role {component}' added to mind of {_minds.MindOwnerLoggingString(mind)}");
+    }
+
     /// <summary>
     ///     Gives this mind a new role.
     /// </summary>
@@ -177,6 +236,11 @@ public bool IsAntagonistRole<T>()
         return _antagTypes.Contains(typeof(T));
     }
 
+    public bool IsAntagonistRole(Type component)
+    {
+        return _antagTypes.Contains(component);
+    }
+
     /// <summary>
     /// Play a sound for the mind, if it has a session attached.
     /// Use this for role greeting sounds.
diff --git a/Content.Shared/Station/SharedStationSpawningSystem.cs b/Content.Shared/Station/SharedStationSpawningSystem.cs
index 715ee2a1494..56a8a846b07 100644
--- a/Content.Shared/Station/SharedStationSpawningSystem.cs
+++ b/Content.Shared/Station/SharedStationSpawningSystem.cs
@@ -1,16 +1,17 @@
 using Content.Shared.Hands.Components;
 using Content.Shared.Hands.EntitySystems;
 using Content.Shared.Inventory;
-using Content.Shared.Preferences;
 using Content.Shared.Roles;
 using Content.Shared.Storage;
 using Content.Shared.Storage.EntitySystems;
 using Robust.Shared.Collections;
+using Robust.Shared.Prototypes;
 
 namespace Content.Shared.Station;
 
 public abstract class SharedStationSpawningSystem : EntitySystem
 {
+    [Dependency] protected readonly IPrototypeManager PrototypeManager = default!;
     [Dependency] protected readonly InventorySystem InventorySystem = default!;
     [Dependency] private   readonly SharedHandsSystem _handsSystem = default!;
     [Dependency] private   readonly SharedStorageSystem _storage = default!;
@@ -21,14 +22,27 @@ public abstract class SharedStationSpawningSystem : EntitySystem
     /// </summary>
     /// <param name="entity">Entity to load out.</param>
     /// <param name="startingGear">Starting gear to use.</param>
-    /// <param name="profile">Character profile to use, if any.</param>
-    public void EquipStartingGear(EntityUid entity, StartingGearPrototype startingGear, HumanoidCharacterProfile? profile)
+    public void EquipStartingGear(EntityUid entity, ProtoId<StartingGearPrototype>? startingGear)
     {
+        PrototypeManager.TryIndex(startingGear, out var gearProto);
+        EquipStartingGear(entity, gearProto);
+    }
+
+    /// <summary>
+    /// Equips starting gear onto the given entity.
+    /// </summary>
+    /// <param name="entity">Entity to load out.</param>
+    /// <param name="startingGear">Starting gear to use.</param>
+    public void EquipStartingGear(EntityUid entity, StartingGearPrototype? startingGear)
+    {
+        if (startingGear == null)
+            return;
+
         if (InventorySystem.TryGetSlots(entity, out var slotDefinitions))
         {
             foreach (var slot in slotDefinitions)
             {
-                var equipmentStr = startingGear.GetGear(slot.Name, profile);
+                var equipmentStr = startingGear.GetGear(slot.Name, null);
                 if (string.IsNullOrEmpty(equipmentStr))
                     continue;
 
@@ -39,7 +53,6 @@ public void EquipStartingGear(EntityUid entity, StartingGearPrototype startingGe
         }
 
         if (TryComp(entity, out HandsComponent? handsComponent))
-            return;
         {
             var inhand = startingGear.Inhand;
             var coords = EntityManager.GetComponent<TransformComponent>(entity).Coordinates;
@@ -48,8 +61,10 @@ public void EquipStartingGear(EntityUid entity, StartingGearPrototype startingGe
                 var inhandEntity = EntityManager.SpawnEntity(prototype, coords);
 
                 if (_handsSystem.TryGetEmptyHand(entity, out var emptyHand, handsComponent))
+                {
                     _handsSystem.TryPickup(entity, inhandEntity, emptyHand, checkActionBlocker: false,
                         handsComp: handsComponent);
+                }
             }
         }
 
@@ -65,7 +80,9 @@ public void EquipStartingGear(EntityUid entity, StartingGearPrototype startingGe
                     continue;
 
                 foreach (var ent in entProtos)
+                {
                     ents.Add(Spawn(ent, coords));
+                }
 
                 if (inventoryComp == null
                     || !InventorySystem.TryGetSlotEntity(entity, slot, out var slotEnt,
@@ -74,7 +91,9 @@ public void EquipStartingGear(EntityUid entity, StartingGearPrototype startingGe
                     continue;
 
                 foreach (var ent in ents)
+                {
                     _storage.Insert(slotEnt.Value, ent, out _, storageComp: storage, playSound: false);
+                }
             }
         }
     }
diff --git a/Resources/Locale/en-US/game-ticking/game-presets/preset-pirates.ftl b/Resources/Locale/en-US/game-ticking/game-presets/preset-pirates.ftl
deleted file mode 100644
index 941643dd9a9..00000000000
--- a/Resources/Locale/en-US/game-ticking/game-presets/preset-pirates.ftl
+++ /dev/null
@@ -1,10 +0,0 @@
-pirates-title = Privateers
-pirates-description = A group of privateers has approached your lowly station. Hostile or not, their sole goal is to end the round with as many knicknacks on their ship as they can get.
-
-pirates-no-ship = Through unknown circumstances, the privateer's ship was completely and utterly destroyed. No score.
-pirates-final-score = The privateers successfully obtained {$score} spesos worth
-pirates-final-score-2 = of knicknacks, with a total of {$finalPrice} spesos.
-pirates-list-start = The privateers were:
-pirates-most-valuable = The most valuable stolen items were:
-pirates-stolen-item-entry = {$entity} ({$credits} spesos)
-pirates-stole-nothing = - The pirates stole absolutely nothing at all. Point and laugh.
diff --git a/Resources/Maps/Shuttles/striker.yml b/Resources/Maps/Shuttles/striker.yml
index 35b6178bd45..ada502275fe 100644
--- a/Resources/Maps/Shuttles/striker.yml
+++ b/Resources/Maps/Shuttles/striker.yml
@@ -1771,7 +1771,7 @@ entities:
     - type: Transform
       pos: 0.5436061,-7.5129323
       parent: 325
-- proto: SpawnPointLoneNukeOperative
+- proto: SpawnPointNukies
   entities:
   - uid: 322
     components:
diff --git a/Resources/Prototypes/Entities/Markers/Spawners/ghost_roles.yml b/Resources/Prototypes/Entities/Markers/Spawners/ghost_roles.yml
index 712dfcf3a06..0b09e0e4c9f 100644
--- a/Resources/Prototypes/Entities/Markers/Spawners/ghost_roles.yml
+++ b/Resources/Prototypes/Entities/Markers/Spawners/ghost_roles.yml
@@ -90,8 +90,7 @@
     - !type:DepartmentTimeRequirement # DeltaV - Security dept time requirement
       department: Security
       time: 36000 # DeltaV - 10 hours
-  - type: GhostRoleMobSpawner
-    prototype: MobHumanLoneNuclearOperative
+  - type: GhostRoleAntagSpawner
   - type: Sprite
     sprite: Markers/jobs.rsi
     layers:
diff --git a/Resources/Prototypes/GameRules/events.yml b/Resources/Prototypes/GameRules/events.yml
index ca885117449..284ed006525 100644
--- a/Resources/Prototypes/GameRules/events.yml
+++ b/Resources/Prototypes/GameRules/events.yml
@@ -441,11 +441,28 @@
     weight: 2
     duration: 1
   - type: ZombieRule
-    minStartDelay: 0 #let them know immediately
-    maxStartDelay: 10
-    maxInitialInfected: 2
-    minInitialInfectedGrace: 300
-    maxInitialInfectedGrace: 450
+  - type: AntagSelection
+    definitions:
+    - prefRoles: [ InitialInfected ]
+      max: 3
+      playerRatio: 10
+      blacklist:
+        components:
+        - ZombieImmune
+        - InitialInfectedExempt
+      briefing:
+        text: zombie-patientzero-role-greeting
+        color: Plum
+        sound: "/Audio/Ambience/Antag/zombie_start.ogg"
+      components:
+      - type: PendingZombie #less time to prepare than normal
+        minInitialInfectedGrace: 300
+        maxInitialInfectedGrace: 450
+      - type: ZombifyOnDeath
+      - type: IncurableZombie
+      mindComponents:
+      - type: InitialInfectedRole
+        prototype: InitialInfected
 
 - type: entity
   id: LoneOpsSpawn
@@ -458,7 +475,29 @@
     minimumPlayers: 15
     reoccurrenceDelay: 45
     duration: 1
-  - type: LoneOpsSpawnRule
+  - type: LoadMapRule
+    mapPath: /Maps/Shuttles/striker.yml
+  - type: NukeopsRule
+    roundEndBehavior: Nothing
+  - type: AntagSelection
+    definitions:
+    - spawnerPrototype: SpawnPointLoneNukeOperative
+      min: 1
+      max: 1
+      pickPlayer: false
+      startingGear: SyndicateLoneOperativeGearFull
+      components:
+      - type: NukeOperative
+      - type: RandomMetadata
+        nameSegments:
+        - SyndicateNamesPrefix
+        - SyndicateNamesNormal
+      - type: NpcFactionMember
+        factions:
+        - Syndicate
+      mindComponents:
+      - type: NukeopsRole
+        prototype: Nukeops
 
 - type: entity
   id: MassHallucinations
diff --git a/Resources/Prototypes/GameRules/midround.yml b/Resources/Prototypes/GameRules/midround.yml
index 37fc4b44cde..bb870f6007e 100644
--- a/Resources/Prototypes/GameRules/midround.yml
+++ b/Resources/Prototypes/GameRules/midround.yml
@@ -34,6 +34,23 @@
   id: Thief
   components:
   - type: ThiefRule
+  - type: AntagSelection
+    definitions:
+    - prefRoles: [ Thief ]
+      maxRange:
+        min: 1
+        max: 3
+      playerRatio: 1
+      allowNonHumans: true
+      multiAntagSetting: All
+      startingGear: ThiefGear
+      components:
+      - type: Pacified
+      mindComponents:
+      - type: ThiefRole
+        prototype: Thief
+      briefing:
+        sound: "/Audio/Misc/thief_greeting.ogg"
 
 - type: entity
   noSpawn: true
diff --git a/Resources/Prototypes/GameRules/roundstart.yml b/Resources/Prototypes/GameRules/roundstart.yml
index 0af55a7f9d0..46513376187 100644
--- a/Resources/Prototypes/GameRules/roundstart.yml
+++ b/Resources/Prototypes/GameRules/roundstart.yml
@@ -70,31 +70,114 @@
   components:
   - type: GameRule
     minPlayers: 35
+  - type: RandomMetadata #this generates the random operation name cuz it's cool.
+    nameSegments:
+    - operationPrefix
+    - operationSuffix
   - type: NukeopsRule
-    faction: Syndicate
-
-- type: entity
-  id: Pirates
-  parent: BaseGameRule
-  noSpawn: true
-  components:
-  - type: PiratesRule
+  - type: LoadMapRule
+    gameMap: NukieOutpost
+  - type: AntagSelection
+    selectionTime: PrePlayerSpawn
+    definitions:
+    - prefRoles: [ NukeopsCommander ]
+      fallbackRoles: [ Nukeops, NukeopsMedic ]
+      max: 1
+      playerRatio: 10
+      startingGear: SyndicateCommanderGearFull
+      components:
+      - type: NukeOperative
+      - type: RandomMetadata
+        nameSegments:
+        - nukeops-role-commander
+        - SyndicateNamesElite
+      - type: NpcFactionMember
+        factions:
+        - Syndicate
+      mindComponents:
+      - type: NukeopsRole
+        prototype: NukeopsCommander
+    - prefRoles: [ NukeopsMedic ]
+      fallbackRoles: [ Nukeops, NukeopsCommander ]
+      max: 1
+      playerRatio: 10
+      startingGear: SyndicateOperativeMedicFull
+      components:
+      - type: NukeOperative
+      - type: RandomMetadata
+        nameSegments:
+        - nukeops-role-agent
+        - SyndicateNamesNormal
+      - type: NpcFactionMember
+        factions:
+        - Syndicate
+      mindComponents:
+      - type: NukeopsRole
+        prototype: NukeopsMedic
+    - prefRoles: [ Nukeops ]
+      fallbackRoles: [ NukeopsCommander, NukeopsMedic ]
+      min: 0
+      max: 3
+      playerRatio: 10
+      startingGear: SyndicateOperativeGearFull
+      components:
+      - type: NukeOperative
+      - type: RandomMetadata
+        nameSegments:
+        - nukeops-role-operator
+        - SyndicateNamesNormal
+      - type: NpcFactionMember
+        factions:
+        - Syndicate
+      mindComponents:
+      - type: NukeopsRole
+        prototype: Nukeops
 
 - type: entity
   id: Traitor
   parent: BaseGameRule
   noSpawn: true
   components:
+  - type: GameRule
+    minPlayers: 5
+    delay:
+      min: 240
+      max: 420
   - type: TraitorRule
+  - type: AntagSelection
+    definitions:
+    - prefRoles: [ Traitor ]
+      max: 12
+      playerRatio: 10
+      lateJoinAdditional: true
+      mindComponents:
+      - type: TraitorRole
+        prototype: Traitor
 
 - type: entity
   id: Revolutionary
   parent: BaseGameRule
   noSpawn: true
   components:
+  - type: GameRule
+    minPlayers: 15
   - type: RevolutionaryRule
-    maxHeadRevs: 2 # DeltaV
-    playersPerHeadRev: 30 # DeltaV - need highpop readied up for multiple headrevs
+  - type: AntagSelection
+    definitions:
+    - prefRoles: [ HeadRev ]
+      max: 2
+      playerRatio: 20 # WD
+      briefing:
+        text: head-rev-role-greeting
+        color: CornflowerBlue
+        sound: "/Audio/Ambience/Antag/headrev_start.ogg"
+      startingGear: HeadRevGear
+      components:
+      - type: Revolutionary
+      - type: HeadRevolutionary
+      mindComponents:
+      - type: RevolutionaryRole
+        prototype: HeadRev
 
 - type: entity
   id: Sandbox
@@ -115,7 +198,32 @@
   parent: BaseGameRule
   noSpawn: true
   components:
+  - type: GameRule
+    minPlayers: 20
+    delay:
+      min: 600
+      max: 900
   - type: ZombieRule
+  - type: AntagSelection
+    definitions:
+    - prefRoles: [ InitialInfected ]
+      max: 6
+      playerRatio: 10
+      blacklist:
+        components:
+        - ZombieImmune
+        - InitialInfectedExempt
+      briefing:
+        text: zombie-patientzero-role-greeting
+        color: Plum
+        sound: "/Audio/Ambience/Antag/zombie_start.ogg"
+      components:
+      - type: PendingZombie
+      - type: ZombifyOnDeath
+      - type: IncurableZombie
+      mindComponents:
+      - type: InitialInfectedRole
+        prototype: InitialInfected
 
 # event schedulers
 - type: entity
@@ -154,7 +262,6 @@
     - id: BasicTrashVariationPass
     - id: SolidWallRustingVariationPass
     - id: ReinforcedWallRustingVariationPass
-    - id: CutWireVariationPass
     - id: BasicPuddleMessVariationPass
       prob: 0.99
       orGroup: puddleMess
diff --git a/Resources/Prototypes/Roles/Antags/nukeops.yml b/Resources/Prototypes/Roles/Antags/nukeops.yml
index 26024b44b28..b02ebe67539 100644
--- a/Resources/Prototypes/Roles/Antags/nukeops.yml
+++ b/Resources/Prototypes/Roles/Antags/nukeops.yml
@@ -40,3 +40,23 @@
     department: Command
     min: 36000 # DeltaV - 10 hours
   - !type:CharacterWhitelistRequirement
+
+#Lone Operative Gear
+- type: startingGear
+  id: SyndicateLoneOperativeGearFull
+  equipment:
+    jumpsuit: ClothingUniformJumpsuitOperative
+    back: ClothingBackpackDuffelSyndicateOperative
+    mask: ClothingMaskGasSyndicate
+    eyes: ClothingEyesHudSyndicate
+    ears: ClothingHeadsetAltSyndicate
+    gloves: ClothingHandsGlovesCombat
+    outerClothing: ClothingOuterHardsuitSyndie
+    shoes: ClothingShoesBootsCombatFilled
+    id: SyndiPDA
+    pocket1: DoubleEmergencyOxygenTankFilled
+    pocket2: BaseUplinkRadio40TC
+    belt: ClothingBeltMilitaryWebbing
+  innerClothingSkirt: ClothingUniformJumpskirtOperative
+  satchel: ClothingBackpackDuffelSyndicateOperative
+  duffelbag: ClothingBackpackDuffelSyndicateOperative
diff --git a/Resources/Prototypes/Roles/Jobs/Fun/misc_startinggear.yml b/Resources/Prototypes/Roles/Jobs/Fun/misc_startinggear.yml
index 434a7c1083e..b2bcd8bcb49 100644
--- a/Resources/Prototypes/Roles/Jobs/Fun/misc_startinggear.yml
+++ b/Resources/Prototypes/Roles/Jobs/Fun/misc_startinggear.yml
@@ -293,8 +293,18 @@
 #Head Rev Gear
 - type: startingGear
   id: HeadRevGear
-  equipment:
-    pocket2: Flash
+  storage:
+    back:
+    - Flash
+    - ClothingEyesGlassesSunglasses
+
+#Thief Gear
+- type: startingGear
+  id: ThiefGear
+  storage:
+    back:
+    - ToolboxThief
+    - ClothingHandsChameleonThief
 
 #Gladiator with spear
 - type: startingGear
diff --git a/Resources/Prototypes/game_presets.yml b/Resources/Prototypes/game_presets.yml
index 7d7169bf10a..7d9c9786bb5 100644
--- a/Resources/Prototypes/game_presets.yml
+++ b/Resources/Prototypes/game_presets.yml
@@ -164,15 +164,3 @@
   - Zombie
   - BasicStationEventScheduler
   - BasicRoundstartVariation
-
-- type: gamePreset
-  id: Pirates
-  alias:
-    - pirates
-  name: pirates-title
-  description: pirates-description
-  showInVote: false
-  rules:
-    - Pirates
-    - BasicStationEventScheduler
-    - BasicRoundstartVariation