Misc implant fixes (#17172)

Content.Server/Explosion/EntitySystems/TriggerSystem.Mobstate.cs

@@ -1,7 +1,7 @@
 using Content.Server.Explosion.Components;
+using Content.Shared.Implants;
 using Content.Shared.Interaction.Events;
 using Content.Shared.Mobs;
-using Robust.Shared.Player;
 
 namespace Content.Server.Explosion.EntitySystems;
 
@@ -11,6 +11,9 @@ public sealed partial class TriggerSystem
     {
         SubscribeLocalEvent<TriggerOnMobstateChangeComponent, MobStateChangedEvent>(OnMobStateChanged);
         SubscribeLocalEvent<TriggerOnMobstateChangeComponent, SuicideEvent>(OnSuicide);
+
+        SubscribeLocalEvent<TriggerOnMobstateChangeComponent, ImplantRelayEvent<SuicideEvent>>(OnSuicideRelay);
+        SubscribeLocalEvent<TriggerOnMobstateChangeComponent, ImplantRelayEvent<MobStateChangedEvent>>(OnMobStateRelay);
     }
 
     private void OnMobStateChanged(EntityUid uid, TriggerOnMobstateChangeComponent component, MobStateChangedEvent args)
@@ -45,4 +48,14 @@ public sealed partial class TriggerSystem
             args.BlockSuicideAttempt(component.PreventSuicide);
         }
     }
+
+    private void OnSuicideRelay(EntityUid uid, TriggerOnMobstateChangeComponent component, ImplantRelayEvent<SuicideEvent> args)
+    {
+        OnSuicide(uid, component, args.Event);
+    }
+
+    private void OnMobStateRelay(EntityUid uid, TriggerOnMobstateChangeComponent component, ImplantRelayEvent<MobStateChangedEvent> args)
+    {
+        OnMobStateChanged(uid, component, args.Event);
+    }
 }

Content.Server/Implants/ImplanterSystem.cs

@@ -48,10 +48,12 @@ public sealed partial class ImplanterSystem : SharedImplanterSystem
         }
         else
         {
+            if (!CanImplant(args.User, args.Target.Value, uid, component, out _, out _))
+                return;
+
             //Implant self instantly, otherwise try to inject the target.
             if (args.User == args.Target)
-                Implant(uid, args.Target.Value, component);
+                Implant(args.User, args.Target.Value, uid, component);
-
             else
                 TryImplant(component, args.User, args.Target.Value, uid);
         }
@@ -117,7 +119,7 @@ public sealed partial class ImplanterSystem : SharedImplanterSystem
         if (args.Cancelled || args.Handled || args.Target == null || args.Used == null)
             return;
 
-        Implant(args.Used.Value, args.Target.Value, component);
+        Implant(args.User, args.Target.Value, args.Used.Value, component);
 
         args.Handled = true;
     }

Content.Server/Implants/SubdermalImplantSystem.cs

@@ -5,44 +5,31 @@ using Content.Shared.Cuffs.Components;
 using Content.Shared.Implants;
 using Content.Shared.Implants.Components;
 using Content.Shared.Interaction;
-using Content.Shared.Interaction.Events;
-using Content.Shared.Mobs;
 using Content.Shared.Popups;
-using Robust.Shared.Containers;
 
 namespace Content.Server.Implants;
 
 public sealed class SubdermalImplantSystem : SharedSubdermalImplantSystem
 {
     [Dependency] private readonly CuffableSystem _cuffable = default!;
-    [Dependency] private readonly SharedContainerSystem _container = default!;
-    [Dependency] private readonly SharedPopupSystem _popup = default!;
     [Dependency] private readonly StoreSystem _store = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
 
     public override void Initialize()
     {
         base.Initialize();
 
         SubscribeLocalEvent<SubdermalImplantComponent, UseFreedomImplantEvent>(OnFreedomImplant);
-
+        SubscribeLocalEvent<StoreComponent, ImplantRelayEvent<AfterInteractUsingEvent>>(OnStoreRelay);
-        SubscribeLocalEvent<StoreComponent, AfterInteractUsingEvent>(OnUplinkInteractUsing);
-
-        SubscribeLocalEvent<ImplantedComponent, MobStateChangedEvent>(RelayToImplantEvent);
-        SubscribeLocalEvent<ImplantedComponent, AfterInteractUsingEvent>(RelayToImplantEvent);
-        SubscribeLocalEvent<ImplantedComponent, SuicideEvent>(RelayToImplantEvent);
     }
 
-    private void OnFreedomImplant(EntityUid uid, SubdermalImplantComponent component, UseFreedomImplantEvent args)
+    private void OnStoreRelay(EntityUid uid, StoreComponent store, ImplantRelayEvent<AfterInteractUsingEvent> implantRelay)
     {
-        if (!TryComp<CuffableComponent>(component.ImplantedEntity, out var cuffs) || cuffs.Container.ContainedEntities.Count < 1)
+        var args = implantRelay.Event;
+
+        if (args.Handled)
             return;
 
-        _cuffable.Uncuff(component.ImplantedEntity.Value, cuffs.LastAddedCuffs, cuffs.LastAddedCuffs);
-        args.Handled = true;
-    }
-
-    private void OnUplinkInteractUsing(EntityUid uid, StoreComponent store, AfterInteractUsingEvent args)
-    {
         // can only insert into yourself to prevent uplink checking with renault
         if (args.Target != args.User)
             return;
@@ -61,46 +48,12 @@ public sealed class SubdermalImplantSystem : SharedSubdermalImplantSystem
         QueueDel(args.Used);
     }
 
-    #region Relays
+    private void OnFreedomImplant(EntityUid uid, SubdermalImplantComponent component, UseFreedomImplantEvent args)
-
-    //Relays from the implanted to the implant
-    private void RelayToImplantEvent<T>(EntityUid uid, ImplantedComponent component, T args) where T: notnull
     {
-        if (!_container.TryGetContainer(uid, ImplanterComponent.ImplantSlotId, out var implantContainer))
+        if (!TryComp<CuffableComponent>(component.ImplantedEntity, out var cuffs) || cuffs.Container.ContainedEntities.Count < 1)
             return;
-        foreach (var implant in implantContainer.ContainedEntities)
-        {
-            RaiseLocalEvent(implant, args);
-        }
-    }
 
-    //Relays from the implanted to the implant
+        _cuffable.Uncuff(component.ImplantedEntity.Value, cuffs.LastAddedCuffs, cuffs.LastAddedCuffs);
-    private void RelayToImplantEventByRef<T>(EntityUid uid, ImplantedComponent component, ref T args) where T: notnull
+        args.Handled = true;
-    {
-        if (!_container.TryGetContainer(uid, ImplanterComponent.ImplantSlotId, out var implantContainer))
-            return;
-        foreach (var implant in implantContainer.ContainedEntities)
-        {
-            RaiseLocalEvent(implant,ref args);
-        }
     }
-
-    //Relays from the implant to the implanted
-    private void RelayToImplantedEvent<T>(EntityUid uid, SubdermalImplantComponent component, T args) where T : EntityEventArgs
-    {
-        if (component.ImplantedEntity != null)
-        {
-            RaiseLocalEvent(component.ImplantedEntity.Value, args);
-        }
-    }
-
-    private void RelayToImplantedEventByRef<T>(EntityUid uid, SubdermalImplantComponent component, ref T args) where T : EntityEventArgs
-    {
-        if (component.ImplantedEntity != null)
-        {
-            RaiseLocalEvent(component.ImplantedEntity.Value, ref args);
-        }
-    }
-
-    #endregion
 }

Content.Server/PDA/Ringer/RingerSystem.cs

@@ -34,10 +34,18 @@ namespace Content.Server.PDA.Ringer
             SubscribeLocalEvent<RingerComponent, RingerPlayRingtoneMessage>(RingerPlayRingtone);
             SubscribeLocalEvent<RingerComponent, RingerRequestUpdateInterfaceMessage>(UpdateRingerUserInterfaceDriver);
 
+            SubscribeLocalEvent<RingerUplinkComponent, CurrencyInsertAttemptEvent>(OnCurrencyInsert);
         }
 
         //Event Functions
 
+        private void OnCurrencyInsert(EntityUid uid, RingerUplinkComponent uplink, CurrencyInsertAttemptEvent args)
+        {
+            // if the store can be locked, it must be unlocked first before inserting currency. Stops traitor checking.
+            if (!uplink.Unlocked)
+                args.Cancel();
+        }
+
         private void RingerPlayRingtone(EntityUid uid, RingerComponent ringer, RingerPlayRingtoneMessage args)
         {
             EnsureComp<ActiveRingerComponent>(uid);

Content.Server/Store/Systems/StoreSystem.cs

@@ -70,12 +70,12 @@ public sealed partial class StoreSystem : EntitySystem
         if (args.Handled || !args.CanReach)
             return;
 
-        if (args.Target == null || !TryComp<StoreComponent>(args.Target, out var store))
+        if (!TryComp<StoreComponent>(args.Target, out var store))
             return;
 
-        // if the store can be locked, it must be unlocked first before inserting currency
+        var ev = new CurrencyInsertAttemptEvent(args.User, args.Target.Value, args.Used, store);
-        var user = args.User;
+        RaiseLocalEvent(args.Target.Value, ev);
-        if (TryComp<RingerUplinkComponent>(args.Target, out var uplink) && !uplink.Unlocked)
+        if (ev.Cancelled)
             return;
 
         args.Handled = TryAddCurrency(GetCurrencyValue(uid, component), args.Target.Value, store);
@@ -189,3 +189,19 @@ public sealed partial class StoreSystem : EntitySystem
         }
     }
 }
+
+public sealed class CurrencyInsertAttemptEvent : CancellableEntityEventArgs
+{
+    public readonly EntityUid User;
+    public readonly EntityUid Target;
+    public readonly EntityUid Used;
+    public readonly StoreComponent Store;
+
+    public CurrencyInsertAttemptEvent(EntityUid user, EntityUid target, EntityUid used, StoreComponent store)
+    {
+        User = user;
+        Target = target;
+        Used = used;
+        Store = store;
+    }
+}

Content.Shared/Implants/Components/ImplanterComponent.cs

@@ -67,7 +67,7 @@ public sealed class ImplanterComponent : Component
     /// The <see cref="ItemSlot"/> for this implanter
     /// </summary>
     [ViewVariables]
-    [DataField("implanterSlot")]
+    [DataField("implanterSlot", required:true)]
     public ItemSlot ImplanterSlot = new();
 
     public bool UiUpdateNeeded;

Content.Shared/Implants/SharedImplanterSystem.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading.Tasks;
 using Content.Shared.Containers.ItemSlots;
 using Content.Shared.DoAfter;
 using Content.Shared.IdentityManagement;
@@ -39,38 +41,48 @@ public abstract class SharedImplanterSystem : EntitySystem
         component.ImplantData = (implantData.EntityName, implantData.EntityDescription);
     }
 
+
     //Instantly implant something and add all necessary components and containers.
     //Set to draw mode if not implant only
-    public void Implant(EntityUid implanter, EntityUid target, ImplanterComponent component)
+    public void Implant(EntityUid user, EntityUid target, EntityUid implanter, ImplanterComponent component)
     {
-        var implanterContainer = component.ImplanterSlot.ContainerSlot;
+        if (!CanImplant(user, target, implanter, component, out var implant, out var implantComp))
-
-        if (implanterContainer is null)
-            return;
-
-        var implant = implanterContainer.ContainedEntities.FirstOrDefault();
-
-        if (!TryComp<SubdermalImplantComponent>(implant, out var implantComp))
             return;
 
         //If the target doesn't have the implanted component, add it.
         var implantedComp = EnsureComp<ImplantedComponent>(target);
         var implantContainer = implantedComp.ImplantContainer;
 
-        implanterContainer.Remove(implant);
+        component.ImplanterSlot.ContainerSlot?.Remove(implant.Value);
         implantComp.ImplantedEntity = target;
         implantContainer.OccludesLight = false;
-        implantContainer.Insert(implant);
+        implantContainer.Insert(implant.Value);
 
         if (component.CurrentMode == ImplanterToggleMode.Inject && !component.ImplantOnly)
             DrawMode(component);
-
         else
             ImplantMode(component);
 
         Dirty(component);
     }
 
+    public bool CanImplant(
+        EntityUid user,
+        EntityUid target,
+        EntityUid implanter,
+        ImplanterComponent component,
+        [NotNullWhen(true)] out EntityUid? implant,
+        [NotNullWhen(true)] out SubdermalImplantComponent? implantComp)
+    {
+        implant = component.ImplanterSlot.ContainerSlot?.ContainedEntities?.FirstOrDefault();
+        if (!TryComp<SubdermalImplantComponent>(implant, out implantComp))
+            return false;
+
+        var ev = new AddImplantAttemptEvent(user, target, implant.Value, implanter);
+        RaiseLocalEvent(target, ev);
+        return !ev.Cancelled;
+    }
+
     //Draw the implant out of the target
     //TODO: Rework when surgery is in so implant cases can be a thing
     public void Draw(EntityUid implanter, EntityUid user, EntityUid target, ImplanterComponent component)
@@ -167,3 +179,19 @@ public sealed class ImplantEvent : SimpleDoAfterEvent
 public sealed class DrawEvent : SimpleDoAfterEvent
 {
 }
+
+public sealed class AddImplantAttemptEvent : CancellableEntityEventArgs
+{
+    public readonly EntityUid User;
+    public readonly EntityUid Target;
+    public readonly EntityUid Implant;
+    public readonly EntityUid Implanter;
+
+    public AddImplantAttemptEvent(EntityUid user, EntityUid target, EntityUid implant, EntityUid implanter)
+    {
+        User = user;
+        Target = target;
+        Implant = implant;
+        Implanter = implanter;
+    }
+}

Content.Shared/Implants/SharedSubdermalImplantSystem.cs

@@ -2,6 +2,9 @@
 using Content.Shared.Actions;
 using Content.Shared.Actions.ActionTypes;
 using Content.Shared.Implants.Components;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Mobs;
 using Content.Shared.Tag;
 using Robust.Shared.Containers;
 using Robust.Shared.Prototypes;
@@ -22,6 +25,10 @@ public abstract class SharedSubdermalImplantSystem : EntitySystem
         SubscribeLocalEvent<SubdermalImplantComponent, EntGotInsertedIntoContainerMessage>(OnInsert);
         SubscribeLocalEvent<SubdermalImplantComponent, ContainerGettingRemovedAttemptEvent>(OnRemoveAttempt);
         SubscribeLocalEvent<SubdermalImplantComponent, EntGotRemovedFromContainerMessage>(OnRemove);
+
+        SubscribeLocalEvent<ImplantedComponent, MobStateChangedEvent>(RelayToImplantEvent);
+        SubscribeLocalEvent<ImplantedComponent, AfterInteractUsingEvent>(RelayToImplantEvent);
+        SubscribeLocalEvent<ImplantedComponent, SuicideEvent>(RelayToImplantEvent);
     }
 
     private void OnInsert(EntityUid uid, SubdermalImplantComponent component, EntGotInsertedIntoContainerMessage args)
@@ -126,4 +133,30 @@ public abstract class SharedSubdermalImplantSystem : EntitySystem
 
         _container.CleanContainer(implantContainer);
     }
+
+    //Relays from the implanted to the implant
+    private void RelayToImplantEvent<T>(EntityUid uid, ImplantedComponent component, T args) where T : notnull
+    {
+        if (!_container.TryGetContainer(uid, ImplanterComponent.ImplantSlotId, out var implantContainer))
+            return;
+
+        var relayEv = new ImplantRelayEvent<T>(args);
+        foreach (var implant in implantContainer.ContainedEntities)
+        {
+            if (args is HandledEntityEventArgs { Handled : true })
+                return;
+
+            RaiseLocalEvent(implant, relayEv);
+        }
+    }
+}
+
+public sealed class ImplantRelayEvent<T> where T : notnull
+{
+    public readonly T Event;
+
+    public ImplantRelayEvent(T ev)
+    {
+        Event = ev;
+    }
 }