Made the whole thing not dumb.

Microwave needs the YAML added.

Content.Server/Kitchen/EntitySystems/MicrowaveSystem.cs

@@ -182,6 +182,7 @@ private void SubtractContents(MicrowaveComponent component, FoodRecipePrototype
         private void OnInit(EntityUid uid, MicrowaveComponent component, ComponentInit ags)
         {
             component.Storage = _container.EnsureContainer<Container>(uid, "microwave_entity_container");
+            _variablePower.SetActive(uid, false); // Parkstation-VariablePower // Parkstation-VariablePower
         }
 
         private void OnSuicide(EntityUid uid, MicrowaveComponent component, SuicideEvent args)

Content.Server/Power/EntitySystems/UpgradePowerSystem.cs

@@ -1,6 +1,8 @@
 using Content.Server.Construction;
 using Content.Server.Construction.Components;
 using Content.Server.Power.Components;
+using Content.Server.SimpleStation14.Power.Components;
+using Content.Server.SimpleStation14.Power.Systems;
 
 namespace Content.Server.Power.EntitySystems;
 
@@ -10,6 +12,8 @@ namespace Content.Server.Power.EntitySystems;
 /// </summary>
 public sealed class UpgradePowerSystem : EntitySystem
 {
+    [Dependency] private readonly VariablePowerSystem _variablePower = default!; // Parkstation-VariablePower
+
     /// <inheritdoc/>
     public override void Initialize()
     {
@@ -24,7 +28,11 @@ public override void Initialize()
 
     private void OnMapInit(EntityUid uid, UpgradePowerDrawComponent component, MapInitEvent args)
     {
-        if (TryComp<PowerConsumerComponent>(uid, out var powa))
+        // Parkstation-VariablePower-Start
+        if (TryComp<VariablePowerComponent>(uid, out var varPower))
+            component.BaseLoad = varPower.ActiveLoad;
+        // Parkstation-VariablePower-End
+        else if (TryComp<PowerConsumerComponent>(uid, out var powa))
             component.BaseLoad = powa.DrawRate;
         else if (TryComp<ApcPowerReceiverComponent>(uid, out var powa2))
             component.BaseLoad = powa2.Load;
@@ -51,13 +59,20 @@ private void OnRefreshParts(EntityUid uid, UpgradePowerDrawComponent component,
             powa.Load = load;
         if (TryComp<PowerConsumerComponent>(uid, out var powa2))
             powa2.DrawRate = load;
+        // Parkstation-VariablePower-Start
+        if (TryComp<VariablePowerComponent>(uid, out var varPower))
+            _variablePower.ChangeVariablePowerBaseLoad(uid, load, null, varPower);
+        // Parkstation-VariablePower-End
     }
 
     private void OnUpgradeExamine(EntityUid uid, UpgradePowerDrawComponent component, UpgradeExamineEvent args)
     {
         // UpgradePowerDrawComponent.PowerDrawMultiplier is not the actual multiplier, so we have to do this.
-        var powerDrawMultiplier = CompOrNull<ApcPowerReceiverComponent>(uid)?.Load / component.BaseLoad
+        // Parkstation-VariablePower-Start
+        var powerDrawMultiplier = CompOrNull<VariablePowerComponent>(uid)?.ActiveLoad / component.BaseLoad
+            ?? CompOrNull<ApcPowerReceiverComponent>(uid)?.Load / component.BaseLoad
             ?? CompOrNull<PowerConsumerComponent>(uid)?.DrawRate / component.BaseLoad;
+        // Parkstation-VariablePower-End
 
         if (powerDrawMultiplier is not null)
             args.AddPercentageUpgrade("upgrade-power-draw", powerDrawMultiplier.Value);

Content.Server/SimpleStation14/Power/Components/VariablePowerComponent.cs

@@ -1,3 +1,6 @@
+using System.ComponentModel.DataAnnotations;
+using Robust.Shared.Serialization.TypeSerializers.Implementations;
+
 namespace Content.Server.SimpleStation14.Power.Components;
 
 /// <summary>
@@ -6,13 +9,33 @@ namespace Content.Server.SimpleStation14.Power.Components;
 [RegisterComponent]
 public sealed class VariablePowerComponent : Component
 {
-    [DataField("powerActiveMulti")]
-    public float PowerActiveMulti = 5.0f;
+    /// <summary>
+    ///     The amount of power to draw when set to active.
+    /// </summary>
+    [DataField("activeLoad"), ViewVariables(VVAccess.ReadWrite)]
+    public float ActiveLoad = 500;
+
+    /// <summary>
+    ///     The amount of power to draw when told to 'pulse'.
+    /// </summary>
+    [DataField("pulseLoad"), Required, ViewVariables(VVAccess.ReadWrite)]
+    public float PulseLoad = 5000;
 
-    [DataField("powerIdleMulti")]
-    public float PowerIdleMulti = 0.1f;
+    /// <summary>
+    ///     The amount of time this device pulses for.
+    /// </summary>
+    [DataField("pulseTime", customTypeSerializer: typeof(TimespanSerializer)), ViewVariables(VVAccess.ReadWrite)]
+    public TimeSpan PulseTime = TimeSpan.FromSeconds(1);
 
-    public float AddedValue = 0f;
+    /// <summary>
+    ///     The multiplier for how much power to draw when idle.
+    /// </summary>
+    [DataField("powerIdleMulti"), ViewVariables(VVAccess.ReadWrite)]
+    public float IdleMulti = 0.1f;
 
+    /// <summary>
+    ///     Whether the device is currently active.
+    /// </summary>
+    [ViewVariables(VVAccess.ReadOnly)]
     public bool Active = false;
 }

Content.Server/SimpleStation14/Power/Components/VariablePowerPulsingComponent.cs

@@ -1,7 +1,18 @@
 namespace Content.Server.SimpleStation14.Power.Components;
 
+/// <summary>
+///     Registers an item as currently experiencing a pulse in power usage.
+/// </summary>
 [RegisterComponent]
 public sealed class VariablePowerPulsingComponent : Component
 {
+    /// <summary>
+    ///     The time at which the pulse is done.
+    /// </summary>
     public TimeSpan PulseDoneTime = TimeSpan.FromSeconds(1);
+
+    /// <summary>
+    ///     Whether the device should return to an active or inactive state after the pulse is done.
+    /// </summary>
+    public bool NonPulseState = false;
 }

Content.Server/SimpleStation14/Power/Systems/VariablePowerSystem.cs

@@ -8,13 +8,6 @@ public sealed class VariablePowerSystem : EntitySystem
 {
     [Dependency] private readonly IGameTiming _timing = default!;
 
-    public override void Initialize()
-    {
-        base.Initialize();
-
-        SubscribeLocalEvent<VariablePowerComponent, ComponentInit>(OnVariablePowerInit);
-    }
-
     public override void Update(float frameTime)
     {
         base.Update(frameTime);
@@ -23,10 +16,7 @@ public override void Update(float frameTime)
         while (query.MoveNext(out var uid, out var powerPulseComp))
         {
             if (powerPulseComp.PulseDoneTime <= _timing.CurTime)
-            {
-                SetActive(uid, false);
-                RemComp<VariablePowerPulsingComponent>(uid);
-            }
+                PowerPulseDone(uid, powerPulseComp);
         }
     }
 
@@ -35,34 +25,58 @@ public void SetActive(EntityUid uid, bool active, ApcPowerReceiverComponent? apc
         if (!Resolve(uid, ref apcPowerComp))
             return;
         if (!Resolve(uid, ref varPowerComp))
-            varPowerComp = EnsureComp<VariablePowerComponent>(uid);
+            varPowerComp = AddComp<VariablePowerComponent>(uid);
 
-        if (active == varPowerComp.Active)
-            return;
-
-        varPowerComp.Active = active;
-        if (active)
+        if (TryComp<VariablePowerPulsingComponent>(uid, out var pulseComp))
         {
-            var addition = apcPowerComp.Load * varPowerComp.PowerActiveMulti - apcPowerComp.Load;
-            apcPowerComp.Load += addition;
-            varPowerComp.AddedValue = addition;
+            pulseComp.NonPulseState = active;
+            return;
         }
-        else
+
+        SetActiveInternal(apcPowerComp, varPowerComp, active);
+    }
+
+    public void DoPowerPulse(EntityUid uid, ApcPowerReceiverComponent? apcPowerComp = null, VariablePowerComponent? varPowerComp = null)
+    {
+        if (!Resolve(uid, ref apcPowerComp))
+            return;
+        if (!Resolve(uid, ref varPowerComp))
+            varPowerComp = AddComp<VariablePowerComponent>(uid);
+
+        if (TryComp<VariablePowerPulsingComponent>(uid, out var pulseComp))
         {
-            apcPowerComp.Load -= varPowerComp.AddedValue;
-            varPowerComp.AddedValue = 0f;
+            pulseComp.PulseDoneTime = _timing.CurTime + varPowerComp.PulseTime;
+            return;
         }
+
+        SetActiveInternal(apcPowerComp, varPowerComp, true, true);
+        AddComp<VariablePowerPulsingComponent>(uid).PulseDoneTime = _timing.CurTime + varPowerComp.PulseTime;
     }
 
-    public void DoPowerPulse(EntityUid uid, ApcPowerReceiverComponent? apcPowerComp = null, VariablePowerComponent? varPowerComp = null)
+    private void PowerPulseDone(EntityUid uid, VariablePowerPulsingComponent pulseComp)
     {
-        SetActive(uid, true, apcPowerComp, varPowerComp);
+        if (!TryComp<ApcPowerReceiverComponent>(uid, out var apcPowerComp) || !TryComp<VariablePowerComponent>(uid, out var varPowerComp))
+            return;
 
-        EnsureComp<VariablePowerPulsingComponent>(uid);
+        SetActiveInternal(apcPowerComp, varPowerComp, pulseComp.NonPulseState);
+
+        RemComp<VariablePowerPulsingComponent>(uid);
     }
 
-    private void OnVariablePowerInit(EntityUid uid, VariablePowerComponent component, ComponentInit args)
+    public void ChangeVariablePowerBaseLoad(EntityUid uid, float newBaseLoad, ApcPowerReceiverComponent? apcPowerComp = null, VariablePowerComponent? varPowerComp = null)
     {
-        SetActive(uid, false); // This might not be perfect, but the given system can deal with that.
+        if (!Resolve(uid, ref apcPowerComp))
+            return;
+        if (!Resolve(uid, ref varPowerComp))
+            varPowerComp = AddComp<VariablePowerComponent>(uid);
+
+        varPowerComp.ActiveLoad = newBaseLoad;
+        SetActive(uid, varPowerComp.Active, null, varPowerComp);
+    }
+
+    private void SetActiveInternal(ApcPowerReceiverComponent apcPowerComp, VariablePowerComponent varPowerComp, bool active, bool pulse = false)
+    {
+        varPowerComp.Active = active;
+        apcPowerComp.Load = !active ? varPowerComp.ActiveLoad * varPowerComp.IdleMulti : pulse ? varPowerComp.PulseLoad : varPowerComp.ActiveLoad; // If not active > idle power, if pulse > pulse power, if active > active pwoer.
     }
 }