Merge branch 'WWhiteDreamProject:master' into Ru-translation

Content.Client/Buckle/BuckleSystem.cs

@@ -57,7 +57,6 @@ private void OnAppearanceChange(EntityUid uid, BuckleComponent component, ref Ap
             !buckled ||
             args.Sprite == null)
         {
-            _rotationVisualizerSystem.SetHorizontalAngle((uid, rotVisuals), rotVisuals.DefaultRotation);
             return;
         }
 

Content.Client/Options/UI/Tabs/KeyRebindTab.xaml.cs

@@ -110,6 +110,12 @@ private void HandleStaticStorageUI(BaseButton.ButtonToggledEventArgs args)
             _cfg.SaveToFile();
         }
 
+        private void HandleToggleAutoGetUp(BaseButton.ButtonToggledEventArgs args) // WD EDIT
+        {
+            _cfg.SetCVar(WhiteCVars.AutoGetUp, args.Pressed);
+            _cfg.SaveToFile();
+        }
+
         public KeyRebindTab()
         {
             IoCManager.InjectDependencies(this);
@@ -194,6 +200,7 @@ void AddCheckBox(string checkBoxName, bool currentState, Action<BaseButton.Butto
             AddButton(ContentKeyFunctions.SaveItemLocation);
             AddButton(ContentKeyFunctions.ToggleStanding);
             AddButton(ContentKeyFunctions.LookUp); // WD EDIT
+            AddCheckBox("ui-options-function-auto-get-up", _cfg.GetCVar(WhiteCVars.AutoGetUp), HandleToggleAutoGetUp); // WD EDIT
             AddCheckBox("ui-options-function-hold-look-up", _cfg.GetCVar(WhiteCVars.HoldLookUp), HandleHoldLookUp); // WD EDIT
 
             AddHeader("ui-options-header-interaction-adv");

Content.Client/_White/Standing/LayingDownSystem.cs

@@ -0,0 +1,82 @@
+using Content.Shared._White.Standing;
+using Content.Shared.Buckle;
+using Content.Shared.Rotation;
+using Content.Shared.Standing;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Shared.Timing;
+
+namespace Content.Client._White.Standing;
+
+public sealed class LayingDownSystem : SharedLayingDownSystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly StandingStateSystem _standing = default!;
+    [Dependency] private readonly AnimationPlayerSystem _animation = default!;
+    [Dependency] private readonly SharedBuckleSystem _buckle = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<LayingDownComponent, MoveEvent>(OnMovementInput);
+
+        SubscribeNetworkEvent<CheckAutoGetUpEvent>(OnCheckAutoGetUp);
+    }
+
+    private void OnMovementInput(EntityUid uid, LayingDownComponent component, MoveEvent args)
+    {
+        if (!_timing.IsFirstTimePredicted)
+            return;
+
+        if (!_standing.IsDown(uid))
+            return;
+
+        if (_buckle.IsBuckled(uid))
+            return;
+
+        if (_animation.HasRunningAnimation(uid, "rotate"))
+            return;
+
+        if (!TryComp<TransformComponent>(uid, out var transform)
+            || !TryComp<SpriteComponent>(uid, out var sprite)
+            || !TryComp<RotationVisualsComponent>(uid, out var rotationVisuals))
+        {
+            return;
+        }
+
+        var rotation = transform.LocalRotation + (_eyeManager.CurrentEye.Rotation - (transform.LocalRotation - transform.WorldRotation));
+
+        if (rotation.GetDir() is Direction.SouthEast or Direction.East or Direction.NorthEast or Direction.North)
+        {
+            rotationVisuals.HorizontalRotation = Angle.FromDegrees(270);
+            sprite.Rotation = Angle.FromDegrees(270);
+            return;
+        }
+
+        rotationVisuals.HorizontalRotation = Angle.FromDegrees(90);
+        sprite.Rotation = Angle.FromDegrees(90);
+    }
+
+    private void OnCheckAutoGetUp(CheckAutoGetUpEvent ev, EntitySessionEventArgs args)
+    {
+        if (!_timing.IsFirstTimePredicted)
+            return;
+
+        var uid = GetEntity(ev.User);
+
+        if (!TryComp<TransformComponent>(uid, out var transform) || !TryComp<RotationVisualsComponent>(uid, out var rotationVisuals))
+            return;
+
+        var rotation = transform.LocalRotation + (_eyeManager.CurrentEye.Rotation - (transform.LocalRotation - transform.WorldRotation));
+
+        if (rotation.GetDir() is Direction.SouthEast or Direction.East or Direction.NorthEast or Direction.North)
+        {
+            rotationVisuals.HorizontalRotation = Angle.FromDegrees(270);
+            return;
+        }
+
+        rotationVisuals.HorizontalRotation = Angle.FromDegrees(90);
+    }
+}

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

@@ -60,6 +60,9 @@ public async Task TryStopNukeOpsFromConstantlyFailing()
         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);
@@ -201,6 +204,7 @@ public async Task TryStopNukeOpsFromConstantlyFailing()
 
         //ticker.SetGamePreset((GamePresetPrototype?)null); WD edit
         server.CfgMan.SetCVar(CCVars.GridFill, false);
+        await pair.SetAntagPref("NukeopsCommander", false);
         await pair.CleanReturnAsync();
     }
 }

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;

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

Content.Server/Administration/Systems/AdminVerbSystem.Antags.cs

@@ -44,17 +44,19 @@ 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"),
             Category = VerbCategory.Antag,
             Icon = new SpriteSpecifier.Rsi(new ResPath("/Textures/Structures/Wallmounts/posters.rsi"), "poster5_contraband"),
             Act = () =>
             {
-                _antag.ForceMakeAntag<TraitorRuleComponent>(player, DefaultTraitorRule);
+                _antag.ForceMakeAntag<TraitorRuleComponent>(targetPlayer, DefaultTraitorRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-traitor"),
@@ -83,7 +85,7 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
             Icon = new SpriteSpecifier.Rsi(new("/Textures/Structures/Wallmounts/signs.rsi"), "radiation"),
             Act = () =>
             {
-                _antag.ForceMakeAntag<NukeopsRuleComponent>(player, DefaultNukeOpRule);
+                _antag.ForceMakeAntag<NukeopsRuleComponent>(targetPlayer, DefaultNukeOpRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-nuclear-operative"),
@@ -112,7 +114,7 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
             Icon = new SpriteSpecifier.Rsi(new("/Textures/Interface/Misc/job_icons.rsi"), "HeadRevolutionary"),
             Act = () =>
             {
-                _antag.ForceMakeAntag<RevolutionaryRuleComponent>(player, DefaultRevsRule);
+                _antag.ForceMakeAntag<RevolutionaryRuleComponent>(targetPlayer, DefaultRevsRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-head-rev"),
@@ -123,10 +125,10 @@ private void AddAntagVerbs(GetVerbsEvent<Verb> args)
         {
             Text = Loc.GetString("admin-verb-text-make-thief"),
             Category = VerbCategory.Antag,
-            Icon = new SpriteSpecifier.Rsi(new ResPath("/Textures/Clothing/Hands/Gloves/ihscombat.rsi"), "icon"),
+            Icon = new SpriteSpecifier.Rsi(new ResPath("/Textures/Clothing/Hands/Gloves/Color/black.rsi"), "icon"),
             Act = () =>
             {
-                _antag.ForceMakeAntag<ThiefRuleComponent>(player, DefaultThiefRule);
+                _antag.ForceMakeAntag<ThiefRuleComponent>(targetPlayer, DefaultThiefRule);
             },
             Impact = LogImpact.High,
             Message = Loc.GetString("admin-verb-make-thief"),