decouple ItemToggle from PowerCellDraw (#31392)

* remove ItemToggle from PowerCellDraw query

* add EntityQuery for resolves, make them all optional

* move integration to ToggleCellDraw

* add ToggleCellDraw to almost every PowerCellDraw prototype

* :trollface:

* :trollface:

* :trollface:

* let it disable on mapinit

* set update time on mapinit, make borg power logic consistent now

* :trollface:

---------

Co-authored-by: deltanedas <@deltanedas:kde.org>

Content.Shared/PowerCell/Components/ToggleCellDrawComponent.cs

@@ -0,0 +1,10 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.PowerCell.Components;
+
+/// <summary>
+/// Integrate PowerCellDraw and ItemToggle.
+/// Make toggling this item require power, and deactivates the item when power runs out.
+/// </summary>
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ToggleCellDrawComponent : Component;

Content.Shared/PowerCell/PowerCellDrawComponent.cs

@@ -8,7 +8,6 @@ namespace Content.Shared.PowerCell;
 /// </summary>
 /// <remarks>
 /// With ActivatableUI it will activate and deactivate when the ui is opened and closed, drawing power inbetween.
-/// Requires <see cref="ItemToggleComponent"/> to work.
 /// </remarks>
 [RegisterComponent, NetworkedComponent, AutoGenerateComponentState, AutoGenerateComponentPause]
 public sealed partial class PowerCellDrawComponent : Component
@@ -30,9 +29,8 @@ public sealed partial class PowerCellDrawComponent : Component
     #endregion
 
     /// <summary>
-    /// Whether drawing is enabled, regardless of ItemToggle.
+    /// Whether drawing is enabled.
     /// Having no cell will still disable it.
-    /// Only use this if you really don't want it to use power for some time.
     /// </summary>
     [DataField, AutoNetworkedField]
     public bool Enabled = true;

Content.Shared/PowerCell/SharedPowerCellSystem.cs

@@ -1,6 +1,4 @@
 using Content.Shared.Containers.ItemSlots;
-using Content.Shared.Item.ItemToggle;
-using Content.Shared.Item.ItemToggle.Components;
 using Content.Shared.PowerCell.Components;
 using Content.Shared.Rejuvenate;
 using Robust.Shared.Containers;
@@ -13,19 +11,22 @@ public abstract class SharedPowerCellSystem : EntitySystem
     [Dependency] protected readonly IGameTiming Timing = default!;
     [Dependency] private readonly ItemSlotsSystem _itemSlots = default!;
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
-    [Dependency] protected readonly ItemToggleSystem Toggle = default!;
 
     public override void Initialize()
     {
         base.Initialize();
 
+        SubscribeLocalEvent<PowerCellDrawComponent, MapInitEvent>(OnMapInit);
+
         SubscribeLocalEvent<PowerCellSlotComponent, RejuvenateEvent>(OnRejuvenate);
         SubscribeLocalEvent<PowerCellSlotComponent, EntInsertedIntoContainerMessage>(OnCellInserted);
         SubscribeLocalEvent<PowerCellSlotComponent, EntRemovedFromContainerMessage>(OnCellRemoved);
         SubscribeLocalEvent<PowerCellSlotComponent, ContainerIsInsertingAttemptEvent>(OnCellInsertAttempt);
+    }
 
-        SubscribeLocalEvent<PowerCellDrawComponent, ItemToggleActivateAttemptEvent>(OnActivateAttempt);
-        SubscribeLocalEvent<PowerCellDrawComponent, ItemToggledEvent>(OnToggled);
+    private void OnMapInit(Entity<PowerCellDrawComponent> ent, ref MapInitEvent args)
+    {
+        QueueUpdate((ent, ent.Comp));
     }
 
     private void OnRejuvenate(EntityUid uid, PowerCellSlotComponent component, RejuvenateEvent args)
@@ -70,16 +71,13 @@ public abstract class SharedPowerCellSystem : EntitySystem
         RaiseLocalEvent(uid, new PowerCellChangedEvent(true), false);
     }
 
-    private void OnActivateAttempt(Entity<PowerCellDrawComponent> ent, ref ItemToggleActivateAttemptEvent args)
+    /// <summary>
+    /// Makes the draw logic update in the next tick.
+    /// </summary>
+    public void QueueUpdate(Entity<PowerCellDrawComponent?> ent)
     {
-        if (!HasDrawCharge(ent, ent.Comp, user: args.User)
-            || !HasActivatableCharge(ent, ent.Comp, user: args.User))
-            args.Cancelled = true;
-    }
-
-    private void OnToggled(Entity<PowerCellDrawComponent> ent, ref ItemToggledEvent args)
-    {
-        ent.Comp.NextUpdateTime = Timing.CurTime;
+        if (Resolve(ent, ref ent.Comp))
+            ent.Comp.NextUpdateTime = Timing.CurTime;
     }
 
     public void SetDrawEnabled(Entity<PowerCellDrawComponent?> ent, bool enabled)

Content.Shared/PowerCell/ToggleCellDrawSystem.cs

@@ -0,0 +1,49 @@
+using Content.Shared.Item.ItemToggle;
+using Content.Shared.Item.ItemToggle.Components;
+using Content.Shared.PowerCell.Components;
+
+namespace Content.Shared.PowerCell;
+
+/// <summary>
+/// Handles events to integrate PowerCellDraw with ItemToggle
+/// </summary>
+public sealed class ToggleCellDrawSystem : EntitySystem
+{
+    [Dependency] private readonly ItemToggleSystem _toggle = default!;
+    [Dependency] private readonly SharedPowerCellSystem _cell = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ToggleCellDrawComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ToggleCellDrawComponent, ItemToggleActivateAttemptEvent>(OnActivateAttempt);
+        SubscribeLocalEvent<ToggleCellDrawComponent, ItemToggledEvent>(OnToggled);
+        SubscribeLocalEvent<ToggleCellDrawComponent, PowerCellSlotEmptyEvent>(OnEmpty);
+    }
+
+    private void OnMapInit(Entity<ToggleCellDrawComponent> ent, ref MapInitEvent args)
+    {
+        _cell.SetDrawEnabled(ent.Owner, _toggle.IsActivated(ent.Owner));
+    }
+
+    private void OnActivateAttempt(Entity<ToggleCellDrawComponent> ent, ref ItemToggleActivateAttemptEvent args)
+    {
+        if (!_cell.HasDrawCharge(ent, user: args.User)
+            || !_cell.HasActivatableCharge(ent, user: args.User))
+            args.Cancelled = true;
+    }
+
+    private void OnToggled(Entity<ToggleCellDrawComponent> ent, ref ItemToggledEvent args)
+    {
+        var uid = ent.Owner;
+        var draw = Comp<PowerCellDrawComponent>(uid);
+        _cell.QueueUpdate((uid, draw));
+        _cell.SetDrawEnabled((uid, draw), args.Activated);
+    }
+
+    private void OnEmpty(Entity<ToggleCellDrawComponent> ent, ref PowerCellSlotEmptyEvent args)
+    {
+        _toggle.TryDeactivate(ent.Owner);
+    }
+}