Display current load and maximum capacity (#20181)

Content.Client/Ame/UI/AmeWindow.xaml

@@ -1,7 +1,7 @@
-<DefaultWindow xmlns="https://spacestation14.io"
+<DefaultWindow xmlns="https://spacestation14.io"
             Title="{Loc 'ame-window-title'}"
             MinSize="250 250">
-    <BoxContainer Orientation="Vertical">
+    <GridContainer Columns="2">
         <BoxContainer Orientation="Horizontal">
             <Label Text="{Loc 'ame-window-engine-status-label'}" />
             <Label Text=" " />
@@ -42,5 +42,19 @@
             <Label Text=" " />
             <Label Name="CoreCount" Text="0" />
         </BoxContainer>
-    </BoxContainer>
+        <BoxContainer></BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'ame-window-power-currentsupply-label'}" />
+            <Label Text=" " />
+            <Label Name="CurrentPowerSupply" Text="0" />
+            <Label Text=" kW" />
+        </BoxContainer>
+        <BoxContainer></BoxContainer>
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'ame-window-power-targetsupply-label'}" />
+            <Label Text=" " />
+            <Label Name="TargetedPowerSupply" Text="0" />
+            <Label Text=" kW" />
+        </BoxContainer>
+    </GridContainer>
 </DefaultWindow>

Content.Client/Ame/UI/AmeWindow.xaml.cs

@@ -64,6 +64,9 @@ namespace Content.Client.Ame.UI
 
             CoreCount.Text = $"{castState.CoreCount}";
             InjectionAmount.Text = $"{castState.InjectionAmount}";
+            // format power statistics to pretty numbers
+            CurrentPowerSupply.Text = $"{castState.CurrentPowerSupply.ToString("N1")}";
+            TargetedPowerSupply.Text = $"{castState.TargetedPowerSupply.ToString("N1")}";
         }
     }
 }

Content.Server/Ame/AmeNodeGroup.cs

@@ -126,11 +126,7 @@ public sealed class AmeNodeGroup : BaseNodeGroup
 
         var safeFuelLimit = CoreCount * 2;
 
-        // Note the float conversions. The maths will completely fail if not done using floats.
+        var powerOutput = CalculatePower(fuel, CoreCount);
-        // Oh, and don't ever stuff the result of this in an int. Seriously.
-        var floatFuel = (float) fuel;
-        var floatCores = (float) CoreCount;
-        var powerOutput = 20000f * floatFuel * floatFuel / floatCores;
         if (fuel <= safeFuelLimit)
             return powerOutput;
 
@@ -177,6 +173,17 @@ public sealed class AmeNodeGroup : BaseNodeGroup
         return powerOutput;
     }
 
+    /// <summary>
+    /// Calculates the amount of power the AME can produce with the given settings
+    /// </summary>
+    public float CalculatePower(int fuel, int cores)
+    {
+        // Fuel is squared so more fuel vastly increases power and efficiency
+        // We divide by the number of cores so a larger AME is less efficient at the same fuel settings
+        // this results in all AMEs having the same efficiency at the same fuel-per-core setting
+        return 20000f * fuel * fuel / cores;
+    }
+
     public int GetTotalStability()
     {
         if (CoreCount < 1)

Content.Server/Ame/Components/AmeControllerComponent.cs

@@ -72,10 +72,21 @@ public sealed partial class AmeControllerComponent : SharedAmeControllerComponen
     [DataField("nextUpdate")]
     public TimeSpan NextUpdate = default!;
 
+    /// <summary>
+    /// The next time this will try to update the controller UI.
+    /// </summary>
+    public TimeSpan NextUIUpdate = default!;
+
     /// <summary>
     /// The the amount of time that passes between injection attempts.
     /// </summary>
     [DataField("updatePeriod")]
     [ViewVariables(VVAccess.ReadWrite)]
     public TimeSpan UpdatePeriod = TimeSpan.FromSeconds(10.0);
+
+    /// <summary>
+    /// The maximum amount of time that passes between UI updates.
+    /// </summary>
+    [ViewVariables]
+    public TimeSpan UpdateUIPeriod = TimeSpan.FromSeconds(3.0);
 }

Content.Server/Ame/EntitySystems/AmeControllerSystem.cs

@@ -50,6 +50,8 @@ public sealed class AmeControllerSystem : EntitySystem
         {
             if (controller.NextUpdate <= curTime)
                 UpdateController(uid, curTime, controller, nodes);
+            else if (controller.NextUIUpdate <= curTime)
+                UpdateUi(uid, controller);
         }
     }
 
@@ -60,6 +62,8 @@ public sealed class AmeControllerSystem : EntitySystem
 
         controller.LastUpdate = curTime;
         controller.NextUpdate = curTime + controller.UpdatePeriod;
+        // update the UI regardless of other factors to update the power readings
+        UpdateUi(uid, controller);
 
         if (!controller.Injecting)
             return;
@@ -106,18 +110,35 @@ public sealed class AmeControllerSystem : EntitySystem
 
         var state = GetUiState(uid, controller);
         _userInterfaceSystem.SetUiState(bui, state);
+
+        controller.NextUIUpdate = _gameTiming.CurTime + controller.UpdateUIPeriod;
     }
 
     private AmeControllerBoundUserInterfaceState GetUiState(EntityUid uid, AmeControllerComponent controller)
     {
         var powered = !TryComp<ApcPowerReceiverComponent>(uid, out var powerSource) || powerSource.Powered;
-        var coreCount = TryGetAMENodeGroup(uid, out var group) ? group.CoreCount : 0;
+        var coreCount = 0;
+        // how much power can be produced at the current settings, in kW
+        // we don't use max. here since this is what is set in the Controller, not what the AME is actually producing
+        float targetedPowerSupply = 0;
+        if (TryGetAMENodeGroup(uid, out var group))
+        {
+            coreCount = group.CoreCount;
+            targetedPowerSupply = group.CalculatePower(controller.InjectionAmount, group.CoreCount) / 1000;
+        }
+
+        // set current power statistics in kW
+        float currentPowerSupply = 0;
+        if (TryComp<PowerSupplierComponent>(uid, out var powerOutlet) && coreCount > 0)
+        {
+            currentPowerSupply = powerOutlet.CurrentSupply / 1000;
+        }
 
         var hasJar = Exists(controller.JarSlot.ContainedEntity);
         if (!hasJar || !TryComp<AmeFuelContainerComponent>(controller.JarSlot.ContainedEntity, out var jar))
-            return new AmeControllerBoundUserInterfaceState(powered, IsMasterController(uid), false, hasJar, 0, controller.InjectionAmount, coreCount);
+            return new AmeControllerBoundUserInterfaceState(powered, IsMasterController(uid), false, hasJar, 0, controller.InjectionAmount, coreCount, currentPowerSupply, targetedPowerSupply);
 
-        return new AmeControllerBoundUserInterfaceState(powered, IsMasterController(uid), controller.Injecting, hasJar, jar.FuelAmount, controller.InjectionAmount, coreCount);
+        return new AmeControllerBoundUserInterfaceState(powered, IsMasterController(uid), controller.Injecting, hasJar, jar.FuelAmount, controller.InjectionAmount, coreCount, currentPowerSupply, targetedPowerSupply);
     }
 
     private bool IsMasterController(EntityUid uid)

Content.Shared/Ame/SharedAmeControllerComponent.cs

@@ -1,4 +1,4 @@
-using Robust.Shared.Serialization;
+using Robust.Shared.Serialization;
 
 namespace Content.Shared.Ame;
 
@@ -17,8 +17,10 @@ public sealed class AmeControllerBoundUserInterfaceState : BoundUserInterfaceSta
     public readonly int FuelAmount;
     public readonly int InjectionAmount;
     public readonly int CoreCount;
+    public readonly float CurrentPowerSupply;
+    public readonly float TargetedPowerSupply;
 
-    public AmeControllerBoundUserInterfaceState(bool hasPower, bool isMaster, bool injecting, bool hasFuelJar, int fuelAmount, int injectionAmount, int coreCount)
+    public AmeControllerBoundUserInterfaceState(bool hasPower, bool isMaster, bool injecting, bool hasFuelJar, int fuelAmount, int injectionAmount, int coreCount, float currentPowerSupply, float targetedPowerSupply)
     {
         HasPower = hasPower;
         IsMaster = isMaster;
@@ -27,6 +29,8 @@ public sealed class AmeControllerBoundUserInterfaceState : BoundUserInterfaceSta
         FuelAmount = fuelAmount;
         InjectionAmount = injectionAmount;
         CoreCount = coreCount;
+        CurrentPowerSupply = currentPowerSupply;
+        TargetedPowerSupply = targetedPowerSupply;
     }
 }
 

Resources/Locale/en-US/ame/components/ame-controller-component.ftl

@@ -16,6 +16,8 @@ ame-window-fuel-not-inserted-text = No fuel inserted
 ame-window-injection-amount-label = Injection amount:
 ame-window-refresh-parts-button = Refresh Parts
 ame-window-core-count-label = Core count:
+ame-window-power-currentsupply-label = Current power supply:
+ame-window-power-targetsupply-label = Targeted power supply:
 ame-window-toggle-injection-button = Toggle Injection
 ame-window-eject-button = Eject
 ame-window-increase-fuel-button = Increase