Mass Engine Update

Content.Client/Alerts/ClientAlertsSystem.cs

@@ -91,8 +91,8 @@ private void OnPlayerDetached(EntityUid uid, AlertsComponent component, LocalPla
         ClearAlerts?.Invoke(this, EventArgs.Empty);
     }
 
-    public void AlertClicked(AlertType alertType)
+    public void AlertClicked(ProtoId<AlertPrototype> alertType)
     {
-        RaiseNetworkEvent(new ClickAlertEvent(alertType));
+        RaisePredictiveEvent(new ClickAlertEvent(alertType));
     }
 }

Content.Client/Buckle/BuckleSystem.cs

@@ -3,6 +3,7 @@
 using Content.Shared.Buckle.Components;
 using Content.Shared.Rotation;
 using Robust.Client.GameObjects;
+using Robust.Shared.GameStates;
 
 namespace Content.Client.Buckle;
 
@@ -14,37 +15,44 @@ public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<BuckleComponent, AfterAutoHandleStateEvent>(OnBuckleAfterAutoHandleState);
         SubscribeLocalEvent<BuckleComponent, AppearanceChangeEvent>(OnAppearanceChange);
+        SubscribeLocalEvent<StrapComponent, MoveEvent>(OnStrapMoveEvent);
     }
 
-    private void OnBuckleAfterAutoHandleState(EntityUid uid, BuckleComponent component, ref AfterAutoHandleStateEvent args)
+    private void OnStrapMoveEvent(EntityUid uid, StrapComponent component, ref MoveEvent args)
     {
-        ActionBlocker.UpdateCanMove(uid);
+        // I'm moving this to the client-side system, but for the sake of posterity let's keep this comment:
+        // > This is mega cursed. Please somebody save me from Mr Buckle's wild ride
 
-        if (!TryComp<SpriteComponent>(uid, out var ownerSprite))
+        // The nice thing is its still true, this is quite cursed, though maybe not omega cursed anymore.
+        // This code is garbage, it doesn't work with rotated viewports. I need to finally get around to reworking
+        // sprite rendering for entity layers & direction dependent sorting.
+
+        if (args.NewRotation == args.OldRotation)
             return;
 
-        // Adjust draw depth when the chair faces north so that the seat back is drawn over the player.
-        // Reset the draw depth when rotated in any other direction.
-        // TODO when ECSing, make this a visualizer
-        // This code was written before rotatable viewports were introduced, so hard-coding Direction.North
-        // and comparing it against LocalRotation now breaks this in other rotations. This is a FIXME, but
-        // better to get it working for most people before we look at a more permanent solution.
-        if (component is { Buckled: true, LastEntityBuckledTo: { } } &&
-            Transform(component.LastEntityBuckledTo.Value).LocalRotation.GetCardinalDir() == Direction.North &&
-            TryComp<SpriteComponent>(component.LastEntityBuckledTo, out var buckledSprite))
-        {
-            component.OriginalDrawDepth ??= ownerSprite.DrawDepth;
-            ownerSprite.DrawDepth = buckledSprite.DrawDepth - 1;
+        if (!TryComp<SpriteComponent>(uid, out var strapSprite))
             return;
-        }
 
-        // If here, we're not turning north and should restore the saved draw depth.
-        if (component.OriginalDrawDepth.HasValue)
+        var isNorth = Transform(uid).LocalRotation.GetCardinalDir() == Direction.North;
+        foreach (var buckledEntity in component.BuckledEntities)
         {
-            ownerSprite.DrawDepth = component.OriginalDrawDepth.Value;
-            component.OriginalDrawDepth = null;
+            if (!TryComp<BuckleComponent>(buckledEntity, out var buckle))
+                continue;
+
+            if (!TryComp<SpriteComponent>(buckledEntity, out var buckledSprite))
+                continue;
+
+            if (isNorth)
+            {
+                buckle.OriginalDrawDepth ??= buckledSprite.DrawDepth;
+                buckledSprite.DrawDepth = strapSprite.DrawDepth - 1;
+            }
+            else if (buckle.OriginalDrawDepth.HasValue)
+            {
+                buckledSprite.DrawDepth = buckle.OriginalDrawDepth.Value;
+                buckle.OriginalDrawDepth = null;
+            }
         }
     }
 

Content.Client/Movement/Systems/WaddleAnimationSystem.cs

@@ -32,7 +32,7 @@ public override void Initialize()
         SubscribeLocalEvent<WaddleAnimationComponent, AnimationCompletedEvent>(OnAnimationCompleted);
         SubscribeLocalEvent<WaddleAnimationComponent, StunnedEvent>(OnStunned);
         SubscribeLocalEvent<WaddleAnimationComponent, KnockedDownEvent>(OnKnockedDown);
-        SubscribeLocalEvent<WaddleAnimationComponent, BuckleChangeEvent>(OnBuckleChange);
+        SubscribeLocalEvent<WaddleAnimationComponent, BuckledEvent>(OnBuckled);
     }
 
     private void OnMovementInput(EntityUid entity, WaddleAnimationComponent component, MoveInputEvent args)
@@ -148,7 +148,7 @@ private void OnKnockedDown(EntityUid uid, WaddleAnimationComponent component, Kn
         StopWaddling(uid, component);
     }
 
-    private void OnBuckleChange(EntityUid uid, WaddleAnimationComponent component, BuckleChangeEvent args)
+    private void OnBuckled(EntityUid uid, WaddleAnimationComponent component, BuckledEvent args)
     {
         StopWaddling(uid, component);
     }

Content.Client/Revenant/RevenantSystem.cs

@@ -1,5 +1,4 @@
 using Content.Client.Alerts;
-using Content.Shared.Alert;
 using Content.Shared.Revenant;
 using Content.Shared.Revenant.Components;
 using Robust.Client.GameObjects;
@@ -42,7 +41,7 @@ private void OnAppearanceChange(EntityUid uid, RevenantComponent component, ref
 
     private void OnUpdateAlert(Entity<RevenantComponent> ent, ref UpdateAlertSpriteEvent args)
     {
-        if (args.Alert.AlertType != AlertType.Essence)
+        if (args.Alert.ID != ent.Comp.EssenceAlert)
             return;
 
         var sprite = args.SpriteViewEnt.Comp;

Content.Client/UserInterface/Systems/Alerts/AlertsUIController.cs

@@ -7,6 +7,7 @@
 using Robust.Client.Player;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controllers;
+using Robust.Shared.Prototypes;
 
 namespace Content.Client.UserInterface.Systems.Alerts;
 
@@ -43,7 +44,7 @@ private void OnScreenLoad()
         SyncAlerts();
     }
 
-    private void OnAlertPressed(object? sender, AlertType e)
+    private void OnAlertPressed(object? sender, ProtoId<AlertPrototype> e)
     {
         _alertsSystem?.AlertClicked(e);
     }

Content.Client/UserInterface/Systems/Alerts/Widgets/AlertsUI.xaml.cs

@@ -4,6 +4,7 @@
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Input;
+using Robust.Shared.Prototypes;
 
 namespace Content.Client.UserInterface.Systems.Alerts.Widgets;
 
@@ -21,8 +22,10 @@ public AlertsUI()
         RobustXamlLoader.Load(this);
     }
 
-    public void SyncControls(AlertsSystem alertsSystem, AlertOrderPrototype? alertOrderPrototype,
-        IReadOnlyDictionary<AlertKey, AlertState> alertStates)
+    public void SyncControls(AlertsSystem alertsSystem,
+        AlertOrderPrototype? alertOrderPrototype,
+        IReadOnlyDictionary<AlertKey,
+        AlertState> alertStates)
     {
         // remove any controls with keys no longer present
         if (SyncRemoveControls(alertStates))
@@ -46,7 +49,7 @@ public void ClearAllControls()
         _alertControls.Clear();
     }
 
-    public event EventHandler<AlertType>? AlertPressed;
+    public event EventHandler<ProtoId<AlertPrototype>>? AlertPressed;
 
     private bool SyncRemoveControls(IReadOnlyDictionary<AlertKey, AlertState> alertStates)
     {
@@ -88,7 +91,7 @@ private void SyncUpdateControls(AlertsSystem alertsSystem, AlertOrderPrototype?
             }
 
             if (_alertControls.TryGetValue(newAlert.AlertKey, out var existingAlertControl) &&
-                existingAlertControl.Alert.AlertType == newAlert.AlertType)
+                existingAlertControl.Alert.ID == newAlert.ID)
             {
                 // key is the same, simply update the existing control severity / cooldown
                 existingAlertControl.SetSeverity(alertState.Severity);
@@ -155,6 +158,6 @@ private void AlertControlPressed(BaseButton.ButtonEventArgs args)
         if (args.Event.Function != EngineKeyFunctions.UIClick)
             return;
 
-        AlertPressed?.Invoke(this, control.Alert.AlertType);
+        AlertPressed?.Invoke(this, control.Alert.ID);
     }
 }

Content.Client/UserInterface/Systems/Storage/Controls/ItemGridPiece.cs

@@ -9,7 +9,7 @@
 
 namespace Content.Client.UserInterface.Systems.Storage.Controls;
 
-public sealed class ItemGridPiece : Control
+public sealed class ItemGridPiece : Control, IEntityControl
 {
     private readonly IEntityManager _entityManager;
     private readonly StorageUIController _storageController;
@@ -287,6 +287,8 @@ public static Vector2 GetCenterOffset(Entity<ItemComponent?> entity, ItemStorage
         var actualSize = new Vector2(boxSize.X + 1, boxSize.Y + 1);
         return actualSize * new Vector2i(8, 8);
     }
+
+    public EntityUid? UiEntity => Entity;
 }
 
 public enum ItemGridPieceMarks

Content.Client/Weather/WeatherSystem.cs

@@ -124,9 +124,9 @@ protected override void Run(EntityUid uid, WeatherData weather, WeatherPrototype
         comp.Occlusion = occlusion;
     }
 
-    protected override bool SetState(WeatherState state, WeatherComponent comp, WeatherData weather, WeatherPrototype weatherProto)
+    protected override bool SetState(EntityUid uid, WeatherState state, WeatherComponent comp, WeatherData weather, WeatherPrototype weatherProto)
     {
-        if (!base.SetState(state, comp, weather, weatherProto))
+        if (!base.SetState(uid, state, comp, weather, weatherProto))
             return false;
 
         if (!Timing.IsFirstTimePredicted)
@@ -164,7 +164,7 @@ private void OnWeatherHandleState(EntityUid uid, WeatherComponent component, ref
                 continue;
 
             // New weather
-            StartWeather(component, ProtoMan.Index<WeatherPrototype>(proto), weather.EndTime);
+            StartWeather(uid, component, ProtoMan.Index<WeatherPrototype>(proto), weather.EndTime);
         }
     }
 }

Content.IntegrationTests/Tests/Buckle/BuckleDragTest.cs

@@ -0,0 +1,56 @@
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Buckle;
+using Content.Shared.Buckle.Components;
+using Content.Shared.Input;
+using Content.Shared.Movement.Pulling.Components;
+
+namespace Content.IntegrationTests.Tests.Buckle;
+
+public sealed class BuckleDragTest : InteractionTest
+{
+    // Check that dragging a buckled player unbuckles them.
+    [Test]
+    public async Task BucklePullTest()
+    {
+        var urist = await SpawnTarget("MobHuman");
+        var sUrist = ToServer(urist);
+        await SpawnTarget("Chair");
+
+        var buckle = Comp<BuckleComponent>(urist);
+        var strap = Comp<StrapComponent>(Target);
+        var puller = Comp<PullerComponent>(Player);
+        var pullable = Comp<PullableComponent>(urist);
+
+#pragma warning disable RA0002
+        buckle.Delay = TimeSpan.Zero;
+#pragma warning restore RA0002
+
+        // Initially not buckled to the chair and not pulling anything
+        Assert.That(buckle.Buckled, Is.False);
+        Assert.That(buckle.BuckledTo, Is.Null);
+        Assert.That(strap.BuckledEntities, Is.Empty);
+        Assert.That(puller.Pulling, Is.Null);
+        Assert.That(pullable.Puller, Is.Null);
+        Assert.That(pullable.BeingPulled, Is.False);
+
+        // Strap the human to the chair
+        Assert.That(Server.System<SharedBuckleSystem>().TryBuckle(sUrist, SPlayer, STarget.Value));
+        await RunTicks(5);
+        Assert.That(buckle.Buckled, Is.True);
+        Assert.That(buckle.BuckledTo, Is.EqualTo(STarget));
+        Assert.That(strap.BuckledEntities, Is.EquivalentTo(new[]{sUrist}));
+        Assert.That(puller.Pulling, Is.Null);
+        Assert.That(pullable.Puller, Is.Null);
+        Assert.That(pullable.BeingPulled, Is.False);
+
+        // Start pulling, and thus unbuckle them
+        await PressKey(ContentKeyFunctions.TryPullObject, cursorEntity:urist);
+        await RunTicks(5);
+        Assert.That(buckle.Buckled, Is.False);
+        Assert.That(buckle.BuckledTo, Is.Null);
+        Assert.That(strap.BuckledEntities, Is.Empty);
+        Assert.That(puller.Pulling, Is.EqualTo(sUrist));
+        Assert.That(pullable.Puller, Is.EqualTo(SPlayer));
+        Assert.That(pullable.BeingPulled, Is.True);
+    }
+}

Content.IntegrationTests/Tests/Buckle/BuckleTest.Interact.cs

@@ -0,0 +1,108 @@
+using Content.Shared.Buckle;
+using Content.Shared.Buckle.Components;
+using Content.Shared.Interaction;
+using Robust.Server.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+
+namespace Content.IntegrationTests.Tests.Buckle;
+
+public sealed partial class BuckleTest
+{
+    [Test]
+    public async Task BuckleInteractUnbuckleOther()
+    {
+        await using var pair = await PoolManager.GetServerClient();
+        var server = pair.Server;
+
+        var entMan = server.ResolveDependency<IServerEntityManager>();
+        var buckleSystem = entMan.System<SharedBuckleSystem>();
+
+        EntityUid user = default;
+        EntityUid victim = default;
+        EntityUid chair = default;
+        BuckleComponent buckle = null;
+        StrapComponent strap = null;
+
+        await server.WaitAssertion(() =>
+        {
+            user = entMan.SpawnEntity(BuckleDummyId, MapCoordinates.Nullspace);
+            victim = entMan.SpawnEntity(BuckleDummyId, MapCoordinates.Nullspace);
+            chair = entMan.SpawnEntity(StrapDummyId, MapCoordinates.Nullspace);
+
+            Assert.That(entMan.TryGetComponent(victim, out buckle));
+            Assert.That(entMan.TryGetComponent(chair, out strap));
+
+#pragma warning disable RA0002
+            buckle.Delay = TimeSpan.Zero;
+#pragma warning restore RA0002
+
+            // Buckle victim to chair
+            Assert.That(buckleSystem.TryBuckle(victim, user, chair, buckle));
+            Assert.Multiple(() =>
+            {
+                Assert.That(buckle.BuckledTo, Is.EqualTo(chair), "Victim did not get buckled to the chair.");
+                Assert.That(buckle.Buckled, "Victim is not buckled.");
+                Assert.That(strap.BuckledEntities, Does.Contain(victim), "Chair does not have victim buckled to it.");
+            });
+
+            // InteractHand with chair to unbuckle victim
+            entMan.EventBus.RaiseLocalEvent(chair, new InteractHandEvent(user, chair));
+            Assert.Multiple(() =>
+            {
+                Assert.That(buckle.BuckledTo, Is.Null);
+                Assert.That(buckle.Buckled, Is.False);
+                Assert.That(strap.BuckledEntities, Does.Not.Contain(victim));
+            });
+        });
+
+        await pair.CleanReturnAsync();
+    }
+
+    [Test]
+    public async Task BuckleInteractBuckleUnbuckleSelf()
+    {
+        await using var pair = await PoolManager.GetServerClient();
+        var server = pair.Server;
+
+        var entMan = server.ResolveDependency<IServerEntityManager>();
+
+        EntityUid user = default;
+        EntityUid chair = default;
+        BuckleComponent buckle = null;
+        StrapComponent strap = null;
+
+        await server.WaitAssertion(() =>
+        {
+            user = entMan.SpawnEntity(BuckleDummyId, MapCoordinates.Nullspace);
+            chair = entMan.SpawnEntity(StrapDummyId, MapCoordinates.Nullspace);
+
+            Assert.That(entMan.TryGetComponent(user, out buckle));
+            Assert.That(entMan.TryGetComponent(chair, out strap));
+
+#pragma warning disable RA0002
+            buckle.Delay = TimeSpan.Zero;
+#pragma warning restore RA0002
+
+            // Buckle user to chair
+            entMan.EventBus.RaiseLocalEvent(chair, new InteractHandEvent(user, chair));
+            Assert.Multiple(() =>
+            {
+                Assert.That(buckle.BuckledTo, Is.EqualTo(chair), "Victim did not get buckled to the chair.");
+                Assert.That(buckle.Buckled, "Victim is not buckled.");
+                Assert.That(strap.BuckledEntities, Does.Contain(user), "Chair does not have victim buckled to it.");
+            });
+
+            // InteractHand with chair to unbuckle
+            entMan.EventBus.RaiseLocalEvent(chair, new InteractHandEvent(user, chair));
+            Assert.Multiple(() =>
+            {
+                Assert.That(buckle.BuckledTo, Is.Null);
+                Assert.That(buckle.Buckled, Is.False);
+                Assert.That(strap.BuckledEntities, Does.Not.Contain(user));
+            });
+        });
+
+        await pair.CleanReturnAsync();
+    }
+}