Adds the thermo-electric generator (#18840)

* Basic TEG start.

Connects via node group.

* Basic TEG test map

* Sensor monitoring basics, TEG circulator flow

* Basic power generation (it doesn't work)

* More sensor monitoring work

* Battery (SMES) monitoring system.

* Sensor monitoring fixes

Make it work properly when mapped.

* Test map improvements

* Revise TEG power output mechanism.

Now uses a fixed supplier with a custom ramping system.

* TEG test map fixes

* Make air alarms and pumps open UI on activate.

* Clean up thermo machines power switch.

Removed separate Enabled bool from the component that always matched the power receiver's state.

This enables adding a PowerSwitch component to give us alt click/verb menu.

* TEG but now fancy

* Make sensor monitoring console obviously WiP to mappers.

* Vending machine sound, because of course.

* Terrible, terrible graph background color

* Examine improvements for the TEG.

* Account for electrical power when equalizing gas mixtures.

* Get rid of the TegCirculatorArrow logic.

Use TimedDespawn instead. The "no show in right-click menuu" goes into a new general-purpose component.

Thanks Julian.

* Put big notice of "not ready, here's why" on the sensor monitoring console.

* TryGetComponent -> TryComp

* Lol there's a HideContextMenu tag

* Test fixes

* Guidebook for TEG

Fixed rotation on GuideEntityEmbed not working correctly.

Added Margin property to GuideEntityEmbed

* Make TEG power bar default to invisible.

So it doesn't appear in the guidebook and spawn menu.

Content.Client/Computer/ComputerBoundUserInterface.cs

@@ -51,6 +51,11 @@ namespace Content.Client.Computer
                 _window?.Dispose();
             }
         }
+
+        protected override void ReceiveMessage(BoundUserInterfaceMessage message)
+        {
+            _window?.ReceiveMessage(message);
+        }
     }
 
     /// <summary>
@@ -79,6 +84,10 @@ namespace Content.Client.Computer
         void UpdateState(TState state)
         {
         }
+
+        void ReceiveMessage(BoundUserInterfaceMessage message)
+        {
+        }
     }
 }
 

Content.Client/Examine/ExamineSystem.cs

@@ -359,6 +359,9 @@ namespace Content.Client.Examine
                     _idCounter = 0;
                 RaiseNetworkEvent(new ExamineSystemMessages.RequestExamineInfoMessage(entity, _idCounter, true));
             }
+
+            RaiseLocalEvent(entity, new ClientExaminedEvent(entity, playerEnt.Value));
+
             _lastExaminedEntity = entity;
         }
 
@@ -384,4 +387,26 @@ namespace Content.Client.Examine
             }
         }
     }
+
+    /// <summary>
+    /// An entity was examined on the client.
+    /// </summary>
+    public sealed class ClientExaminedEvent : EntityEventArgs
+    {
+        /// <summary>
+        ///     The entity performing the examining.
+        /// </summary>
+        public readonly EntityUid Examiner;
+
+        /// <summary>
+        ///     Entity being examined, for broadcast event purposes.
+        /// </summary>
+        public readonly EntityUid Examined;
+
+        public ClientExaminedEvent(EntityUid examined, EntityUid examiner)
+        {
+            Examined = examined;
+            Examiner = examiner;
+        }
+    }
 }

Content.Client/Guidebook/Controls/GuideEntityEmbed.xaml.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.Linq;
 using System.Numerics;
 using Content.Client.ContextMenu.UI;
 using Content.Client.Examine;
@@ -15,6 +16,7 @@ using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Input;
 using Robust.Shared.Map;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Guidebook.Controls;
 
@@ -169,10 +171,17 @@ public sealed partial class GuideEntityEmbed : BoxContainer, IDocumentTag
 
         if (args.TryGetValue("Rotation", out var rotation))
         {
-            Sprite.Rotation = Angle.FromDegrees(double.Parse(rotation));
+            View.OverrideDirection = Angle.FromDegrees(double.Parse(rotation)).GetDir();
         }
 
-        Margin = new Thickness(4, 8);
+        if (args.TryGetValue("Margin", out var margin))
+        {
+            Margin = ParseThickness(margin);
+        }
+        else
+        {
+            Margin = new Thickness(4, 8);
+        }
 
         // By default, we will map-initialize guidebook entities.
         if (!args.TryGetValue("Init", out var mapInit) || !bool.Parse(mapInit))
@@ -181,4 +190,20 @@ public sealed partial class GuideEntityEmbed : BoxContainer, IDocumentTag
         control = this;
         return true;
     }
+
+    private static Thickness ParseThickness(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+            return default;
+
+        var split = value.Split(" ", StringSplitOptions.RemoveEmptyEntries).Select(x => Parse.Float(x)).ToArray();
+        if (split.Length == 1)
+            return new Thickness(split[0]);
+        if (split.Length == 2)
+            return new Thickness(split[0], split[1]);
+        if (split.Length == 4)
+            return new Thickness(split[0], split[1], split[2], split[3]);
+
+        throw new Exception("Invalid Thickness format!");
+    }
 }

Content.Client/Power/Generation/Teg/TegCirculatorComponent.cs

@@ -0,0 +1,8 @@
+namespace Content.Client.Power.Generation.Teg;
+
+/// <seealso cref="TegSystem"/>
+[RegisterComponent]
+public sealed class TegCirculatorComponent : Component
+{
+
+}

Content.Client/Power/Generation/Teg/TegSystem.cs

@@ -0,0 +1,26 @@
+using Content.Client.Examine;
+using Robust.Shared.Map;
+
+namespace Content.Client.Power.Generation.Teg;
+
+/// <summary>
+/// Handles client-side logic for the thermo-electric generator (TEG).
+/// </summary>
+/// <remarks>
+/// <para>
+/// TEG circulators show which direction the in- and outlet port is by popping up two floating arrows when examined.
+/// </para>
+/// </remarks>
+/// <seealso cref="TegCirculatorComponent"/>
+public sealed class TegSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<TegCirculatorComponent, ClientExaminedEvent>(CirculatorExamined);
+    }
+
+    private void CirculatorExamined(EntityUid uid, TegCirculatorComponent component, ClientExaminedEvent args)
+    {
+        Spawn("TegCirculatorArrow", new EntityCoordinates(uid, 0, 0));
+    }
+}

Content.Client/SensorMonitoring/SensorMonitoringWindow.xaml

@@ -0,0 +1,10 @@
+<contentControls:FancyWindow
+    xmlns="https://spacestation14.io"
+    xmlns:contentControls="clr-namespace:Content.Client.UserInterface.Controls"
+    Title="{Loc 'sensor-monitoring-window-title'}" MinWidth="640" MinHeight="480">
+    <ScrollContainer>
+        <BoxContainer Name="Asdf" Orientation="Vertical" Margin="4 0">
+
+        </BoxContainer>
+    </ScrollContainer>
+</contentControls:FancyWindow>

Content.Client/SensorMonitoring/SensorMonitoringWindow.xaml.cs

@@ -0,0 +1,264 @@
+using System.Linq;
+using System.Numerics;
+using Content.Client.Computer;
+using Content.Client.Stylesheets;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.SensorMonitoring;
+using JetBrains.Annotations;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Timing;
+using ConsoleUIState = Content.Shared.SensorMonitoring.SensorMonitoringConsoleBoundInterfaceState;
+using IncrementalUIState = Content.Shared.SensorMonitoring.SensorMonitoringIncrementalUpdate;
+
+namespace Content.Client.SensorMonitoring;
+
+[GenerateTypedNameReferences]
+public sealed partial class SensorMonitoringWindow : FancyWindow, IComputerWindow<ConsoleUIState>
+{
+    [Dependency] private readonly IGameTiming _gameTiming = default!;
+    [Dependency] private readonly ILocalizationManager _loc = default!;
+
+    private TimeSpan _retentionTime;
+    private readonly Dictionary<int, SensorData> _sensorData = new();
+
+    public SensorMonitoringWindow()
+    {
+        RobustXamlLoader.Load(this);
+    }
+
+    public void UpdateState(ConsoleUIState state)
+    {
+        _retentionTime = state.RetentionTime;
+
+        _sensorData.Clear();
+
+        foreach (var netSensor in state.Sensors)
+        {
+            var sensor = new SensorData
+            {
+                Name = netSensor.Name,
+                Address = netSensor.Address,
+                DeviceType = netSensor.DeviceType
+            };
+
+            _sensorData.Add(netSensor.NetId, sensor);
+
+            foreach (var netStream in netSensor.Streams)
+            {
+                var stream = new SensorStream
+                {
+                    Name = netStream.Name,
+                    Unit = netStream.Unit
+                };
+
+                sensor.Streams.Add(netStream.NetId, stream);
+
+                foreach (var sample in netStream.Samples)
+                {
+                    stream.Samples.Enqueue(sample);
+                }
+            }
+        }
+
+        Update();
+    }
+
+    public void ReceiveMessage(BoundUserInterfaceMessage message)
+    {
+        if (message is not IncrementalUIState incremental)
+            return;
+
+        foreach (var removed in incremental.RemovedSensors)
+        {
+            _sensorData.Remove(removed);
+        }
+
+        foreach (var netSensor in incremental.Sensors)
+        {
+            // TODO: Fuck this doesn't work if a sensor is added while the UI is open.
+            if (!_sensorData.TryGetValue(netSensor.NetId, out var sensor))
+                continue;
+
+            foreach (var netStream in netSensor.Streams)
+            {
+                // TODO: Fuck this doesn't work if a stream is added while the UI is open.
+                if (!sensor.Streams.TryGetValue(netStream.NetId, out var stream))
+                    continue;
+
+                foreach (var (time, value) in netStream.Samples)
+                {
+                    stream.Samples.Enqueue(new SensorSample(time + incremental.RelTime, value));
+                }
+            }
+        }
+
+        CullOldSamples();
+        Update();
+    }
+
+    private void Update()
+    {
+        Asdf.RemoveAllChildren();
+
+        var curTime = _gameTiming.CurTime;
+        var startTime = curTime - _retentionTime;
+
+        foreach (var sensor in _sensorData.Values)
+        {
+            var labelName = new Label { Text = sensor.Name, StyleClasses = { StyleBase.StyleClassLabelHeading } };
+            var labelAddress = new Label
+            {
+                Text = sensor.Address,
+                Margin = new Thickness(4, 0),
+                VerticalAlignment = VAlignment.Bottom,
+                StyleClasses = { StyleNano.StyleClassLabelSecondaryColor }
+            };
+
+            Asdf.AddChild(new BoxContainer
+            {
+                Orientation = BoxContainer.LayoutOrientation.Horizontal, Children =
+                {
+                    labelName,
+                    labelAddress
+                }
+            });
+
+            foreach (var stream in sensor.Streams.Values)
+            {
+                var maxValue = stream.Unit switch
+                {
+                    SensorUnit.PressureKpa => 5000, // 5 MPa
+                    SensorUnit.Ratio => 1,
+                    SensorUnit.PowerW => 1_000_000, // 1 MW
+                    SensorUnit.EnergyJ => 2_000_000, // 2 MJ
+                    _ => 1000
+                };
+
+                // TODO: Better way to do this?
+                var lastSample = stream.Samples.Last();
+
+                Asdf.AddChild(new BoxContainer
+                {
+                    Orientation = BoxContainer.LayoutOrientation.Horizontal,
+                    Children =
+                    {
+                        new Label { Text = stream.Name, StyleClasses = { "monospace" }, HorizontalExpand = true },
+                        new Label { Text = FormatValue(stream.Unit, lastSample.Value) }
+                    }
+                });
+
+                Asdf.AddChild(new GraphView(stream.Samples, startTime, curTime, maxValue) { MinHeight = 150 });
+                Asdf.AddChild(new PanelContainer { StyleClasses = { StyleBase.ClassLowDivider } });
+            }
+        }
+    }
+
+    private string FormatValue(SensorUnit unit, float value)
+    {
+        return _loc.GetString(
+            "sensor-monitoring-value-display",
+            ("unit", unit.ToString()),
+            ("value", value));
+    }
+
+    private void CullOldSamples()
+    {
+        var startTime = _gameTiming.CurTime - _retentionTime;
+
+        foreach (var sensor in _sensorData.Values)
+        {
+            foreach (var stream in sensor.Streams.Values)
+            {
+                while (stream.Samples.TryPeek(out var sample) && sample.Time < startTime)
+                {
+                    stream.Samples.Dequeue();
+                }
+            }
+        }
+    }
+
+    private sealed class SensorData
+    {
+        public string Name = "";
+        public string Address = "";
+        public SensorDeviceType DeviceType;
+
+        public readonly Dictionary<int, SensorStream> Streams = new();
+    }
+
+    private sealed class SensorStream
+    {
+        public string Name = "";
+        public SensorUnit Unit;
+        public readonly Queue<SensorSample> Samples = new();
+    }
+
+    private sealed class GraphView : Control
+    {
+        private readonly Queue<SensorSample> _samples;
+        private readonly TimeSpan _startTime;
+        private readonly TimeSpan _curTime;
+        private readonly float _maxY;
+
+        public GraphView(Queue<SensorSample> samples, TimeSpan startTime, TimeSpan curTime, float maxY)
+        {
+            _samples = samples;
+            _startTime = startTime;
+            _curTime = curTime;
+            _maxY = maxY;
+            RectClipContent = true;
+        }
+
+        protected override void Draw(DrawingHandleScreen handle)
+        {
+            base.Draw(handle);
+
+            var window = (float) (_curTime - _startTime).TotalSeconds;
+
+            // TODO: omg this is terrible don't fucking hardcode this size to something uncached huge omfg.
+            var vertices = new Vector2[25000];
+            var countVtx = 0;
+
+            var lastPoint = new Vector2(float.NaN, float.NaN);
+
+            foreach (var (time, sample) in _samples)
+            {
+                var relTime = (float) (time - _startTime).TotalSeconds;
+
+                var posY = PixelHeight - (sample / _maxY) * PixelHeight;
+                var posX = (relTime / window) * PixelWidth;
+
+                var newPoint = new Vector2(posX, posY);
+
+                if (float.IsFinite(lastPoint.X))
+                {
+                    handle.DrawLine(lastPoint, newPoint, Color.White);
+
+                    vertices[countVtx++] = lastPoint;
+                    vertices[countVtx++] = lastPoint with { Y = PixelHeight };
+                    vertices[countVtx++] = newPoint;
+                    vertices[countVtx++] = newPoint;
+                    vertices[countVtx++] = lastPoint with { Y = PixelHeight };
+                    vertices[countVtx++] = newPoint with { Y = PixelHeight };
+                }
+
+                lastPoint = newPoint;
+            }
+
+            handle.DrawPrimitives(DrawPrimitiveTopology.TriangleList, vertices.AsSpan(0, countVtx), Color.White.WithAlpha(0.1f));
+        }
+    }
+}
+
+[UsedImplicitly]
+public sealed class
+    SensorMonitoringConsoleBoundUserInterface : ComputerBoundUserInterface<SensorMonitoringWindow, ConsoleUIState>
+{
+    public SensorMonitoringConsoleBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+}