Code cleanup: radio jammer (#29052)

* Code cleanup for radio jammer

* More Entity<T> for the people, and fix an accidental variable reuse

Content.Client/DeviceNetwork/Systems/DeviceNetworkJammerSystem.cs

@@ -0,0 +1,6 @@
+using Content.Shared.DeviceNetwork.Systems;
+
+namespace Content.Client.DeviceNetwork.Systems;
+
+/// <inheritdoc/>
+public sealed class DeviceNetworkJammerSystem : SharedDeviceNetworkJammerSystem;

Content.Server/DeviceNetwork/Systems/DeviceNetworkJammerSystem.cs

@@ -1,12 +1,15 @@
-using Content.Server.DeviceNetwork.Components;
 using Content.Shared.DeviceNetwork.Components;
+using Content.Shared.DeviceNetwork.Systems;
 using Robust.Server.GameObjects;
 
 namespace Content.Server.DeviceNetwork.Systems;
 
-public sealed class DeviceNetworkJammerSystem : EntitySystem
+/// <inheritdoc/>
+public sealed class DeviceNetworkJammerSystem : SharedDeviceNetworkJammerSystem
 {
-    [Dependency] private TransformSystem _transform = default!;
+    [Dependency] private readonly TransformSystem _transform = default!;
+    [Dependency] private readonly SharedDeviceNetworkJammerSystem _jammer = default!;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -14,20 +17,20 @@ public sealed class DeviceNetworkJammerSystem : EntitySystem
         SubscribeLocalEvent<TransformComponent, BeforePacketSentEvent>(BeforePacketSent);
     }
 
-    private void BeforePacketSent(EntityUid uid, TransformComponent xform, BeforePacketSentEvent ev)
+    private void BeforePacketSent(Entity<TransformComponent> xform, ref BeforePacketSentEvent ev)
     {
         if (ev.Cancelled)
             return;
 
         var query = EntityQueryEnumerator<DeviceNetworkJammerComponent, TransformComponent>();
 
-        while (query.MoveNext(out _, out var jammerComp, out var jammerXform))
+        while (query.MoveNext(out var uid, out var jammerComp, out var jammerXform))
         {
-            if (!jammerComp.JammableNetworks.Contains(ev.NetworkId))
+            if (!_jammer.GetJammableNetworks((uid, jammerComp)).Contains(ev.NetworkId))
                 continue;
 
-            if (jammerXform.Coordinates.InRange(EntityManager, _transform, ev.SenderTransform.Coordinates, jammerComp.Range)
+            if (_transform.InRange(jammerXform.Coordinates, ev.SenderTransform.Coordinates, jammerComp.Range)
-                || jammerXform.Coordinates.InRange(EntityManager, _transform, xform.Coordinates, jammerComp.Range))
+                || _transform.InRange(jammerXform.Coordinates, xform.Comp.Coordinates, jammerComp.Range))
             {
                 ev.Cancel();
                 return;

Content.Server/Radio/Components/ActiveRadioJammerComponent.cs

@@ -1,12 +0,0 @@
-using Content.Server.Radio.EntitySystems;
-
-namespace Content.Server.Radio.Components;
-
-/// <summary>
-/// Prevents all radio in range from sending messages
-/// </summary>
-[RegisterComponent]
-[Access(typeof(JammerSystem))]
-public sealed partial class ActiveRadioJammerComponent : Component
-{
-}

Content.Server/Radio/EntitySystems/JammerSystem.cs

@@ -1,14 +1,12 @@
 using Content.Server.DeviceNetwork.Components;
-using Content.Server.Popups;
 using Content.Server.Power.EntitySystems;
 using Content.Server.PowerCell;
-using Content.Server.Radio.Components;
 using Content.Shared.DeviceNetwork.Components;
-using Content.Shared.Examine;
 using Content.Shared.Interaction;
 using Content.Shared.PowerCell.Components;
-using Content.Shared.RadioJammer;
 using Content.Shared.Radio.EntitySystems;
+using Content.Shared.Radio.Components;
+using Content.Shared.DeviceNetwork.Systems;
 
 namespace Content.Server.Radio.EntitySystems;
 
@@ -17,6 +15,7 @@ public sealed class JammerSystem : SharedJammerSystem
     [Dependency] private readonly PowerCellSystem _powerCell = default!;
     [Dependency] private readonly BatterySystem _battery = default!;
     [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly SharedDeviceNetworkJammerSystem _jammer = default!;
 
     public override void Initialize()
     {
@@ -24,7 +23,6 @@ public sealed class JammerSystem : SharedJammerSystem
 
         SubscribeLocalEvent<RadioJammerComponent, ActivateInWorldEvent>(OnActivate);
         SubscribeLocalEvent<ActiveRadioJammerComponent, PowerCellChangedEvent>(OnPowerCellChanged);
-        SubscribeLocalEvent<RadioJammerComponent, ExaminedEvent>(OnExamine);
         SubscribeLocalEvent<RadioSendAttemptEvent>(OnRadioSendAttempt);
     }
 
@@ -37,27 +35,22 @@ public sealed class JammerSystem : SharedJammerSystem
 
             if (_powerCell.TryGetBatteryFromSlot(uid, out var batteryUid, out var battery))
             {
-                if (!_battery.TryUseCharge(batteryUid.Value, GetCurrentWattage(jam) * frameTime, battery))
+                if (!_battery.TryUseCharge(batteryUid.Value, GetCurrentWattage((uid, jam)) * frameTime, battery))
                 {
-                    ChangeLEDState(false, uid);
+                    ChangeLEDState(uid, false);
                     RemComp<ActiveRadioJammerComponent>(uid);
                     RemComp<DeviceNetworkJammerComponent>(uid);
                 }
                 else
                 {
                     var percentCharged = battery.CurrentCharge / battery.MaxCharge;
-                    if (percentCharged > .50)
+                    var chargeLevel = percentCharged switch
                     {
-                        ChangeChargeLevel(RadioJammerChargeLevel.High, uid);
+                        > 0.50f => RadioJammerChargeLevel.High,
-                    }
+                        < 0.15f => RadioJammerChargeLevel.Low,
-                    else if (percentCharged < .15)
+                        _ => RadioJammerChargeLevel.Medium,
-                    {
+                    };
-                        ChangeChargeLevel(RadioJammerChargeLevel.Low, uid);
+                    ChangeChargeLevel(uid, chargeLevel);
-                    }
-                    else
-                    {
-                        ChangeChargeLevel(RadioJammerChargeLevel.Medium, uid);
-                    }
                 }
 
             }
@@ -65,28 +58,27 @@ public sealed class JammerSystem : SharedJammerSystem
         }
     }
 
-    private void OnActivate(EntityUid uid, RadioJammerComponent comp, ActivateInWorldEvent args)
+    private void OnActivate(Entity<RadioJammerComponent> ent, ref ActivateInWorldEvent args)
     {
         if (args.Handled || !args.Complex)
             return;
 
-        var activated = !HasComp<ActiveRadioJammerComponent>(uid) &&
+        var activated = !HasComp<ActiveRadioJammerComponent>(ent) &&
-            _powerCell.TryGetBatteryFromSlot(uid, out var battery) &&
+            _powerCell.TryGetBatteryFromSlot(ent.Owner, out var battery) &&
-            battery.CurrentCharge > GetCurrentWattage(comp);
+            battery.CurrentCharge > GetCurrentWattage(ent);
         if (activated)
         {
-            ChangeLEDState(true, uid);
+            ChangeLEDState(ent.Owner, true);
-            EnsureComp<ActiveRadioJammerComponent>(uid);
+            EnsureComp<ActiveRadioJammerComponent>(ent);
-            EnsureComp<DeviceNetworkJammerComponent>(uid, out var jammingComp);
+            EnsureComp<DeviceNetworkJammerComponent>(ent, out var jammingComp);
-            jammingComp.Range = GetCurrentRange(comp);
+            _jammer.SetRange((ent, jammingComp), GetCurrentRange(ent));
-            jammingComp.JammableNetworks.Add(DeviceNetworkComponent.DeviceNetIdDefaults.Wireless.ToString());
+            _jammer.AddJammableNetwork((ent, jammingComp), DeviceNetworkComponent.DeviceNetIdDefaults.Wireless.ToString());
-            Dirty(uid, jammingComp);
         }
         else
         {
-            ChangeLEDState(false, uid);
+            ChangeLEDState(ent.Owner, false);
-            RemCompDeferred<ActiveRadioJammerComponent>(uid);
+            RemCompDeferred<ActiveRadioJammerComponent>(ent);
-            RemCompDeferred<DeviceNetworkJammerComponent>(uid);
+            RemCompDeferred<DeviceNetworkJammerComponent>(ent);
         }
         var state = Loc.GetString(activated ? "radio-jammer-component-on-state" : "radio-jammer-component-off-state");
         var message = Loc.GetString("radio-jammer-component-on-use", ("state", state));
@@ -94,27 +86,12 @@ public sealed class JammerSystem : SharedJammerSystem
         args.Handled = true;
     }
 
-    private void OnPowerCellChanged(EntityUid uid, ActiveRadioJammerComponent comp, PowerCellChangedEvent args)
+    private void OnPowerCellChanged(Entity<ActiveRadioJammerComponent> ent, ref PowerCellChangedEvent args)
     {
         if (args.Ejected)
         {
-            ChangeLEDState(false, uid);
+            ChangeLEDState(ent.Owner, false);
-            RemCompDeferred<ActiveRadioJammerComponent>(uid);
+            RemCompDeferred<ActiveRadioJammerComponent>(ent);
-        }
-    }
-
-    private void OnExamine(EntityUid uid, RadioJammerComponent comp, ExaminedEvent args)
-    {
-        if (args.IsInDetailsRange)
-        {
-            var powerIndicator = HasComp<ActiveRadioJammerComponent>(uid)
-                ? Loc.GetString("radio-jammer-component-examine-on-state")
-                : Loc.GetString("radio-jammer-component-examine-off-state");
-            args.PushMarkup(powerIndicator);
-
-            var powerLevel = Loc.GetString(comp.Settings[comp.SelectedPowerLevel].Name);
-            var switchIndicator = Loc.GetString("radio-jammer-component-switch-setting", ("powerLevel", powerLevel));
-            args.PushMarkup(switchIndicator);
         }
     }
 
@@ -131,9 +108,9 @@ public sealed class JammerSystem : SharedJammerSystem
         var source = Transform(sourceUid).Coordinates;
         var query = EntityQueryEnumerator<ActiveRadioJammerComponent, RadioJammerComponent, TransformComponent>();
 
-        while (query.MoveNext(out _, out _, out var jam, out var transform))
+        while (query.MoveNext(out var uid, out _, out var jam, out var transform))
         {
-            if (source.InRange(EntityManager, _transform, transform.Coordinates, GetCurrentRange(jam)))
+            if (_transform.InRange(source, transform.Coordinates, GetCurrentRange((uid, jam))))
             {
                 return true;
             }

Content.Shared/DeviceNetwork/Components/DeviceNetworkJammerComponent.cs

@@ -1,3 +1,4 @@
+using Content.Shared.DeviceNetwork.Systems;
 using Robust.Shared.GameStates;
 
 namespace Content.Shared.DeviceNetwork.Components;
@@ -6,6 +7,7 @@ namespace Content.Shared.DeviceNetwork.Components;
 /// Allow entities to jam DeviceNetwork packets.
 /// </summary>
 [RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[Access(typeof(SharedDeviceNetworkJammerSystem))]
 public sealed partial class DeviceNetworkJammerComponent : Component
 {
     /// <summary>

Content.Shared/DeviceNetwork/Systems/SharedDeviceNetworkJammerSystem.cs

@@ -0,0 +1,63 @@
+using Content.Shared.DeviceNetwork.Components;
+
+namespace Content.Shared.DeviceNetwork.Systems;
+
+/// <inheritdoc cref="DeviceNetworkJammerComponent"/>
+public abstract class SharedDeviceNetworkJammerSystem : EntitySystem
+{
+    /// <summary>
+    /// Sets the range of the jamming effect.
+    /// </summary>
+    public void SetRange(Entity<DeviceNetworkJammerComponent> ent, float value)
+    {
+        ent.Comp.Range = value;
+        Dirty(ent);
+    }
+
+    /// <inheritdoc cref="SetRange"/>
+    public bool TrySetRange(Entity<DeviceNetworkJammerComponent?> ent, float value)
+    {
+        if (!Resolve(ent, ref ent.Comp, logMissing: false))
+            return false;
+
+        SetRange((ent, ent.Comp), value);
+        return true;
+    }
+
+    /// <summary>
+    /// Returns the set of networks that this entity can jam.
+    public IReadOnlySet<string> GetJammableNetworks(Entity<DeviceNetworkJammerComponent> ent)
+    {
+        return ent.Comp.JammableNetworks;
+    }
+
+    /// <summary>
+    /// Enables this entity to jam packets on the specified network.
+    /// </summary>
+    public void AddJammableNetwork(Entity<DeviceNetworkJammerComponent> ent, string networkId)
+    {
+        if (ent.Comp.JammableNetworks.Add(networkId))
+            Dirty(ent);
+    }
+
+    /// <summary>
+    /// Stops this entity from jamming packets on the specified network.
+    /// </summary>
+    public void RemoveJammableNetwork(Entity<DeviceNetworkJammerComponent> ent, string networkId)
+    {
+        if (ent.Comp.JammableNetworks.Remove(networkId))
+            Dirty(ent);
+    }
+
+    /// <summary>
+    /// Stops this entity from jamming packets on any networks.
+    /// </summary>
+    public void ClearJammableNetworks(Entity<DeviceNetworkJammerComponent> ent)
+    {
+        if (ent.Comp.JammableNetworks.Count == 0)
+            return;
+
+        ent.Comp.JammableNetworks.Clear();
+        Dirty(ent);
+    }
+}

Content.Shared/Radio/Components/ActiveRadioJammerComponent.cs

@@ -0,0 +1,13 @@
+using Content.Shared.Radio.EntitySystems;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Radio.Components;
+
+/// <summary>
+/// Prevents all radio in range from sending messages
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+[Access(typeof(SharedJammerSystem))]
+public sealed partial class ActiveRadioJammerComponent : Component
+{
+}

Content.Shared/Radio/Components/RadioJammerComponent.cs

@@ -1,13 +1,14 @@
 using Robust.Shared.Serialization;
 using Robust.Shared.GameStates;
 
-namespace Content.Shared.RadioJammer;
+namespace Content.Shared.Radio.Components;
 
 /// <summary>
 /// When activated (<see cref="ActiveRadioJammerComponent"/>) prevents from sending messages in range
 /// Suit sensors will also stop working.
 /// </summary>
 [NetworkedComponent, RegisterComponent]
+[AutoGenerateComponentState]
 public sealed partial class RadioJammerComponent : Component
 {
     [DataDefinition]
@@ -26,7 +27,7 @@ public sealed partial class RadioJammerComponent : Component
         public float Range;
 
         /// <summary>
-        /// The message that is displayed when switched 
+        /// The message that is displayed when switched.
         /// to this setting.
         /// </summary>
         [DataField(required: true)]
@@ -49,6 +50,7 @@ public sealed partial class RadioJammerComponent : Component
     /// Index of the currently selected setting.
     /// </summary>
     [DataField]
+    [AutoNetworkedField]
     public int SelectedPowerLevel = 1;
 }
 

Content.Shared/Radio/EntitySystems/SharedJammerSystem.cs

@@ -1,13 +1,15 @@
 using Content.Shared.Popups;
-using Content.Shared.DeviceNetwork.Components;
 using Content.Shared.Verbs;
-using Content.Shared.RadioJammer;
+using Content.Shared.Examine;
+using Content.Shared.Radio.Components;
+using Content.Shared.DeviceNetwork.Systems;
 
 namespace Content.Shared.Radio.EntitySystems;
 
 public abstract class SharedJammerSystem : EntitySystem
 {
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SharedDeviceNetworkJammerSystem _jammer = default!;
     [Dependency] protected readonly SharedPopupSystem Popup = default!;
 
     public override void Initialize()
@@ -15,6 +17,7 @@ public abstract class SharedJammerSystem : EntitySystem
         base.Initialize();
 
         SubscribeLocalEvent<RadioJammerComponent, GetVerbsEvent<Verb>>(OnGetVerb);
+        SubscribeLocalEvent<RadioJammerComponent, ExaminedEvent>(OnExamine);
     }
 
     private void OnGetVerb(Entity<RadioJammerComponent> entity, ref GetVerbsEvent<Verb> args)
@@ -38,13 +41,11 @@ public abstract class SharedJammerSystem : EntitySystem
                 Act = () =>
                 {
                     entity.Comp.SelectedPowerLevel = currIndex;
-                    if (TryComp<DeviceNetworkJammerComponent>(entity.Owner, out var jammerComp))
+                    Dirty(entity);
+                    if (_jammer.TrySetRange(entity.Owner, GetCurrentRange(entity)))
                     {
-                        // This is a little sketcy but only way to do it.
-                        jammerComp.Range = GetCurrentRange(entity.Comp);
-                        Dirty(entity.Owner, jammerComp);
-                    }
                         Popup.PopupPredicted(Loc.GetString(setting.Message), user, user);
+                    }
                 },
                 Text = Loc.GetString(setting.Name),
             };
@@ -53,26 +54,39 @@ public abstract class SharedJammerSystem : EntitySystem
         }
     }
 
-    public float GetCurrentWattage(RadioJammerComponent jammer)
+    private void OnExamine(Entity<RadioJammerComponent> ent, ref ExaminedEvent args)
     {
-        return jammer.Settings[jammer.SelectedPowerLevel].Wattage;
+        if (args.IsInDetailsRange)
+        {
+            var powerIndicator = HasComp<ActiveRadioJammerComponent>(ent)
+                ? Loc.GetString("radio-jammer-component-examine-on-state")
+                : Loc.GetString("radio-jammer-component-examine-off-state");
+            args.PushMarkup(powerIndicator);
+
+            var powerLevel = Loc.GetString(ent.Comp.Settings[ent.Comp.SelectedPowerLevel].Name);
+            var switchIndicator = Loc.GetString("radio-jammer-component-switch-setting", ("powerLevel", powerLevel));
+            args.PushMarkup(switchIndicator);
+        }
     }
 
-    public float GetCurrentRange(RadioJammerComponent jammer)
+    public float GetCurrentWattage(Entity<RadioJammerComponent> jammer)
     {
-        return jammer.Settings[jammer.SelectedPowerLevel].Range;
+        return jammer.Comp.Settings[jammer.Comp.SelectedPowerLevel].Wattage;
     }
 
-    protected void ChangeLEDState(bool isLEDOn, EntityUid uid,
+    public float GetCurrentRange(Entity<RadioJammerComponent> jammer)
-        AppearanceComponent? appearance = null)
     {
-        _appearance.SetData(uid, RadioJammerVisuals.LEDOn, isLEDOn, appearance);
+        return jammer.Comp.Settings[jammer.Comp.SelectedPowerLevel].Range;
     }
 
-    protected void ChangeChargeLevel(RadioJammerChargeLevel chargeLevel, EntityUid uid,
+    protected void ChangeLEDState(Entity<AppearanceComponent?> ent, bool isLEDOn)
-        AppearanceComponent? appearance = null)
     {
-        _appearance.SetData(uid, RadioJammerVisuals.ChargeLevel, chargeLevel, appearance);
+        _appearance.SetData(ent, RadioJammerVisuals.LEDOn, isLEDOn, ent.Comp);
+    }
+
+    protected void ChangeChargeLevel(Entity<AppearanceComponent?> ent, RadioJammerChargeLevel chargeLevel)
+    {
+        _appearance.SetData(ent, RadioJammerVisuals.ChargeLevel, chargeLevel, ent.Comp);
     }
 
 }