Merge pull request #116 from Evgencheg/master

Фикс вроде

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);
             }
         });

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;

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));
+    }
 }

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);

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();
+    }
+}

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();
+    }
+}
+
+*/

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;

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();