Make APCs emp (when turned on) after a random delay during a power grid check

Content.Server/Power/EntitySystems/ApcSystem.cs

@@ -113,6 +113,8 @@ public void ApcToggleBreaker(EntityUid uid, ApcComponent? apc = null, PowerNetwo
         apc.MainBreakerEnabled = !apc.MainBreakerEnabled;
         battery.CanDischarge = apc.MainBreakerEnabled;
 
+        RaiseLocalEvent(uid, new ApcToggledMainBreakerEvent(apc.MainBreakerEnabled)); // Umbra - ElectricalOverload
+
         UpdateUIState(uid, apc);
         _audio.PlayPvs(apc.OnReceiveMessageSound, uid, AudioParams.Default.WithVolume(-2f));
     }
@@ -241,3 +243,5 @@ private void OnToolUseAttempt(EntityUid uid, ApcComponent component, ToolUseAtte
 
 [ByRefEvent]
 public record struct ApcToggleMainBreakerAttemptEvent(bool Cancelled);
+
+public record struct ApcToggledMainBreakerEvent(bool Enabled); // Umbra - ElectricalOverload

Content.Server/StationEvents/Events/PowerGridCheckRule.cs

@@ -1,4 +1,6 @@
 using System.Threading;
+using Content.Server._NF.Tools.Components; // Frontier
+using Content.Server.GameTicking.Rules.Components;
 using Content.Server.Power.Components;
 using Content.Server.Power.EntitySystems;
 using Content.Server.StationEvents.Components;
@@ -52,6 +54,9 @@
                     if(!apcComponent.MainBreakerEnabled)
                         _apcSystem.ApcToggleBreaker(entity, apcComponent);
                 }
+
+                RemComp<ElectricalOverloadComponent>(entity); // Umbra - ElectricalOverload
+                RemComp<OnToolsUseComponent>(entity); // Umbra - ElectricalOverload
             }
 
             // Can't use the default EndAudio
@@ -87,7 +92,12 @@
                 if (TryComp<ApcComponent>(selected, out var apcComponent))
                 {
                     if (apcComponent.MainBreakerEnabled)
+                    {
                         _apcSystem.ApcToggleBreaker(selected, apcComponent);
+                        EnsureComp<ElectricalOverloadComponent>(selected); // Umbra - ElectricalOverload
+                        var onToolUse = EnsureComp<OnToolsUseComponent>(selected); // Umbra - ElectricalOverload
+                        onToolUse.Disabled = true; // Umbra - ElectricalOverload
+                    }
                 }
                 component.Unpowered.Add(selected);
             }

Content.Server/_Umbra/Power/Components/ElectricalOverloadComponent.cs

@@ -0,0 +1,29 @@
+namespace Content.Server.Power.Components;
+
+[RegisterComponent]
+public sealed partial class ElectricalOverloadComponent : Component
+{
+    [ViewVariables]
+    public DateTime EmpAt = DateTime.MaxValue;
+
+    [ViewVariables]
+    public DateTime NextBuzz = DateTime.MaxValue;
+
+    /// <summary>
+    /// Range of the EMP in tiles.
+    /// </summary>
+    [DataField]
+    public float EmpRange = 1f;
+
+    /// <summary>
+    /// Power consumed from batteries by the EMP
+    /// </summary>
+    [DataField]
+    public float EmpConsumption = 100000f;
+
+    /// <summary>
+    /// How long the EMP effects last for, in seconds
+    /// </summary>
+    [DataField]
+    public float EmpDuration = 15f;
+}

Content.Server/_Umbra/Power/EntitySystems/ElectricalOverloadSystem.cs

@@ -0,0 +1,67 @@
+using Content.Server.Chat.Systems;
+using Content.Server.Emp;
+using Content.Server.Power.Components;
+using Robust.Shared.Random;
+
+namespace Content.Server.Power.EntitySystems;
+
+public sealed class ElectricalOverloadSystem : EntitySystem
+{
+    [Dependency] private readonly EmpSystem _emp = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly ChatSystem _chatSystem = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ElectricalOverloadComponent, ApcToggledMainBreakerEvent>(OnApcToggleMainBreaker);
+    }
+
+    private void OnApcToggleMainBreaker(EntityUid uid, ElectricalOverloadComponent component, ApcToggledMainBreakerEvent args)
+    {
+        if (args.Enabled)
+        {
+            // Toggled on, means Emp!
+            component.EmpAt = DateTime.Now + TimeSpan.FromSeconds(_random.NextDouble(25, 35));
+            component.NextBuzz = DateTime.Now + TimeSpan.FromSeconds(_random.NextDouble(3, 5));
+        }
+        else
+        {
+            // Toggled off, means cancel emp.
+            component.EmpAt = DateTime.MaxValue;
+            component.NextBuzz = DateTime.MaxValue;
+        }
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var enumerator = EntityQueryEnumerator<ElectricalOverloadComponent>();
+        while (enumerator.MoveNext(out var entity, out var component))
+        {
+            if (component.EmpAt > DateTime.Now)
+            {
+                if (component.NextBuzz > DateTime.Now)
+                    continue;
+
+                component.NextBuzz = DateTime.Now + TimeSpan.FromSeconds(_random.NextDouble(7, 15));
+                _chatSystem.TrySendInGameICMessage(
+                    entity,
+                    Loc.GetString("electrical-overload-system-buzz"),
+                    InGameICChatType.Emote,
+                    hideChat: true,
+                    ignoreActionBlocker: true
+                );
+                continue;
+            }
+
+            var coords = _transform.GetMapCoordinates(entity); // Frontier - EMP
+            _emp.EmpPulse(coords, component.EmpRange, component.EmpConsumption, component.EmpDuration); // Frontier - EMP
+            // if the device survives, we add a bit of randomness to the next emp time
+            component.EmpAt = DateTime.Now + TimeSpan.FromSeconds(_random.NextDouble(3, 10));
+        }
+    }
+}

Resources/Locale/en-US/_Umbra/power/overload.ftl

@@ -0,0 +1 @@
+electrical-overload-system-buzz = buzzes