Decouple interactions from hands, cleanup old events, add new fears (#28393)

* ok basic shit

* second part

* pretend it isn't real it can't hurt you.

* 👁️ 👁️

* shadowcommander review

Content.Client/Guidebook/GuidebookSystem.cs

@@ -148,7 +148,7 @@ public sealed class GuidebookSystem : EntitySystem
 
     public void FakeClientActivateInWorld(EntityUid activated)
     {
-        var activateMsg = new ActivateInWorldEvent(GetGuidebookUser(), activated);
+        var activateMsg = new ActivateInWorldEvent(GetGuidebookUser(), activated, true);
         RaiseLocalEvent(activated, activateMsg);
     }
 

Content.IntegrationTests/Tests/Buckle/BuckleTest.cs

@@ -29,6 +29,7 @@ namespace Content.IntegrationTests.Tests.Buckle
   components:
   - type: Buckle
   - type: Hands
+  - type: ComplexInteraction
   - type: InputMover
   - type: Body
     prototype: Human

Content.IntegrationTests/Tests/GameObjects/Components/ActionBlocking/HandCuffTest.cs

@@ -24,6 +24,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.ActionBlocking
   components:
   - type: Cuffable
   - type: Hands
+  - type: ComplexInteraction
   - type: Body
     prototype: Human
 

Content.IntegrationTests/Tests/Interaction/Click/InteractionSystemTests.cs

@@ -4,6 +4,7 @@ using Content.Server.Interaction;
 using Content.Shared.Hands.Components;
 using Content.Shared.Hands.EntitySystems;
 using Content.Shared.Interaction;
+using Content.Shared.Interaction.Components;
 using Content.Shared.Item;
 using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
@@ -64,6 +65,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
             {
                 user = sEntities.SpawnEntity(null, coords);
                 sEntities.EnsureComponent<HandsComponent>(user);
+                sEntities.EnsureComponent<ComplexInteractionComponent>(user);
                 handSys.AddHand(user, "hand", HandLocation.Left);
                 target = sEntities.SpawnEntity(null, coords);
                 item = sEntities.SpawnEntity(null, coords);
@@ -205,6 +207,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
             {
                 user = sEntities.SpawnEntity(null, coords);
                 sEntities.EnsureComponent<HandsComponent>(user);
+                sEntities.EnsureComponent<ComplexInteractionComponent>(user);
                 handSys.AddHand(user, "hand", HandLocation.Left);
                 target = sEntities.SpawnEntity(null, new MapCoordinates(new Vector2(SharedInteractionSystem.InteractionRange - 0.1f, 0), mapId));
                 item = sEntities.SpawnEntity(null, coords);
@@ -347,6 +350,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
             {
                 user = sEntities.SpawnEntity(null, coords);
                 sEntities.EnsureComponent<HandsComponent>(user);
+                sEntities.EnsureComponent<ComplexInteractionComponent>(user);
                 handSys.AddHand(user, "hand", HandLocation.Left);
                 target = sEntities.SpawnEntity(null, coords);
                 item = sEntities.SpawnEntity(null, coords);

Content.IntegrationTests/Tests/Interaction/InteractionTest.cs

@@ -137,6 +137,7 @@ public abstract partial class InteractionTest
     prototype: Aghost
   - type: DoAfter
   - type: Hands
+  - type: ComplexInteraction
   - type: MindContainer
   - type: Stripping
   - type: Tag

Content.IntegrationTests/Tests/VendingMachineRestockTest.cs

@@ -27,6 +27,7 @@ namespace Content.IntegrationTests.Tests
   id: HumanVendingDummy
   components:
   - type: Hands
+  - type: ComplexInteraction
   - type: Body
     prototype: Human
 

Content.Server/Actions/ActionOnInteractSystem.cs

@@ -39,7 +39,7 @@ public sealed class ActionOnInteractSystem : EntitySystem
 
     private void OnActivate(EntityUid uid, ActionOnInteractComponent component, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         if (component.ActionEntities is not {} actionEnts)

Content.Server/Atmos/EntitySystems/FlammableSystem.cs

@@ -155,7 +155,7 @@ namespace Content.Server.Atmos.EntitySystems
 
         private void OnExtinguishActivateInWorld(EntityUid uid, ExtinguishOnInteractComponent component, ActivateInWorldEvent args)
         {
-            if (args.Handled)
+            if (args.Handled || !args.Complex)
                 return;
 
             if (!TryComp(uid, out FlammableComponent? flammable))

Content.Server/Atmos/Monitor/Systems/AirAlarmSystem.cs

@@ -246,6 +246,9 @@ public sealed class AirAlarmSystem : EntitySystem
 
     private void OnActivate(EntityUid uid, AirAlarmComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         if (TryComp<WiresPanelComponent>(uid, out var panel) && panel.Open)
         {
             args.Handled = false;

Content.Server/Atmos/Piping/Binary/EntitySystems/GasPressurePumpSystem.cs

@@ -103,6 +103,9 @@ namespace Content.Server.Atmos.Piping.Binary.EntitySystems
 
         private void OnPumpActivate(EntityUid uid, GasPressurePumpComponent pump, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
                 return;
 

Content.Server/Atmos/Piping/Binary/EntitySystems/GasValveSystem.cs

@@ -52,8 +52,12 @@ namespace Content.Server.Atmos.Piping.Binary.EntitySystems
 
         private void OnActivate(EntityUid uid, GasValveComponent component, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             Toggle(uid, component);
             _audio.PlayPvs(component.ValveSound, uid, AudioParams.Default.WithVariation(0.25f));
+            args.Handled = true;
         }
 
         public void Set(EntityUid uid, GasValveComponent component, bool value)

Content.Server/Atmos/Piping/Binary/EntitySystems/GasVolumePumpSystem.cs

@@ -133,6 +133,9 @@ namespace Content.Server.Atmos.Piping.Binary.EntitySystems
 
         private void OnPumpActivate(EntityUid uid, GasVolumePumpComponent pump, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
                 return;
 

Content.Server/Atmos/Piping/Trinary/EntitySystems/GasFilterSystem.cs

@@ -99,6 +99,9 @@ namespace Content.Server.Atmos.Piping.Trinary.EntitySystems
 
         private void OnFilterActivate(EntityUid uid, GasFilterComponent filter, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
                 return;
 

Content.Server/Atmos/Piping/Trinary/EntitySystems/GasMixerSystem.cs

@@ -139,6 +139,9 @@ namespace Content.Server.Atmos.Piping.Trinary.EntitySystems
 
         private void OnMixerActivate(EntityUid uid, GasMixerComponent mixer, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
                 return;
 

Content.Server/Atmos/Piping/Unary/EntitySystems/GasCanisterSystem.cs

@@ -201,6 +201,9 @@ public sealed class GasCanisterSystem : EntitySystem
 
     private void OnCanisterActivate(EntityUid uid, GasCanisterComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         if (!TryComp<ActorComponent>(args.User, out var actor))
             return;
 

Content.Server/Atmos/Piping/Unary/EntitySystems/GasOutletInjectorSystem.cs

@@ -33,8 +33,12 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
 
         private void OnActivate(EntityUid uid, GasOutletInjectorComponent component, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             component.Enabled = !component.Enabled;
             UpdateAppearance(uid, component);
+            args.Handled = true;
         }
 
         public void UpdateAppearance(EntityUid uid, GasOutletInjectorComponent component, AppearanceComponent? appearance = null)

Content.Server/CardboardBox/CardboardBoxSystem.cs

@@ -36,7 +36,6 @@ public sealed class CardboardBoxSystem : SharedCardboardBoxSystem
         SubscribeLocalEvent<CardboardBoxComponent, StorageAfterCloseEvent>(AfterStorageClosed);
         SubscribeLocalEvent<CardboardBoxComponent, GetAdditionalAccessEvent>(OnGetAdditionalAccess);
         SubscribeLocalEvent<CardboardBoxComponent, ActivateInWorldEvent>(OnInteracted);
-        SubscribeLocalEvent<CardboardBoxComponent, InteractedNoHandEvent>(OnNoHandInteracted);
         SubscribeLocalEvent<CardboardBoxComponent, EntInsertedIntoContainerMessage>(OnEntInserted);
         SubscribeLocalEvent<CardboardBoxComponent, EntRemovedFromContainerMessage>(OnEntRemoved);
 
@@ -45,9 +44,18 @@ public sealed class CardboardBoxSystem : SharedCardboardBoxSystem
 
     private void OnInteracted(EntityUid uid, CardboardBoxComponent component, ActivateInWorldEvent args)
     {
+        if (args.Handled)
+            return;
+
         if (!TryComp<EntityStorageComponent>(uid, out var box))
             return;
 
+        if (!args.Complex)
+        {
+            if (box.Open || !box.Contents.Contains(args.User))
+                return;
+        }
+
         args.Handled = true;
         _storage.ToggleOpen(args.User, uid, box);
 
@@ -58,15 +66,6 @@ public sealed class CardboardBoxSystem : SharedCardboardBoxSystem
         }
     }
 
-    private void OnNoHandInteracted(EntityUid uid, CardboardBoxComponent component, InteractedNoHandEvent args)
-    {
-        //Free the mice please
-        if (!TryComp<EntityStorageComponent>(uid, out var box) || box.Open || !box.Contents.Contains(args.User))
-            return;
-
-        _storage.OpenStorage(uid);
-    }
-
     private void OnGetAdditionalAccess(EntityUid uid, CardboardBoxComponent component, ref GetAdditionalAccessEvent args)
     {
         if (component.Mover == null)

Content.Server/DeviceLinking/Systems/SignalSwitchSystem.cs

@@ -26,7 +26,7 @@ public sealed class SignalSwitchSystem : EntitySystem
 
     private void OnActivated(EntityUid uid, SignalSwitchComponent comp, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         comp.State = !comp.State;

Content.Server/Disposal/Mailing/MailingUnitSystem.cs

@@ -152,6 +152,9 @@ public sealed class MailingUnitSystem : EntitySystem
 
     private void HandleActivate(EntityUid uid, MailingUnitComponent component, ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
         {
             return;

Content.Server/Disposal/Unit/EntitySystems/DisposalUnitSystem.cs

@@ -263,6 +263,9 @@ public sealed class DisposalUnitSystem : SharedDisposalUnitSystem
 
     private void OnActivate(EntityUid uid, SharedDisposalUnitComponent component, ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         if (!TryComp(args.User, out ActorComponent? actor))
         {
             return;

Content.Server/Doors/Systems/AirlockSystem.cs

@@ -67,6 +67,9 @@ public sealed class AirlockSystem : SharedAirlockSystem
 
     private void OnActivate(EntityUid uid, AirlockComponent component, ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         if (TryComp<WiresPanelComponent>(uid, out var panel) &&
             panel.Open &&
             TryComp<ActorComponent>(args.User, out var actor))

Content.Server/Explosion/EntitySystems/TriggerSystem.cs

@@ -218,6 +218,9 @@ namespace Content.Server.Explosion.EntitySystems
 
         private void OnActivate(EntityUid uid, TriggerOnActivateComponent component, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             Trigger(uid, args.User);
             args.Handled = true;
         }

Content.Server/Fluids/EntitySystems/AbsorbentSystem.cs

@@ -34,7 +34,7 @@ public sealed class AbsorbentSystem : SharedAbsorbentSystem
         base.Initialize();
         SubscribeLocalEvent<AbsorbentComponent, ComponentInit>(OnAbsorbentInit);
         SubscribeLocalEvent<AbsorbentComponent, AfterInteractEvent>(OnAfterInteract);
-        SubscribeLocalEvent<AbsorbentComponent, InteractNoHandEvent>(OnInteractNoHand);
+        SubscribeLocalEvent<AbsorbentComponent, UserActivateInWorldEvent>(OnActivateInWorld);
         SubscribeLocalEvent<AbsorbentComponent, SolutionContainerChangedEvent>(OnAbsorbentSolutionChange);
     }
 
@@ -84,12 +84,12 @@ public sealed class AbsorbentSystem : SharedAbsorbentSystem
         Dirty(uid, component);
     }
 
-    private void OnInteractNoHand(EntityUid uid, AbsorbentComponent component, InteractNoHandEvent args)
+    private void OnActivateInWorld(EntityUid uid, AbsorbentComponent component, UserActivateInWorldEvent args)
     {
-        if (args.Handled || args.Target == null)
+        if (args.Handled)
             return;
 
-        Mop(uid, args.Target.Value, uid, component);
+        Mop(uid, args.Target, uid, component);
         args.Handled = true;
     }
 

Content.Server/Gatherable/GatherableSystem.cs

@@ -38,10 +38,14 @@ public sealed partial class GatherableSystem : EntitySystem
 
     private void OnActivate(Entity<GatherableComponent> gatherable, ref ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         if (gatherable.Comp.ToolWhitelist?.IsValid(args.User, EntityManager) != true)
             return;
 
         Gather(gatherable, args.User);
+        args.Handled = true;
     }
 
     public void Gather(EntityUid gatheredUid, EntityUid? gatherer = null, GatherableComponent? component = null)

Content.Server/Light/EntitySystems/HandheldLightSystem.cs

@@ -126,7 +126,7 @@ namespace Content.Server.Light.EntitySystems
 
         private void OnActivate(Entity<HandheldLightComponent> ent, ref ActivateInWorldEvent args)
         {
-            if (args.Handled || !ent.Comp.ToggleOnInteract)
+            if (args.Handled || !args.Complex || !ent.Comp.ToggleOnInteract)
                 return;
 
             if (ToggleStatus(args.User, ent))

Content.Server/Mech/Equipment/EntitySystems/MechGrabberSystem.cs

@@ -40,7 +40,7 @@ public sealed class MechGrabberSystem : EntitySystem
         SubscribeLocalEvent<MechGrabberComponent, MechEquipmentRemovedEvent>(OnEquipmentRemoved);
         SubscribeLocalEvent<MechGrabberComponent, AttemptRemoveMechEquipmentEvent>(OnAttemptRemove);
 
-        SubscribeLocalEvent<MechGrabberComponent, InteractNoHandEvent>(OnInteract);
+        SubscribeLocalEvent<MechGrabberComponent, UserActivateInWorldEvent>(OnInteract);
         SubscribeLocalEvent<MechGrabberComponent, GrabberDoAfterEvent>(OnMechGrab);
     }
 
@@ -123,10 +123,11 @@ public sealed class MechGrabberSystem : EntitySystem
         args.States.Add(GetNetEntity(uid), state);
     }
 
-    private void OnInteract(EntityUid uid, MechGrabberComponent component, InteractNoHandEvent args)
+    private void OnInteract(EntityUid uid, MechGrabberComponent component, UserActivateInWorldEvent args)
     {
-        if (args.Handled || args.Target is not {} target)
+        if (args.Handled)
             return;
+        var target = args.Target;
 
         if (args.Target == args.User || component.DoAfter != null)
             return;

Content.Server/Nutrition/EntitySystems/SmokingSystem.Cigar.cs

@@ -18,7 +18,7 @@ namespace Content.Server.Nutrition.EntitySystems
 
         private void OnCigarActivatedEvent(Entity<CigarComponent> entity, ref ActivateInWorldEvent args)
         {
-            if (args.Handled)
+            if (args.Handled || !args.Complex)
                 return;
 
             if (!EntityManager.TryGetComponent(entity, out SmokableComponent? smokable))

Content.Server/Pinpointer/PinpointerSystem.cs

@@ -45,10 +45,15 @@ public sealed class PinpointerSystem : SharedPinpointerSystem
 
     private void OnActivate(EntityUid uid, PinpointerComponent component, ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         TogglePinpointer(uid, component);
 
         if (!component.CanRetarget)
             LocateTarget(uid, component);
+
+        args.Handled = true;
     }
 
     private void OnLocateTarget(ref FTLCompletedEvent ev)

Content.Server/Radiation/Systems/GeigerSystem.cs

@@ -35,7 +35,7 @@ public sealed class GeigerSystem : SharedGeigerSystem
 
     private void OnActivate(Entity<GeigerComponent> geiger, ref ActivateInWorldEvent args)
     {
-        if (args.Handled || geiger.Comp.AttachedToSuit)
+        if (args.Handled || !args.Complex || geiger.Comp.AttachedToSuit)
             return;
         args.Handled = true;
 

Content.Server/Radio/EntitySystems/JammerSystem.cs

@@ -67,6 +67,9 @@ public sealed class JammerSystem : SharedJammerSystem
 
     private void OnActivate(EntityUid uid, RadioJammerComponent comp, ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         var activated = !HasComp<ActiveRadioJammerComponent>(uid) &&
             _powerCell.TryGetBatteryFromSlot(uid, out var battery) &&
             battery.CurrentCharge > GetCurrentWattage(comp);

Content.Server/Radio/EntitySystems/RadioDeviceSystem.cs

@@ -81,6 +81,9 @@ public sealed class RadioDeviceSystem : EntitySystem
     #region Toggling
     private void OnActivateMicrophone(EntityUid uid, RadioMicrophoneComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         if (!component.ToggleOnInteract)
             return;
 
@@ -90,6 +93,9 @@ public sealed class RadioDeviceSystem : EntitySystem
 
     private void OnActivateSpeaker(EntityUid uid, RadioSpeakerComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         if (!component.ToggleOnInteract)
             return;
 

Content.Server/Revenant/EntitySystems/RevenantSystem.Abilities.cs

@@ -43,7 +43,7 @@ public sealed partial class RevenantSystem
 
     private void InitializeAbilities()
     {
-        SubscribeLocalEvent<RevenantComponent, InteractNoHandEvent>(OnInteract);
+        SubscribeLocalEvent<RevenantComponent, UserActivateInWorldEvent>(OnInteract);
         SubscribeLocalEvent<RevenantComponent, SoulEvent>(OnSoulSearch);
         SubscribeLocalEvent<RevenantComponent, HarvestEvent>(OnHarvest);
 
@@ -53,11 +53,14 @@ public sealed partial class RevenantSystem
         SubscribeLocalEvent<RevenantComponent, RevenantMalfunctionActionEvent>(OnMalfunctionAction);
     }
 
-    private void OnInteract(EntityUid uid, RevenantComponent component, InteractNoHandEvent args)
+    private void OnInteract(EntityUid uid, RevenantComponent component, UserActivateInWorldEvent args)
     {
-        if (args.Target == args.User || args.Target == null)
+        if (args.Handled)
             return;
-        var target = args.Target.Value;
+
+        if (args.Target == args.User)
+            return;
+        var target = args.Target;
 
         if (HasComp<PoweredLightComponent>(target))
         {
@@ -78,6 +81,8 @@ public sealed partial class RevenantSystem
         {
             BeginHarvestDoAfter(uid, target, component, essence);
         }
+
+        args.Handled = true;
     }
 
     private void BeginSoulSearchDoAfter(EntityUid uid, EntityUid target, RevenantComponent revenant)

Content.Server/Shuttles/Systems/ThrusterSystem.cs

@@ -128,15 +128,20 @@ public sealed class ThrusterSystem : EntitySystem
 
     private void OnActivateThruster(EntityUid uid, ThrusterComponent component, ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         component.Enabled ^= true;
 
         if (!component.Enabled)
         {
             DisableThruster(uid, component);
+            args.Handled = true;
         }
         else if (CanEnable(uid, component))
         {
             EnableThruster(uid, component);
+            args.Handled = true;
         }
     }
 

Content.Server/Tabletop/TabletopSystem.cs

@@ -141,6 +141,9 @@ namespace Content.Server.Tabletop
 
         private void OnTabletopActivate(EntityUid uid, TabletopGameComponent component, ActivateInWorldEvent args)
         {
+            if (args.Handled || !args.Complex)
+                return;
+
             // Check that a player is attached to the entity.
             if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
                 return;

Content.Server/Zombies/ZombieSystem.Transform.cs

@@ -21,6 +21,7 @@ using Content.Shared.Damage;
 using Content.Shared.Hands.Components;
 using Content.Shared.Hands.EntitySystems;
 using Content.Shared.Humanoid;
+using Content.Shared.Interaction.Components;
 using Content.Shared.Mobs;
 using Content.Shared.Mobs.Components;
 using Content.Shared.Mobs.Systems;
@@ -106,6 +107,7 @@ namespace Content.Server.Zombies
             RemComp<ReproductiveComponent>(target);
             RemComp<ReproductivePartnerComponent>(target);
             RemComp<LegsParalyzedComponent>(target);
+            RemComp<ComplexInteractionComponent>(target);
 
             //funny voice
             var accentType = "zombie";

Content.Shared/ActionBlocker/ActionBlockerSystem.cs

@@ -96,9 +96,9 @@ namespace Content.Shared.ActionBlocker
         ///     involve using a held entity. In the majority of cases, systems that provide interactions will not need
         ///     to check this themselves.
         /// </remarks>
-        public bool CanUseHeldEntity(EntityUid user)
+        public bool CanUseHeldEntity(EntityUid user, EntityUid used)
         {
-            var ev = new UseAttemptEvent(user);
+            var ev = new UseAttemptEvent(user, used);
             RaiseLocalEvent(user, ev);
 
             return !ev.Cancelled;

Content.Shared/Burial/BurialSystem.cs

@@ -83,10 +83,11 @@ public sealed class BurialSystem : EntitySystem
 
     private void OnActivate(EntityUid uid, GraveComponent component, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         _popupSystem.PopupClient(Loc.GetString("grave-digging-requires-tool", ("grave", args.Target)), uid, args.User);
+        args.Handled = true;
     }
 
     private void OnGraveDigging(EntityUid uid, GraveComponent component, GraveDiggingDoAfterEvent args)

Content.Shared/Chemistry/EntitySystems/SharedSolutionContainerMixerSystem.cs

@@ -31,7 +31,11 @@ public abstract class SharedSolutionContainerMixerSystem : EntitySystem
 
     private void OnActivateInWorld(Entity<SolutionContainerMixerComponent> entity, ref ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         TryStartMix(entity, args.User);
+        args.Handled = true;
     }
 
     private void OnRemoveAttempt(Entity<SolutionContainerMixerComponent> ent, ref ContainerIsRemovingAttemptEvent args)

Content.Shared/DeviceLinking/Systems/TwoWayLeverSystem.cs

@@ -28,7 +28,7 @@ namespace Content.Shared.DeviceLinking.Systems
 
         private void OnActivated(EntityUid uid, TwoWayLeverComponent component, ActivateInWorldEvent args)
         {
-            if (args.Handled)
+            if (args.Handled || !args.Complex)
                 return;
 
             component.State = component.State switch

Content.Shared/Doors/Systems/SharedDoorSystem.cs

@@ -215,7 +215,7 @@ public abstract partial class SharedDoorSystem : EntitySystem
     #region Interactions
     protected void OnActivate(EntityUid uid, DoorComponent door, ActivateInWorldEvent args)
     {
-        if (args.Handled || !door.ClickOpen)
+        if (args.Handled || !args.Complex || !door.ClickOpen)
             return;
 
         if (!TryToggleDoor(uid, door, args.User, predicted: true))

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

@@ -3,6 +3,7 @@ using Content.Shared.Examine;
 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;
@@ -23,6 +24,7 @@ public abstract partial class SharedHandsSystem : EntitySystem
         SubscribeAllEvent<RequestMoveHandItemEvent>(HandleMoveItemFromHand);
         SubscribeAllEvent<RequestHandAltInteractEvent>(HandleHandAltInteract);
 
+        SubscribeLocalEvent<HandsComponent, GetUsedEntityEvent>(OnGetUsedEntity);
         SubscribeLocalEvent<HandsComponent, ExaminedEvent>(HandleExamined);
 
         CommandBinds.Builder
@@ -181,6 +183,18 @@ public abstract partial class SharedHandsSystem : EntitySystem
         return true;
     }
 
+    private void OnGetUsedEntity(EntityUid uid, HandsComponent component, ref GetUsedEntityEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        // TODO: this pattern is super uncommon, but it might be worth changing GetUsedEntityEvent to be recursive.
+        if (TryComp<VirtualItemComponent>(component.ActiveHandEntity, out var virtualItem))
+            args.Used = virtualItem.BlockingEntity;
+        else
+            args.Used = component.ActiveHandEntity;
+    }
+
     //TODO: Actually shows all items/clothing/etc.
     private void HandleExamined(EntityUid examinedUid, HandsComponent handsComp, ExaminedEvent args)
     {

Content.Shared/Interaction/ActivateInWorldEvent.cs

@@ -18,14 +18,49 @@ public sealed class ActivateInWorldEvent : HandledEntityEventArgs, ITargetedInte
     /// </summary>
     public EntityUid Target { get; }
 
+    /// <summary>
+    ///     Whether or not <see cref="User"/> can perform complex interactions or only basic ones.
+    /// </summary>
+    public bool Complex;
+
     /// <summary>
     ///     Set to true when the activation is logged by a specific logger.
     /// </summary>
     public bool WasLogged { get; set; }
 
-    public ActivateInWorldEvent(EntityUid user, EntityUid target)
+    public ActivateInWorldEvent(EntityUid user, EntityUid target, bool complex)
     {
         User = user;
         Target = target;
+        Complex = complex;
+    }
+}
+
+/// <summary>
+/// Event raised on the user when it activates something in the world
+/// </summary>
+[PublicAPI]
+public sealed class UserActivateInWorldEvent : HandledEntityEventArgs, ITargetedInteractEventArgs
+{
+    /// <summary>
+    ///     Entity that activated the target world entity.
+    /// </summary>
+    public EntityUid User { get; }
+
+    /// <summary>
+    ///     Entity that was activated in the world.
+    /// </summary>
+    public EntityUid Target { get; }
+
+    /// <summary>
+    ///     Whether or not <see cref="User"/> can perform complex interactions or only basic ones.
+    /// </summary>
+    public bool Complex;
+
+    public UserActivateInWorldEvent(EntityUid user, EntityUid target, bool complex)
+    {
+        User = user;
+        Target = target;
+        Complex = complex;
     }
 }

Content.Shared/Interaction/Components/ComplexInteractionComponent.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Interaction.Components;
+
+/// <summary>
+/// This is used for identifying entities as being able to use complex interactions with the environment.
+/// </summary>
+[RegisterComponent, NetworkedComponent, Access(typeof(SharedInteractionSystem))]
+public sealed partial class ComplexInteractionComponent : Component;

Content.Shared/Interaction/Events/UseAttemptEvent.cs

@@ -1,12 +1,9 @@
 namespace Content.Shared.Interaction.Events
 {
-    public sealed class UseAttemptEvent : CancellableEntityEventArgs
+    public sealed class UseAttemptEvent(EntityUid uid, EntityUid used) : CancellableEntityEventArgs
     {
-        public UseAttemptEvent(EntityUid uid)
+        public EntityUid Uid { get; } = uid;
-        {
-            Uid = uid;
-        }
 
-        public EntityUid Uid { get; }
+        public EntityUid Used = used;
     }
 }

Content.Shared/Interaction/InteractHand.cs

@@ -51,58 +51,4 @@ namespace Content.Shared.Interaction
             Target = target;
         }
     }
-
-    /// <summary>
-    /// Low-level interaction event used for entities without hands.
-    /// </summary>
-    /// <remarks>
-    /// SHIT IS CURSED.
-    /// </remarks>
-    //TODO: KILLLLLLL
-    public sealed class InteractNoHandEvent : HandledEntityEventArgs
-    {
-        /// <summary>
-        ///     Entity that triggered the interaction.
-        /// </summary>
-        public EntityUid User;
-
-        /// <summary>
-        ///     Entity that was interacted on.
-        /// </summary>
-        public EntityUid? Target;
-
-        public EntityCoordinates ClickLocation;
-
-        public InteractNoHandEvent(EntityUid user, EntityUid? target, EntityCoordinates clickLocation)
-        {
-            User = user;
-            Target = target;
-            ClickLocation = clickLocation;
-        }
-    }
-
-    /// <summary>
-    /// Reverse of the InteractNoHandEvent - raised on what was interacted on, rather than the other way around.
-    /// </summary>
-    public sealed class InteractedNoHandEvent : HandledEntityEventArgs
-    {
-        /// <summary>
-        /// Entity that was interacted on
-        /// </summary>
-        public EntityUid Target;
-
-        /// <summary>
-        /// Entity that triggered this interaction
-        /// </summary>
-        public EntityUid User;
-
-        public EntityCoordinates ClickLocation;
-
-        public InteractedNoHandEvent(EntityUid target, EntityUid user, EntityCoordinates clickLocation)
-        {
-            Target = target;
-            User = user;
-            ClickLocation = clickLocation;
-        }
-    }
 }

Content.Shared/Interaction/InteractionPopupSystem.cs

@@ -32,6 +32,9 @@ public sealed class InteractionPopupSystem : EntitySystem
 
     private void OnActivateInWorld(EntityUid uid, InteractionPopupComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         if (!component.OnActivate)
             return;
 

Content.Shared/Interaction/SharedInteractionSystem.cs

@@ -76,6 +76,7 @@ namespace Content.Shared.Interaction
         private EntityQuery<WallMountComponent> _wallMountQuery;
         private EntityQuery<UseDelayComponent> _delayQuery;
         private EntityQuery<ActivatableUIComponent> _uiQuery;
+        private EntityQuery<ComplexInteractionComponent> _complexInteractionQuery;
 
         private const CollisionGroup InRangeUnobstructedMask = CollisionGroup.Impassable | CollisionGroup.InteractImpassable;
 
@@ -98,6 +99,7 @@ namespace Content.Shared.Interaction
             _wallMountQuery = GetEntityQuery<WallMountComponent>();
             _delayQuery = GetEntityQuery<UseDelayComponent>();
             _uiQuery = GetEntityQuery<ActivatableUIComponent>();
+            _complexInteractionQuery = GetEntityQuery<ComplexInteractionComponent>();
 
             SubscribeLocalEvent<BoundUserInterfaceCheckRangeEvent>(HandleUserInterfaceRangeCheck);
             SubscribeLocalEvent<BoundUserInterfaceMessageAttempt>(OnBoundInterfaceInteractAttempt);
@@ -360,8 +362,13 @@ namespace Content.Shared.Interaction
                 // TODO this needs to be handled better. This probably bypasses many complex can-interact checks in weird roundabout ways.
                 if (_actionBlockerSystem.CanInteract(user, target))
                 {
-                    UserInteraction(relay.RelayEntity.Value, coordinates, target, altInteract, checkCanInteract,
+                    UserInteraction(relay.RelayEntity.Value,
-                        checkAccess, checkCanUse);
+                        coordinates,
+                        target,
+                        altInteract,
+                        checkCanInteract,
+                        checkAccess,
+                        checkCanUse);
                     return;
                 }
             }
@@ -398,25 +405,10 @@ namespace Content.Shared.Interaction
                 ? !checkAccess || InRangeUnobstructed(user, coordinates)
                 : !checkAccess || InRangeUnobstructed(user, target.Value); // permits interactions with wall mounted entities
 
-            // Does the user have hands?
-            if (!_handsQuery.TryComp(user, out var hands) || hands.ActiveHand == null)
-            {
-                var ev = new InteractNoHandEvent(user, target, coordinates);
-                RaiseLocalEvent(user, ev);
-
-                if (target != null)
-                {
-                    var interactedEv = new InteractedNoHandEvent(target.Value, user, coordinates);
-                    RaiseLocalEvent(target.Value, interactedEv);
-                    DoContactInteraction(user, target.Value, ev);
-                }
-                return;
-            }
-
             // empty-hand interactions
             // combat mode hand interactions will always be true here -- since
             // they check this earlier before returning in
-            if (hands.ActiveHandEntity is not { } held)
+            if (!TryGetUsedEntity(user, out var used, checkCanUse))
             {
                 if (inRangeUnobstructed && target != null)
                     InteractHand(user, target.Value);
@@ -424,11 +416,7 @@ namespace Content.Shared.Interaction
                 return;
             }
 
-            // Can the user use the held entity?
+            if (target == used)
-            if (checkCanUse && !_actionBlockerSystem.CanUseHeldEntity(user))
-                return;
-
-            if (target == held)
             {
                 UseInHandInteraction(user, target.Value, checkCanUse: false, checkCanInteract: false);
                 return;
@@ -438,7 +426,7 @@ namespace Content.Shared.Interaction
             {
                 InteractUsing(
                     user,
-                    held,
+                    used.Value,
                     target.Value,
                     coordinates,
                     checkCanInteract: false,
@@ -449,7 +437,7 @@ namespace Content.Shared.Interaction
 
             InteractUsingRanged(
                 user,
-                held,
+                used.Value,
                 target,
                 coordinates,
                 inRangeUnobstructed);
@@ -457,6 +445,18 @@ namespace Content.Shared.Interaction
 
         public void InteractHand(EntityUid user, EntityUid target)
         {
+            var complexInteractions = SupportsComplexInteractions(user);
+            if (!complexInteractions)
+            {
+                InteractionActivate(user,
+                    target,
+                    checkCanInteract: false,
+                    checkUseDelay: true,
+                    checkAccess: false,
+                    complexInteractions: complexInteractions);
+                return;
+            }
+
             // allow for special logic before main interaction
             var ev = new BeforeInteractHandEvent(target);
             RaiseLocalEvent(user, ev);
@@ -475,10 +475,12 @@ namespace Content.Shared.Interaction
                 return;
 
             // Else we run Activate.
-            InteractionActivate(user, target,
+            InteractionActivate(user,
+                target,
                 checkCanInteract: false,
                 checkUseDelay: true,
-                checkAccess: false);
+                checkAccess: false,
+                complexInteractions: complexInteractions);
         }
 
         public void InteractUsingRanged(EntityUid user, EntityUid used, EntityUid? target,
@@ -921,7 +923,7 @@ namespace Content.Shared.Interaction
             if (checkCanInteract && !_actionBlockerSystem.CanInteract(user, target))
                 return;
 
-            if (checkCanUse && !_actionBlockerSystem.CanUseHeldEntity(user))
+            if (checkCanUse && !_actionBlockerSystem.CanUseHeldEntity(user, used))
                 return;
 
             if (RangedInteractDoBefore(user, used, target, clickLocation, true))
@@ -1001,7 +1003,8 @@ namespace Content.Shared.Interaction
             EntityUid used,
             bool checkCanInteract = true,
             bool checkUseDelay = true,
-            bool checkAccess = true)
+            bool checkAccess = true,
+            bool? complexInteractions = null)
         {
             _delayQuery.TryComp(used, out var delayComponent);
             if (checkUseDelay && delayComponent != null && _useDelay.IsDelayed((used, delayComponent)))
@@ -1018,13 +1021,12 @@ namespace Content.Shared.Interaction
             if (checkAccess && !IsAccessible(user, used))
                 return false;
 
-            // Does the user have hands?
+            complexInteractions ??= SupportsComplexInteractions(user);
-            if (!_handsQuery.HasComp(user))
+            var activateMsg = new ActivateInWorldEvent(user, used, complexInteractions.Value);
-                return false;
-
-            var activateMsg = new ActivateInWorldEvent(user, used);
             RaiseLocalEvent(used, activateMsg, true);
-            if (!activateMsg.Handled)
+            var userEv = new UserActivateInWorldEvent(user, used, complexInteractions.Value);
+            RaiseLocalEvent(user, userEv, true);
+            if (!activateMsg.Handled && !userEv.Handled)
                 return false;
 
             DoContactInteraction(user, used, activateMsg);
@@ -1059,7 +1061,7 @@ namespace Content.Shared.Interaction
             if (checkCanInteract && !_actionBlockerSystem.CanInteract(user, used))
                 return false;
 
-            if (checkCanUse && !_actionBlockerSystem.CanUseHeldEntity(user))
+            if (checkCanUse && !_actionBlockerSystem.CanUseHeldEntity(user, used))
                 return false;
 
             var useMsg = new UseInHandEvent(user);
@@ -1259,6 +1261,39 @@ namespace Content.Shared.Interaction
                     ? BoundUserInterfaceRangeResult.Pass
                     : BoundUserInterfaceRangeResult.Fail;
         }
+
+        /// <summary>
+        /// Gets the entity that is currently being "used" for the interaction.
+        /// In most cases, this refers to the entity in the character's active hand.
+        /// </summary>
+        /// <returns>If there is an entity being used.</returns>
+        public bool TryGetUsedEntity(EntityUid user, [NotNullWhen(true)] out EntityUid? used, bool checkCanUse = true)
+        {
+            var ev = new GetUsedEntityEvent();
+            RaiseLocalEvent(user, ref ev);
+
+            used = ev.Used;
+            if (!ev.Handled)
+                return false;
+
+            // Can the user use the held entity?
+            if (checkCanUse && !_actionBlockerSystem.CanUseHeldEntity(user, ev.Used!.Value))
+            {
+                used = null;
+                return false;
+            }
+
+            return ev.Handled;
+        }
+
+        /// <summary>
+        /// Checks if a given entity is able to do specific complex interactions.
+        /// This is used to gate manipulation to general humanoids. If a mouse shouldn't be able to do something, then it's complex.
+        /// </summary>
+        public bool SupportsComplexInteractions(EntityUid user)
+        {
+            return _complexInteractionQuery.HasComp(user);
+        }
     }
 
     /// <summary>
@@ -1284,6 +1319,24 @@ namespace Content.Shared.Interaction
         }
     }
 
+    /// <summary>
+    ///     Raised directed by-ref on an entity to determine what item will be used in interactions.
+    /// </summary>
+    [ByRefEvent]
+    public record struct GetUsedEntityEvent()
+    {
+        public EntityUid? Used = null;
+
+        public bool Handled => Used != null;
+    };
+
+    /// <summary>
+    ///     Raised directed by-ref on an item and a user to determine if interactions can occur.
+    /// </summary>
+    /// <param name="Cancelled">Whether the hand interaction should be cancelled.</param>
+    [ByRefEvent]
+    public record struct AttemptUseInteractEvent(EntityUid User, EntityUid Used, bool Cancelled = false);
+
     /// <summary>
     ///     Raised directed by-ref on an item to determine if hand interactions should go through.
     ///     Defaults to allowing hand interactions to go through. Cancel to force the item to be attacked instead.

Content.Shared/Lock/LockSystem.cs

@@ -62,7 +62,7 @@ public sealed class LockSystem : EntitySystem
 
     private void OnActivated(EntityUid uid, LockComponent lockComp, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         // Only attempt an unlock by default on Activate

Content.Shared/Mech/EntitySystems/SharedMechSystem.cs

@@ -43,7 +43,7 @@ public abstract class SharedMechSystem : EntitySystem
     {
         SubscribeLocalEvent<MechComponent, MechToggleEquipmentEvent>(OnToggleEquipmentAction);
         SubscribeLocalEvent<MechComponent, MechEjectPilotEvent>(OnEjectPilotEvent);
-        SubscribeLocalEvent<MechComponent, InteractNoHandEvent>(RelayInteractionEvent);
+        SubscribeLocalEvent<MechComponent, UserActivateInWorldEvent>(RelayInteractionEvent);
         SubscribeLocalEvent<MechComponent, ComponentStartup>(OnStartup);
         SubscribeLocalEvent<MechComponent, DestructionEventArgs>(OnDestruction);
         SubscribeLocalEvent<MechComponent, GetAdditionalAccessEvent>(OnGetAdditionalAccess);
@@ -71,7 +71,7 @@ public abstract class SharedMechSystem : EntitySystem
         TryEject(uid, component);
     }
 
-    private void RelayInteractionEvent(EntityUid uid, MechComponent component, InteractNoHandEvent args)
+    private void RelayInteractionEvent(EntityUid uid, MechComponent component, UserActivateInWorldEvent args)
     {
         var pilot = component.PilotSlot.ContainedEntity;
         if (pilot == null)

Content.Shared/Projectiles/SharedProjectileSystem.cs

@@ -47,7 +47,7 @@ public abstract partial class SharedProjectileSystem : EntitySystem
         if (component.RemovalTime == null)
             return;
 
-        if (args.Handled || !TryComp<PhysicsComponent>(uid, out var physics) || physics.BodyType != BodyType.Static)
+        if (args.Handled || !args.Complex || !TryComp<PhysicsComponent>(uid, out var physics) || physics.BodyType != BodyType.Static)
             return;
 
         args.Handled = true;

Content.Shared/Storage/EntitySystems/SharedEntityStorageSystem.cs

@@ -89,7 +89,7 @@ public abstract class SharedEntityStorageSystem : EntitySystem
 
     protected void OnInteract(EntityUid uid, SharedEntityStorageComponent component, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         args.Handled = true;

Content.Shared/Storage/EntitySystems/SharedStorageSystem.cs

@@ -364,7 +364,7 @@ public abstract class SharedStorageSystem : EntitySystem
     /// </summary>
     private void OnActivate(EntityUid uid, StorageComponent storageComp, ActivateInWorldEvent args)
     {
-        if (args.Handled || !CanInteract(args.User, (uid, storageComp), storageComp.ClickInsert))
+        if (args.Handled || !args.Complex || !CanInteract(args.User, (uid, storageComp), storageComp.ClickInsert))
             return;
 
         // Toggle

Content.Shared/Strip/SharedStrippableSystem.cs

@@ -21,7 +21,7 @@ public abstract class SharedStrippableSystem : EntitySystem
 
     private void OnActivateInWorld(EntityUid uid, StrippableComponent component, ActivateInWorldEvent args)
     {
-        if (args.Handled || args.Target == args.User)
+        if (args.Handled || !args.Complex || args.Target == args.User)
             return;
 
         if (TryOpenStrippingUi(args.User, (uid, component)))

Content.Shared/SubFloor/SharedTrayScannerSystem.cs

@@ -26,7 +26,11 @@ public abstract class SharedTrayScannerSystem : EntitySystem
 
     private void OnTrayScannerActivate(EntityUid uid, TrayScannerComponent scanner, ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         SetScannerEnabled(uid, !scanner.Enabled, scanner);
+        args.Handled = true;
     }
 
     private void SetScannerEnabled(EntityUid uid, bool enabled, TrayScannerComponent? scanner = null)

Content.Shared/Teleportation/Systems/SwapTeleporterSystem.cs

@@ -101,6 +101,9 @@ public sealed class SwapTeleporterSystem : EntitySystem
 
     private void OnActivateInWorld(Entity<SwapTeleporterComponent> ent, ref ActivateInWorldEvent args)
     {
+        if (args.Handled || !args.Complex)
+            return;
+
         var (uid, comp) = ent;
         var user = args.User;
         if (comp.TeleportTime != null)
@@ -130,6 +133,7 @@ public sealed class SwapTeleporterSystem : EntitySystem
         comp.NextTeleportUse = _timing.CurTime + comp.Cooldown;
         comp.TeleportTime = _timing.CurTime + comp.TeleportDelay;
         Dirty(uid, comp);
+        args.Handled = true;
     }
 
     public void DoTeleport(Entity<SwapTeleporterComponent, TransformComponent> ent)

Content.Shared/Toilet/Systems/SharedToiletSystem.cs

@@ -79,7 +79,7 @@ namespace Content.Shared.Toilet.Systems
 
         private void OnActivateInWorld(EntityUid uid, ToiletComponent comp, ActivateInWorldEvent args)
         {
-            if (args.Handled)
+            if (args.Handled || !args.Complex)
                 return;
 
             args.Handled = true;

Content.Shared/Tools/Systems/SharedToolSystem.MultipleTool.cs

@@ -28,7 +28,7 @@ public abstract partial class SharedToolSystem
 
     private void OnMultipleToolActivated(EntityUid uid, MultipleToolComponent multiple, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         args.Handled = CycleMultipleTool(uid, multiple, args.User);

Content.Shared/UserInterface/ActivatableUISystem.cs

@@ -133,7 +133,7 @@ public sealed partial class ActivatableUISystem : EntitySystem
 
     private void OnActivate(EntityUid uid, ActivatableUIComponent component, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         if (component.VerbOnly)

Content.Shared/Verbs/SharedVerbSystem.cs

@@ -78,28 +78,8 @@ namespace Content.Shared.Verbs
             // call ActionBlocker checks, just cache it for the verb request.
             var canInteract = force || _actionBlockerSystem.CanInteract(user, target);
 
-            EntityUid? @using = null;
+            _interactionSystem.TryGetUsedEntity(user, out var @using);
-            if (TryComp(user, out HandsComponent? hands) && (force || _actionBlockerSystem.CanUseHeldEntity(user)))
+            TryComp<HandsComponent>(user, out var hands);
-            {
-                // if we don't actually have any hands, pass in a null value for the events.
-                if (hands.Count == 0)
-                {
-                    hands = null;
-                }
-                else
-                {
-                    @using = hands.ActiveHandEntity;
-
-                    // Check whether the "Held" entity is a virtual pull entity. If yes, set that as the entity being "Used".
-                    // This allows you to do things like buckle a dragged person onto a surgery table, without click-dragging
-                    // their sprite.
-
-                    if (TryComp(@using, out VirtualItemComponent? pull))
-                    {
-                        @using = pull.BlockingEntity;
-                    }
-                }
-            }
 
             // TODO: fix this garbage and use proper generics or reflection or something else, not this.
             if (types.Contains(typeof(InteractionVerb)))

Content.Shared/Weapons/Misc/SharedGrapplingGunSystem.cs

@@ -116,7 +116,7 @@ public abstract class SharedGrapplingGunSystem : EntitySystem
 
     private void OnGunActivate(EntityUid uid, GrapplingGunComponent component, ActivateInWorldEvent args)
     {
-        if (!Timing.IsFirstTimePredicted || args.Handled)
+        if (!Timing.IsFirstTimePredicted || args.Handled || !args.Complex)
             return;
 
         if (Deleted(component.Projectile))

Content.Shared/Weapons/Misc/SharedTetherGunSystem.Force.cs

@@ -14,6 +14,9 @@ public abstract partial class SharedTetherGunSystem
 
     private void OnForceActivate(EntityUid uid, ForceGunComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         StopTether(uid, component);
     }
 

Content.Shared/Weapons/Misc/SharedTetherGunSystem.cs

@@ -152,6 +152,9 @@ public abstract partial class SharedTetherGunSystem : EntitySystem
 
     private void OnTetherActivate(EntityUid uid, TetherGunComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         StopTether(uid, component);
     }
 

Content.Shared/Weapons/Ranged/Systems/BatteryWeaponFireModesSystem.cs

@@ -75,6 +75,9 @@ public sealed class BatteryWeaponFireModesSystem : EntitySystem
 
     private void OnInteractHandEvent(EntityUid uid, BatteryWeaponFireModesComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         if (component.FireModes.Count < 2)
             return;
 

Content.Shared/Weapons/Ranged/Systems/RechargeCycleAmmoSystem.cs

@@ -18,6 +18,9 @@ public sealed class RechargeCycleAmmoSystem : EntitySystem
 
     private void OnRechargeCycled(EntityUid uid, RechargeCycleAmmoComponent component, ActivateInWorldEvent args)
     {
+        if (!args.Complex)
+            return;
+
         if (!TryComp<BasicEntityAmmoProviderComponent>(uid, out var basic) || args.Handled)
             return;
 

Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.ChamberMagazine.cs

@@ -51,7 +51,7 @@ public abstract partial class SharedGunSystem
     /// </summary>
     private void OnChamberActivate(EntityUid uid, ChamberMagazineAmmoProviderComponent component, ActivateInWorldEvent args)
     {
-        if (args.Handled)
+        if (args.Handled || !args.Complex)
             return;
 
         args.Handled = true;

Resources/Prototypes/Entities/Mobs/Cyborgs/base_borg_chassis.yml

@@ -84,6 +84,7 @@
   - type: Hands
     showInHands: false
     disableExplosionRecursion: true
+  - type: ComplexInteraction
   - type: IntrinsicRadioReceiver
   - type: IntrinsicRadioTransmitter
     channels:

Resources/Prototypes/Entities/Mobs/NPCs/animals.yml

@@ -1200,6 +1200,7 @@
       state: "creampie_human"
       visible: false
   - type: Hands
+  - type: ComplexInteraction
   - type: GenericVisualizer
     visuals:
       enum.CreamPiedVisuals.Creamed:

Resources/Prototypes/Entities/Mobs/NPCs/mimic.yml

@@ -12,7 +12,6 @@
   - type: NpcFactionMember
     factions:
     - SimpleHostile
-  - type: Hands
   - type: Sprite
     drawdepth: Mobs
     sprite: Structures/Machines/VendingMachines/cola.rsi

Resources/Prototypes/Entities/Mobs/NPCs/xeno.yml

@@ -40,6 +40,7 @@
     factions:
     - Xeno
   - type: Hands
+  - type: ComplexInteraction
   - type: Sprite
     drawdepth: Mobs
     sprite: Mobs/Aliens/Xenos/burrower.rsi

Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml

@@ -18,6 +18,7 @@
     canInteract: true
   - type: GhostHearing
   - type: Hands
+  - type: ComplexInteraction
   - type: Puller
   - type: CombatMode
   - type: Physics

Resources/Prototypes/Entities/Mobs/Player/guardian.yml

@@ -225,6 +225,7 @@
     - type: Inventory
       templateId: holoclown
     - type: Hands
+    - type: ComplexInteraction
     - type: Clumsy
       clumsyDamage:
         types:

Resources/Prototypes/Entities/Mobs/Species/base.yml

@@ -149,6 +149,7 @@
   - type: Identity
   - type: IdExaminable
   - type: Hands
+  - type: ComplexInteraction
   - type: Internals
   - type: Inventory
   - type: InventorySlots
@@ -309,6 +310,7 @@
   abstract: true
   components:
   - type: Hands
+  - type: ComplexInteraction
   - type: Inventory
   - type: InventorySlots
   - type: ContainerContainer