Merged files from space-wizards/space-station-14 PR #30111 commit #f3…

…0cb0f

Content.Server/Alert/Click/StopPulling.cs

@@ -20,7 +20,7 @@ public void AlertClicked(EntityUid player)
             if (entManager.TryGetComponent(player, out PullerComponent? puller) &&
                 entManager.TryGetComponent(puller.Pulling, out PullableComponent? pullableComp))
             {
-                ps.TryStopPull(puller.Pulling.Value, pullableComp, user: player);
+                ps.TryLowerGrabStage(puller.Pulling.Value, puller: player, ignoreCombatMode: true);
             }
         }
     }

Content.Server/Body/Systems/RespiratorSystem.cs

@@ -1,5 +1,4 @@
 using Content.Server.Administration.Logs;
-using Content.Server.Atmos;
 using Content.Server.Atmos.EntitySystems;
 using Content.Server.Body.Components;
 using Content.Server.Chemistry.Containers.EntitySystems;
@@ -12,6 +11,8 @@
 using Content.Shared.Mobs.Systems;
 using JetBrains.Annotations;
 using Robust.Shared.Timing;
+using Content.Shared.Movement.Pulling.Systems;
+using Content.Shared.Movement.Pulling.Components;
 
 namespace Content.Server.Body.Systems;
 
@@ -25,7 +26,6 @@ public sealed class RespiratorSystem : EntitySystem
     [Dependency] private readonly BodySystem _bodySystem = default!;
     [Dependency] private readonly DamageableSystem _damageableSys = default!;
     [Dependency] private readonly LungSystem _lungSystem = default!;
-    [Dependency] private readonly PopupSystem _popupSystem = default!;
     [Dependency] private readonly MobStateSystem _mobState = default!;
     [Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
 
@@ -50,6 +50,13 @@ private void OnUnpaused(Entity<RespiratorComponent> ent, ref EntityUnpausedEvent
         ent.Comp.NextUpdate += args.PausedTime;
     }
 
+    public bool CanBreathe(EntityUid uid)
+    {
+        if (TryComp<PullableComponent>(uid, out var pullable) && pullable.GrabStage == GrabStage.Suffocate)
+            return false;
+        return true;
+    }
+
     public override void Update(float frameTime)
     {
         base.Update(frameTime);

Content.Server/Hands/Systems/HandsSystem.cs

@@ -21,6 +21,8 @@
 using Robust.Shared.Player;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
+using Content.Shared.Hands;
+using Content.Shared.Inventory.VirtualItem;
 
 namespace Content.Server.Hands.Systems
 {
@@ -30,7 +32,6 @@ public sealed class HandsSystem : SharedHandsSystem
         [Dependency] private readonly StackSystem _stackSystem = default!;
         [Dependency] private readonly VirtualItemSystem _virtualItemSystem = default!;
         [Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
-        [Dependency] private readonly SharedHandsSystem _handsSystem = default!;
         [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
         [Dependency] private readonly PullingSystem _pullingSystem = default!;
         [Dependency] private readonly ThrowingSystem _throwingSystem = default!;
@@ -88,7 +89,7 @@ private void OnDisarmed(EntityUid uid, HandsComponent component, DisarmedEvent a
 
             // Break any pulls
             if (TryComp(uid, out PullerComponent? puller) && TryComp(puller.Pulling, out PullableComponent? pullable))
-                _pullingSystem.TryStopPull(puller.Pulling.Value, pullable);
+                _pullingSystem.TryStopPull(puller.Pulling.Value, pullable, ignoreGrab: true);
 
             if (!_handsSystem.TryDrop(uid, component.ActiveHand!, null, checkActionBlocker: false))
                 return;
@@ -168,6 +169,18 @@ private bool HandleThrowItem(ICommonSession? playerSession, EntityCoordinates co
             if (playerSession?.AttachedEntity is not {Valid: true} player || !Exists(player))
                 return false;
 
+            if (TryGetActiveItem(player, out var item) && TryComp<VirtualItemComponent>(item, out var virtComp))
+            {
+                var userEv = new VirtualItemDropAttemptEvent(virtComp.BlockingEntity, player, item.Value, true);
+                RaiseLocalEvent(player, userEv);
+
+                var targEv = new VirtualItemDropAttemptEvent(virtComp.BlockingEntity, player, item.Value, true);
+                RaiseLocalEvent(virtComp.BlockingEntity, targEv);
+
+                if (userEv.Cancelled || targEv.Cancelled)
+                    return false;
+            }
+
             return ThrowHeldItem(player, coordinates);
         }
 
@@ -211,6 +224,15 @@ hands.ActiveHandEntity is not { } throwEnt ||
             var ev = new BeforeThrowEvent(throwEnt, direction, throwStrength, player);
             RaiseLocalEvent(player, ref ev);
 
+            if (TryComp<VirtualItemComponent>(throwEnt, out var virt))
+            {
+                var userEv = new VirtualItemThrownEvent(virt.BlockingEntity, player, throwEnt, direction);
+                RaiseLocalEvent(player, userEv);
+
+                var targEv = new VirtualItemThrownEvent(virt.BlockingEntity, player, throwEnt, direction);
+                RaiseLocalEvent(virt.BlockingEntity, targEv);
+            }
+
             if (ev.Cancelled)
                 return true;
 

Content.Server/Implants/SubdermalImplantSystem.cs

@@ -1,4 +1,4 @@
-using Content.Server.Cuffs;
+using Content.Server.Cuffs;
 using Content.Server.Forensics;
 using Content.Server.Humanoid;
 using Content.Server.Implants.Components;
@@ -20,6 +20,7 @@
 using System.Numerics;
 using Content.Shared.Movement.Pulling.Components;
 using Content.Shared.Movement.Pulling.Systems;
+using Content.Shared.Store.Components;
 using Robust.Shared.Collections;
 using Robust.Shared.Map.Components;
 
@@ -107,7 +108,7 @@ private void OnScramImplant(EntityUid uid, SubdermalImplantComponent component,
         // We need stop the user from being pulled so they don't just get "attached" with whoever is pulling them.
         // This can for example happen when the user is cuffed and being pulled.
         if (TryComp<PullableComponent>(ent, out var pull) && _pullingSystem.IsPulled(ent, pull))
-            _pullingSystem.TryStopPull(ent, pull);
+            _pullingSystem.TryStopPull(ent, pull, ignoreGrab: true);
 
         var xform = Transform(ent);
         var targetCoords = SelectRandomTileInRange(xform, implant.TeleportRadius);

Content.Shared/Administration/SharedAdminFrozenSystem.cs

@@ -0,0 +1,89 @@
+using Content.Shared.ActionBlocker;
+using Content.Shared.Emoting;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Item;
+using Content.Shared.Movement.Events;
+using Content.Shared.Movement.Pulling.Components;
+using Content.Shared.Movement.Pulling.Events;
+using Content.Shared.Movement.Pulling.Systems;
+using Content.Shared.Speech;
+using Content.Shared.Throwing;
+
+namespace Content.Shared.Administration;
+
+// TODO deduplicate with BlockMovementComponent
+public abstract class SharedAdminFrozenSystem : EntitySystem
+{
+    [Dependency] private readonly ActionBlockerSystem _blocker = default!;
+    [Dependency] private readonly PullingSystem _pulling = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<AdminFrozenComponent, UseAttemptEvent>(OnAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, PickupAttemptEvent>(OnAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, ThrowAttemptEvent>(OnAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, InteractionAttemptEvent>(OnInteractAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<AdminFrozenComponent, ComponentShutdown>(UpdateCanMove);
+        SubscribeLocalEvent<AdminFrozenComponent, UpdateCanMoveEvent>(OnUpdateCanMove);
+        SubscribeLocalEvent<AdminFrozenComponent, PullAttemptEvent>(OnPullAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, AttackAttemptEvent>(OnAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, ChangeDirectionAttemptEvent>(OnAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, EmoteAttemptEvent>(OnEmoteAttempt);
+        SubscribeLocalEvent<AdminFrozenComponent, SpeakAttemptEvent>(OnSpeakAttempt);
+    }
+
+    private void OnInteractAttempt(Entity<AdminFrozenComponent> ent, ref InteractionAttemptEvent args)
+    {
+        args.Cancelled = true;
+    }
+
+    private void OnSpeakAttempt(EntityUid uid, AdminFrozenComponent component, SpeakAttemptEvent args)
+    {
+        if (!component.Muted)
+            return;
+
+        args.Cancel();
+    }
+
+    private void OnAttempt(EntityUid uid, AdminFrozenComponent component, CancellableEntityEventArgs args)
+    {
+        args.Cancel();
+    }
+
+    private void OnPullAttempt(EntityUid uid, AdminFrozenComponent component, PullAttemptEvent args)
+    {
+        args.Cancelled = true;
+    }
+
+    private void OnStartup(EntityUid uid, AdminFrozenComponent component, ComponentStartup args)
+    {
+        if (TryComp<PullableComponent>(uid, out var pullable))
+        {
+            _pulling.TryStopPull(uid, pullable, ignoreGrab: true);
+        }
+
+        UpdateCanMove(uid, component, args);
+    }
+
+    private void OnUpdateCanMove(EntityUid uid, AdminFrozenComponent component, UpdateCanMoveEvent args)
+    {
+        if (component.LifeStage > ComponentLifeStage.Running)
+            return;
+
+        args.Cancel();
+    }
+
+    private void UpdateCanMove(EntityUid uid, AdminFrozenComponent component, EntityEventArgs args)
+    {
+        _blocker.UpdateCanMove(uid);
+    }
+
+    private void OnEmoteAttempt(EntityUid uid, AdminFrozenComponent component, EmoteAttemptEvent args)
+    {
+        if (component.Muted)
+            args.Cancel();
+    }
+}

Content.Shared/Construction/EntitySystems/AnchorableSystem.cs

@@ -32,7 +32,6 @@ public sealed partial class AnchorableSystem : EntitySystem
     [Dependency] private   readonly TagSystem _tagSystem = default!;
 
     private EntityQuery<PhysicsComponent> _physicsQuery;
-    private EntityQuery<TagComponent> _tagQuery;
 
     public const string Unstackable = "Unstackable";
 
@@ -41,7 +40,6 @@ public override void Initialize()
         base.Initialize();
 
         _physicsQuery = GetEntityQuery<PhysicsComponent>();
-        _tagQuery = GetEntityQuery<TagComponent>();
 
         SubscribeLocalEvent<AnchorableComponent, InteractUsingEvent>(OnInteractUsing,
             before: new[] { typeof(ItemSlotsSystem) }, after: new[] { typeof(SharedConstructionSystem) });
@@ -133,7 +131,7 @@ private void OnAnchorComplete(EntityUid uid, AnchorableComponent component, TryA
 
         if (TryComp<PullableComponent>(uid, out var pullable) && pullable.Puller != null)
         {
-            _pulling.TryStopPull(uid, pullable);
+            _pulling.TryStopPull(uid, pullable, ignoreGrab: true);
         }
 
         // TODO: Anchoring snaps rn anyway!
@@ -330,7 +328,6 @@ public bool AnyUnstackablesAnchoredAt(EntityCoordinates location)
             if (_tagSystem.HasTag(entity.Value, Unstackable, _tagQuery))
             {
                 return true;
-            }
         }
 
         return false;

Content.Shared/Hands/EntitySystems/SharedHandsSystem.Interactions.cs

@@ -3,11 +3,14 @@
 using Content.Shared.Hands.Components;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Input;
+using Content.Shared.Interaction;
 using Content.Shared.Inventory.VirtualItem;
 using Content.Shared.Localizations;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.Map;
 using Robust.Shared.Player;
+using Robust.Shared.Utility;
+using Content.Shared.Hands;
 
 namespace Content.Shared.Hands.EntitySystems;
 
@@ -95,7 +98,25 @@ private void SwapHandsPressed(ICommonSession? session)
     private bool DropPressed(ICommonSession? session, EntityCoordinates coords, EntityUid netEntity)
     {
         if (TryComp(session?.AttachedEntity, out HandsComponent? hands) && hands.ActiveHand != null)
-            TryDrop(session.AttachedEntity.Value, hands.ActiveHand, coords, handsComp: hands);
+        {
+            if (session != null)
+            {
+                var ent = session.AttachedEntity.Value;
+
+                if (TryGetActiveItem(ent, out var item) && TryComp<VirtualItemComponent>(item, out var virtComp))
+                {
+                    var userEv = new VirtualItemDropAttemptEvent(virtComp.BlockingEntity, ent, item.Value, false);
+                    RaiseLocalEvent(ent, userEv);
+
+                    var targEv = new VirtualItemDropAttemptEvent(virtComp.BlockingEntity, ent, item.Value, false);
+                    RaiseLocalEvent(virtComp.BlockingEntity, targEv);
+
+                    if (userEv.Cancelled || targEv.Cancelled)
+                        return false;
+                }
+                TryDrop(ent, hands.ActiveHand, coords, handsComp: hands);
+            }
+        }
 
         // always send to server.
         return false;

Content.Shared/Hands/HandEvents.cs

@@ -148,11 +148,52 @@ public sealed class VirtualItemDeletedEvent : EntityEventArgs
     {
         public EntityUid BlockingEntity;
         public EntityUid User;
+        public EntityUid VirtualItem;
 
-        public VirtualItemDeletedEvent(EntityUid blockingEntity, EntityUid user)
+        public VirtualItemDeletedEvent(EntityUid blockingEntity, EntityUid user, EntityUid virtualItem)
         {
             BlockingEntity = blockingEntity;
             User = user;
+            VirtualItem = virtualItem;
+        }
+    }
+
+    /// <summary>
+    ///     Raised directed on both the blocking entity and user when
+    ///     a virtual hand item is thrown (at least attempted to).
+    /// </summary>
+    public sealed class VirtualItemThrownEvent : EntityEventArgs
+    {
+        public EntityUid BlockingEntity;
+        public EntityUid User;
+        public EntityUid VirtualItem;
+        public Vector2 Direction;
+        public VirtualItemThrownEvent(EntityUid blockingEntity, EntityUid user, EntityUid virtualItem, Vector2 direction)
+        {
+            BlockingEntity = blockingEntity;
+            User = user;
+            VirtualItem = virtualItem;
+            Direction = direction;
+        }
+    }
+
+    /// <summary>
+    ///     Raised directed on both the blocking entity and user when
+    ///     user tries to drop it by keybind.
+    ///     Cancellable.
+    /// </summary>
+    public sealed class VirtualItemDropAttemptEvent : CancellableEntityEventArgs
+    {
+        public EntityUid BlockingEntity;
+        public EntityUid User;
+        public EntityUid VirtualItem;
+        public bool Throw;
+        public VirtualItemDropAttemptEvent(EntityUid blockingEntity, EntityUid user, EntityUid virtualItem, bool thrown)
+        {
+            BlockingEntity = blockingEntity;
+            User = user;
+            VirtualItem = virtualItem;
+            Throw = thrown;
         }
     }
 

Content.Shared/Inventory/VirtualItem/SharedVirtualItemSystem.cs

@@ -4,6 +4,7 @@
 using Content.Shared.Interaction;
 using Content.Shared.Inventory.Events;
 using Content.Shared.Item;
+using Content.Shared.Popups;
 using Robust.Shared.Containers;
 using Robust.Shared.Network;
 using Robust.Shared.Prototypes;
@@ -199,10 +200,10 @@ public bool TrySpawnVirtualItem(EntityUid blockingEnt, EntityUid user, [NotNullW
     /// </summary>
     public void DeleteVirtualItem(Entity<VirtualItemComponent> item, EntityUid user)
     {
-        var userEv = new VirtualItemDeletedEvent(item.Comp.BlockingEntity, user);
+        var userEv = new VirtualItemDeletedEvent(item.Comp.BlockingEntity, user, item.Owner);
         RaiseLocalEvent(user, userEv);
 
-        var targEv = new VirtualItemDeletedEvent(item.Comp.BlockingEntity, user);
+        var targEv = new VirtualItemDeletedEvent(item.Comp.BlockingEntity, user, item.Owner);
         RaiseLocalEvent(item.Comp.BlockingEntity, targEv);
 
         if (TerminatingOrDeleted(item))

Content.Shared/MartialArts/Components/GrabThrownComponent.cs

@@ -0,0 +1,24 @@
+using Content.Shared.Alert;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Content.Shared.Movement.Pulling.Systems;
+using Robust.Shared.Timing;
+using Content.Shared.Damage;
+using Content.Shared.Physics;
+using Robust.Shared.Physics;
+
+namespace Content.Shared.MartialArts.Components;    // Added a new category because im planning to make martials combat soon. And throwing is kinda... Martial-artistic?
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class GrabThrownComponent : Component
+{
+    public DamageSpecifier? DamageOnCollide;
+
+    public DamageSpecifier? WallDamageOnCollide;
+
+    public float? StaminaDamageOnCollide;
+
+    //public int? SavedCollisionMask;
+
+    //public int? SavedCollisionLayer;
+}