Fix soil refilling (#442)

* fix soil

* Revert "fix soil"

This reverts commit 8176355286.

* Reapply "fix soil"

This reverts commit 0c958f4c9c.

.github/rsi-schema.json

@@ -85,7 +85,7 @@
             "CC-BY-NC-SA-3.0",
             "CC-BY-NC-SA-4.0",
             "CC0-1.0",
-            "All rights reserved for the CrystallPunk14 project only"
+            "CLA"
          ],
          "examples":[
             "CC-BY-SA-3.0"

.github/workflows/update-credits.yml

@@ -19,6 +19,8 @@ jobs:
         
       - name: Get this week's Contributors
         shell: pwsh
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
         run: Tools/dump_github_contributors.ps1 > Resources/Credits/GitHub.txt
 
       # TODO

Content.Client/Actions/ActionsSystem.cs

@@ -259,12 +259,6 @@ namespace Content.Client.Actions
 
             if (action.ClientExclusive)
             {
-                if (instantAction.Event != null)
-                {
-                    instantAction.Event.Performer = user;
-                    instantAction.Event.Action = actionId;
-                }
-
                 PerformAction(user, actions, actionId, instantAction, instantAction.Event, GameTiming.CurTime);
             }
             else

Content.Client/Administration/AdminNameOverlay.cs

@@ -2,10 +2,10 @@ using System.Numerics;
 using Content.Client.Administration.Systems;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
+using Robust.Client.UserInterface;
+using Robust.Shared;
 using Robust.Shared.Enums;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Maths;
+using Robust.Shared.Configuration;
 
 namespace Content.Client.Administration;
 
@@ -15,14 +15,16 @@ internal sealed class AdminNameOverlay : Overlay
     private readonly IEntityManager _entityManager;
     private readonly IEyeManager _eyeManager;
     private readonly EntityLookupSystem _entityLookup;
+    private readonly IUserInterfaceManager _userInterfaceManager;
     private readonly Font _font;
 
-    public AdminNameOverlay(AdminSystem system, IEntityManager entityManager, IEyeManager eyeManager, IResourceCache resourceCache, EntityLookupSystem entityLookup)
+    public AdminNameOverlay(AdminSystem system, IEntityManager entityManager, IEyeManager eyeManager, IResourceCache resourceCache, EntityLookupSystem entityLookup, IUserInterfaceManager userInterfaceManager)
     {
         _system = system;
         _entityManager = entityManager;
         _eyeManager = eyeManager;
         _entityLookup = entityLookup;
+        _userInterfaceManager = userInterfaceManager;
         ZIndex = 200;
         _font = new VectorFont(resourceCache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
     }
@@ -57,16 +59,18 @@ internal sealed class AdminNameOverlay : Overlay
                 continue;
             }
 
-            var lineoffset = new Vector2(0f, 11f);
+            var uiScale = _userInterfaceManager.RootControl.UIScale;
+            var lineoffset = new Vector2(0f, 11f) * uiScale;
             var screenCoordinates = _eyeManager.WorldToScreen(aabb.Center +
                                                               new Angle(-_eyeManager.CurrentEye.Rotation).RotateVec(
                                                                   aabb.TopRight - aabb.Center)) + new Vector2(1f, 7f);
             if (playerInfo.Antag)
             {
-                args.ScreenHandle.DrawString(_font, screenCoordinates + (lineoffset * 2), "ANTAG", Color.OrangeRed);
+                args.ScreenHandle.DrawString(_font, screenCoordinates + (lineoffset * 2), "ANTAG", uiScale, Color.OrangeRed);
+;
             }
-            args.ScreenHandle.DrawString(_font, screenCoordinates+lineoffset, playerInfo.Username, playerInfo.Connected ? Color.Yellow : Color.White);
-            args.ScreenHandle.DrawString(_font, screenCoordinates, playerInfo.CharacterName, playerInfo.Connected ? Color.Aquamarine : Color.White);
+            args.ScreenHandle.DrawString(_font, screenCoordinates+lineoffset, playerInfo.Username, uiScale, playerInfo.Connected ? Color.Yellow : Color.White);
+            args.ScreenHandle.DrawString(_font, screenCoordinates, playerInfo.CharacterName, uiScale, playerInfo.Connected ? Color.Aquamarine : Color.White);
         }
     }
 }

Content.Client/Administration/Systems/AdminSystem.Overlay.cs

@@ -1,6 +1,8 @@
 using Content.Client.Administration.Managers;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
+using Robust.Client.UserInterface;
+using Robust.Shared.Configuration;
 
 namespace Content.Client.Administration.Systems
 {
@@ -11,6 +13,7 @@ namespace Content.Client.Administration.Systems
         [Dependency] private readonly IClientAdminManager _adminManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
+        [Dependency] private readonly IUserInterfaceManager _userInterfaceManager = default!;
 
         private AdminNameOverlay _adminNameOverlay = default!;
 
@@ -19,7 +22,7 @@ namespace Content.Client.Administration.Systems
 
         private void InitializeOverlay()
         {
-            _adminNameOverlay = new AdminNameOverlay(this, EntityManager, _eyeManager, _resourceCache, _entityLookup);
+            _adminNameOverlay = new AdminNameOverlay(this, EntityManager, _eyeManager, _resourceCache, _entityLookup, _userInterfaceManager);
             _adminManager.AdminStatusUpdated += OnAdminStatusUpdated;
         }
 

Content.Client/Administration/UI/AdminRemarks/AdminMessagePopupMessage.xaml.cs

@@ -1,4 +1,4 @@
-using Content.Shared.Administration.Notes;
+using Content.Shared.Administration.Notes;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.XAML;
@@ -13,7 +13,7 @@ public sealed partial class AdminMessagePopupMessage : Control
     {
         RobustXamlLoader.Load(this);
 
-        Admin.SetMessage(FormattedMessage.FromMarkup(Loc.GetString(
+        Admin.SetMessage(FormattedMessage.FromMarkupOrThrow(Loc.GetString(
             "admin-notes-message-admin",
             ("admin", message.AdminName),
             ("date", message.AddedOn.ToLocalTime()))));

Content.Client/Administration/UI/AdminRemarks/AdminMessagePopupWindow.xaml.cs

@@ -49,7 +49,7 @@ public sealed partial class AdminMessagePopupWindow : Control
             MessageContainer.AddChild(new AdminMessagePopupMessage(message));
         }
 
-        Description.SetMessage(FormattedMessage.FromMarkup(Loc.GetString("admin-notes-message-desc", ("count", state.Messages.Length))));
+        Description.SetMessage(FormattedMessage.FromMarkupOrThrow(Loc.GetString("admin-notes-message-desc", ("count", state.Messages.Length))));
     }
 
     private void OnDismissButtonPressed(BaseButton.ButtonEventArgs obj)

Content.Client/Administration/UI/BanList/BanListWindow.xaml.cs

@@ -1,4 +1,5 @@
 using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
 

Content.Client/Administration/UI/Bwoink/BwoinkControl.xaml.cs

@@ -11,9 +11,8 @@ using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Network;
-using Robust.Shared.Utility;
-using Robust.Shared.Timing;
 using Robust.Shared.Configuration;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Administration.UI.Bwoink
 {

Content.Client/Administration/UI/Bwoink/BwoinkPanel.xaml.cs

@@ -59,7 +59,7 @@ namespace Content.Client.Administration.UI.Bwoink
                 Unread++;
 
             var formatted = new FormattedMessage(1);
-            formatted.AddMarkup($"[color=gray]{message.SentAt.ToShortTimeString()}[/color] {message.Text}");
+            formatted.AddMarkupOrThrow($"[color=gray]{message.SentAt.ToShortTimeString()}[/color] {message.Text}");
             TextOutput.AddMessage(formatted);
             LastMessage = message.SentAt;
         }

Content.Client/Administration/UI/SetOutfit/SetOutfitMenu.xaml.cs

@@ -1,4 +1,5 @@
 using System.Numerics;
+using Content.Client.UserInterface.Controls;
 using Content.Shared.Roles;
 using Robust.Client.AutoGenerated;
 using Robust.Client.Console;

Content.Client/Anomaly/Ui/AnomalyGeneratorBoundUserInterface.cs

@@ -1,7 +1,5 @@
 using Content.Shared.Anomaly;
-using Content.Shared.Gravity;
 using JetBrains.Annotations;
-using Robust.Client.GameObjects;
 using Robust.Client.UserInterface;
 
 namespace Content.Client.Anomaly.Ui;

Content.Client/Atmos/Consoles/AtmosAlarmEntryContainer.xaml

@@ -0,0 +1,81 @@
+<BoxContainer xmlns="https://spacestation14.io"
+         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+         xmlns:s="clr-namespace:Content.Client.Stylesheets"
+         xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+         xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+         Orientation="Vertical" HorizontalExpand ="True" Margin="0 0 0 3">
+
+    <!-- Device selection button -->
+    <Button Name="FocusButton" HorizontalExpand="True" SetHeight="32" Margin="12 0 0 0" StyleClasses="OpenBoth" Access="Public">
+        <BoxContainer HorizontalExpand="True" VerticalExpand="True" Orientation="Horizontal">
+
+            <!-- Alarm state -->
+            <TextureRect Stretch="Keep" HorizontalAlignment="Left" Margin="-20 -2 0 0" ModulateSelfOverride="#25252a" TexturePath="/Textures/Interface/AtmosMonitoring/status_bg.png">
+                <BoxContainer VerticalExpand="True" HorizontalExpand="True" Orientation="Horizontal" Margin="8 0">
+                    <TextureRect Name="ArrowTexture" VerticalAlignment="Center" SetSize="12 12" Stretch="KeepAspectCentered" Margin="3 0" TexturePath="/Textures/Interface/Nano/triangle_right.png"></TextureRect>
+                    <Label Name="AlarmStateLabel" HorizontalExpand="True" HorizontalAlignment="Center" FontColorOverride="#5A5A5A" Text="{Loc 'atmos-alerts-window-invalid-state'}"></Label>
+                </BoxContainer>
+            </TextureRect>
+
+            <!-- Alarm name -->
+            <Label Name="AlarmNameLabel" Text="???" HorizontalExpand="True" HorizontalAlignment="Center" Margin="5 0"></Label>
+        </BoxContainer>
+    </Button>
+
+    <!-- Panel that appears on selecting the device -->
+    <PanelContainer Name="FocusContainer" HorizontalExpand="True" Margin="1 -1 1 0" ReservesSpace="False" Visible="False" Access="Public">
+        <PanelContainer.PanelOverride>
+            <gfx:StyleBoxFlat BackgroundColor="#25252a"/>
+        </PanelContainer.PanelOverride>
+        <BoxContainer HorizontalExpand="True" VerticalExpand="True" Orientation="Vertical">
+
+            <!-- Atmosphere status -->
+            <Control>
+
+                <!-- Main container for displaying atmospheric data -->
+                <BoxContainer Name="MainDataContainer" HorizontalExpand="True" VerticalExpand="True" Orientation="Vertical" ReservesSpace="False" Visible="False">
+                    <BoxContainer HorizontalExpand="True" Orientation="Horizontal">
+                        <Label Name="TemperatureHeaderLabel" Text="{Loc 'atmos-alerts-window-temperature-label'}" HorizontalAlignment="Center" HorizontalExpand="True" FontColorOverride="#a9a9a9" Margin="0 2 0 0" SetHeight="24"></Label>
+                        <Label Name="PressureHeaderLabel" Text="{Loc 'atmos-alerts-window-pressure-label'}" HorizontalAlignment="Center" HorizontalExpand="True" FontColorOverride="#a9a9a9" Margin="0 2 0 0" SetHeight="24"></Label>
+                        <Label Name="OxygenationHeaderLabel" Text="{Loc 'atmos-alerts-window-oxygenation-label'}" HorizontalAlignment="Center" HorizontalExpand="True" FontColorOverride="#a9a9a9" Margin="0 2 0 0" SetHeight="24"></Label>
+                    </BoxContainer>
+                    <PanelContainer HorizontalExpand="True">
+                        <PanelContainer.PanelOverride>
+                            <gfx:StyleBoxFlat BackgroundColor="#202023"/>
+                        </PanelContainer.PanelOverride>
+                        <BoxContainer HorizontalExpand="True" Orientation="Horizontal">
+                            <Label Name="TemperatureLabel" Text="???" HorizontalAlignment="Center" HorizontalExpand="True" FontColorOverride="#5A5A5A" Margin="0 2 0 0" SetHeight="24"></Label>
+                            <Label Name="PressureLabel" Text="???" HorizontalAlignment="Center" HorizontalExpand="True" FontColorOverride="#5A5A5A" Margin="0 2 0 0" SetHeight="24"></Label>
+                            <Label Name="OxygenationLabel" Text="???" HorizontalAlignment="Center" HorizontalExpand="True" FontColorOverride="#5A5A5A" Margin="0 2 0 0" SetHeight="24"></Label>
+                        </BoxContainer>
+                    </PanelContainer>
+                    <BoxContainer HorizontalExpand="True" Orientation="Horizontal">
+                        <Label Name="GasesHeaderLabel" Text="{Loc 'atmos-alerts-window-other-gases-label'}" HorizontalAlignment="Center" HorizontalExpand="True" FontColorOverride="#a9a9a9" Margin="0 4 0 0" SetHeight="24"></Label>
+                    </BoxContainer>
+                    <PanelContainer HorizontalExpand="True">
+                        <PanelContainer.PanelOverride>
+                            <gfx:StyleBoxFlat BackgroundColor="#202023"/>
+                        </PanelContainer.PanelOverride>
+
+                        <!-- Gas entries added via C# code -->
+                        <GridContainer Name="GasGridContainer" HorizontalExpand="True" Columns = "4"></GridContainer>
+                    </PanelContainer>
+                </BoxContainer>
+
+                <!-- If the alarm is inactive, this is label is diplayed instead -->
+                <Label Name="NoDataLabel" Text="{Loc 'atmos-alerts-window-no-data-available'}" HorizontalAlignment="Center" Margin="0 15" FontColorOverride="#a9a9a9" ReservesSpace="False" Visible="False"></Label>
+
+                <!-- Silencing progress bar -->
+                <controls:StripeBack Name="SilenceAlarmProgressBar" ReservesSpace="False" Visible="False" Access="Public">
+                    <PanelContainer>
+                        <Label Text="{Loc 'atmos-alerts-window-alerts-being-silenced'}" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="5 5 5 5"/>
+                    </PanelContainer>
+                </controls:StripeBack>
+            </Control>
+
+            <!-- Check box for silencing this alarm -->
+            <CheckBox Name="SilenceCheckBox" Text="{Loc 'atmos-alerts-window-silence-alerts'}" HorizontalAlignment="Left" Margin="5 5 5 5" Access="Public"></CheckBox>
+        </BoxContainer>
+    </PanelContainer>
+
+</BoxContainer>

Content.Client/Atmos/Consoles/AtmosAlarmEntryContainer.xaml.cs

@@ -0,0 +1,215 @@
+using Content.Client.Stylesheets;
+using Content.Shared.Atmos;
+using Content.Shared.Atmos.Components;
+using Content.Shared.Atmos.Monitor;
+using Content.Shared.FixedPoint;
+using Content.Shared.Temperature;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Map;
+using System.Linq;
+
+namespace Content.Client.Atmos.Consoles;
+
+[GenerateTypedNameReferences]
+public sealed partial class AtmosAlarmEntryContainer : BoxContainer
+{
+    public NetEntity NetEntity;
+    public EntityCoordinates? Coordinates;
+
+    private readonly IEntityManager _entManager;
+    private readonly IResourceCache _cache;
+
+    private Dictionary<AtmosAlarmType, string> _alarmStrings = new Dictionary<AtmosAlarmType, string>()
+    {
+        [AtmosAlarmType.Invalid] = "atmos-alerts-window-invalid-state",
+        [AtmosAlarmType.Normal] = "atmos-alerts-window-normal-state",
+        [AtmosAlarmType.Warning] = "atmos-alerts-window-warning-state",
+        [AtmosAlarmType.Danger] = "atmos-alerts-window-danger-state",
+    };
+
+    private Dictionary<Gas, string> _gasShorthands = new Dictionary<Gas, string>()
+    {
+        [Gas.Ammonia] = "NH₃",
+        [Gas.CarbonDioxide] = "CO₂",
+        [Gas.Frezon] = "F",
+        [Gas.Nitrogen] = "N₂",
+        [Gas.NitrousOxide] = "N₂O",
+        [Gas.Oxygen] = "O₂",
+        [Gas.Plasma] = "P",
+        [Gas.Tritium] = "T",
+        [Gas.WaterVapor] = "H₂O",
+    };
+
+    public AtmosAlarmEntryContainer(NetEntity uid, EntityCoordinates? coordinates)
+    {
+        RobustXamlLoader.Load(this);
+
+        _entManager = IoCManager.Resolve<IEntityManager>();
+        _cache = IoCManager.Resolve<IResourceCache>();
+
+        NetEntity = uid;
+        Coordinates = coordinates;
+
+        // Load fonts
+        var headerFont = new VectorFont(_cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Bold.ttf"), 11);
+        var normalFont = new VectorFont(_cache.GetResource<FontResource>("/Fonts/NotoSansDisplay/NotoSansDisplay-Regular.ttf"), 11);
+        var smallFont = new VectorFont(_cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+
+        // Set fonts
+        TemperatureHeaderLabel.FontOverride = headerFont;
+        PressureHeaderLabel.FontOverride = headerFont;
+        OxygenationHeaderLabel.FontOverride = headerFont;
+        GasesHeaderLabel.FontOverride = headerFont;
+
+        TemperatureLabel.FontOverride = normalFont;
+        PressureLabel.FontOverride = normalFont;
+        OxygenationLabel.FontOverride = normalFont;
+
+        NoDataLabel.FontOverride = headerFont;
+
+        SilenceCheckBox.Label.FontOverride = smallFont;
+        SilenceCheckBox.Label.FontColorOverride = Color.DarkGray;
+    }
+
+    public void UpdateEntry(AtmosAlertsComputerEntry entry, bool isFocus, AtmosAlertsFocusDeviceData? focusData = null)
+    {
+        NetEntity = entry.NetEntity;
+        Coordinates = _entManager.GetCoordinates(entry.Coordinates);
+
+        // Load fonts
+        var normalFont = new VectorFont(_cache.GetResource<FontResource>("/Fonts/NotoSansDisplay/NotoSansDisplay-Regular.ttf"), 11);
+
+        // Update alarm state
+        if (!_alarmStrings.TryGetValue(entry.AlarmState, out var alarmString))
+            alarmString = "atmos-alerts-window-invalid-state";
+
+        AlarmStateLabel.Text = Loc.GetString(alarmString);
+        AlarmStateLabel.FontColorOverride = GetAlarmStateColor(entry.AlarmState);
+
+        // Update alarm name
+        AlarmNameLabel.Text = Loc.GetString("atmos-alerts-window-alarm-label", ("name", entry.EntityName), ("address", entry.Address));
+
+        // Focus updates
+        FocusContainer.Visible = isFocus;
+
+        if (isFocus)
+            SetAsFocus();
+        else
+            RemoveAsFocus();
+
+        if (isFocus && entry.Group == AtmosAlertsComputerGroup.AirAlarm)
+        {
+            MainDataContainer.Visible = (entry.AlarmState != AtmosAlarmType.Invalid);
+            NoDataLabel.Visible = (entry.AlarmState == AtmosAlarmType.Invalid);
+
+            if (focusData != null)
+            {
+                // Update temperature
+                var tempK = (FixedPoint2)focusData.Value.TemperatureData.Item1;
+                var tempC = (FixedPoint2)TemperatureHelpers.KelvinToCelsius(tempK.Float());
+
+                TemperatureLabel.Text = Loc.GetString("atmos-alerts-window-temperature-value", ("valueInC", tempC), ("valueInK", tempK));
+                TemperatureLabel.FontColorOverride = GetAlarmStateColor(focusData.Value.TemperatureData.Item2);
+
+                // Update pressure
+                PressureLabel.Text = Loc.GetString("atmos-alerts-window-pressure-value", ("value", (FixedPoint2)focusData.Value.PressureData.Item1));
+                PressureLabel.FontColorOverride = GetAlarmStateColor(focusData.Value.PressureData.Item2);
+
+                // Update oxygenation
+                var oxygenPercent = (FixedPoint2)0f;
+                var oxygenAlert = AtmosAlarmType.Invalid;
+
+                if (focusData.Value.GasData.TryGetValue(Gas.Oxygen, out var oxygenData))
+                {
+                    oxygenPercent = oxygenData.Item2 * 100f;
+                    oxygenAlert = oxygenData.Item3;
+                }
+
+                OxygenationLabel.Text = Loc.GetString("atmos-alerts-window-oxygenation-value", ("value", oxygenPercent));
+                OxygenationLabel.FontColorOverride = GetAlarmStateColor(oxygenAlert);
+
+                // Update other present gases
+                GasGridContainer.RemoveAllChildren();
+
+                var gasData = focusData.Value.GasData.Where(g => g.Key != Gas.Oxygen);
+
+                if (gasData.Count() == 0)
+                {
+                    // No other gases
+                    var gasLabel = new Label()
+                    {
+                        Text = Loc.GetString("atmos-alerts-window-other-gases-value-nil"),
+                        FontOverride = normalFont,
+                        FontColorOverride = StyleNano.DisabledFore,
+                        HorizontalAlignment = HAlignment.Center,
+                        VerticalAlignment = VAlignment.Center,
+                        HorizontalExpand = true,
+                        Margin = new Thickness(0, 2, 0, 0),
+                        SetHeight = 24f,
+                    };
+
+                    GasGridContainer.AddChild(gasLabel);
+                }
+
+                else
+                {
+                    // Add an entry for each gas
+                    foreach ((var gas, (var mol, var percent, var alert)) in gasData)
+                    {
+                        var gasPercent = (FixedPoint2)0f;
+                        gasPercent = percent * 100f;
+
+                        if (!_gasShorthands.TryGetValue(gas, out var gasShorthand))
+                            gasShorthand = "X";
+
+                        var gasLabel = new Label()
+                        {
+                            Text = Loc.GetString("atmos-alerts-window-other-gases-value", ("shorthand", gasShorthand), ("value", gasPercent)),
+                            FontOverride = normalFont,
+                            FontColorOverride = GetAlarmStateColor(alert),
+                            HorizontalAlignment = HAlignment.Center,
+                            VerticalAlignment = VAlignment.Center,
+                            HorizontalExpand = true,
+                            Margin = new Thickness(0, 2, 0, 0),
+                            SetHeight = 24f,
+                        };
+
+                        GasGridContainer.AddChild(gasLabel);
+                    }
+                }
+            }
+        }
+    }
+
+    public void SetAsFocus()
+    {
+        FocusButton.AddStyleClass(StyleNano.StyleClassButtonColorGreen);
+        ArrowTexture.TexturePath = "/Textures/Interface/Nano/inverted_triangle.svg.png";
+    }
+
+    public void RemoveAsFocus()
+    {
+        FocusButton.RemoveStyleClass(StyleNano.StyleClassButtonColorGreen);
+        ArrowTexture.TexturePath = "/Textures/Interface/Nano/triangle_right.png";
+        FocusContainer.Visible = false;
+    }
+
+    private Color GetAlarmStateColor(AtmosAlarmType alarmType)
+    {
+        switch (alarmType)
+        {
+            case AtmosAlarmType.Normal:
+                return StyleNano.GoodGreenFore;
+            case AtmosAlarmType.Warning:
+                return StyleNano.ConcerningOrangeFore;
+            case AtmosAlarmType.Danger:
+                return StyleNano.DangerousRedFore;
+        }
+
+        return StyleNano.DisabledFore;
+    }
+}

Content.Client/Atmos/Consoles/AtmosAlertsComputerBoundUserInterface.cs

@@ -0,0 +1,52 @@
+using Content.Shared.Atmos.Components;
+
+namespace Content.Client.Atmos.Consoles;
+
+public sealed class AtmosAlertsComputerBoundUserInterface : BoundUserInterface
+{
+    [ViewVariables]
+    private AtmosAlertsComputerWindow? _menu;
+
+    public AtmosAlertsComputerBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey) { }
+
+    protected override void Open()
+    {
+        _menu = new AtmosAlertsComputerWindow(this, Owner);
+        _menu.OpenCentered();
+        _menu.OnClose += Close;
+
+        EntMan.TryGetComponent<TransformComponent>(Owner, out var xform);
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        var castState = (AtmosAlertsComputerBoundInterfaceState) state;
+
+        if (castState == null)
+            return;
+
+        EntMan.TryGetComponent<TransformComponent>(Owner, out var xform);
+        _menu?.UpdateUI(xform?.Coordinates, castState.AirAlarms, castState.FireAlarms, castState.FocusData);
+    }
+
+    public void SendFocusChangeMessage(NetEntity? netEntity)
+    {
+        SendMessage(new AtmosAlertsComputerFocusChangeMessage(netEntity));
+    }
+
+    public void SendDeviceSilencedMessage(NetEntity netEntity, bool silenceDevice)
+    {
+        SendMessage(new AtmosAlertsComputerDeviceSilencedMessage(netEntity, silenceDevice));
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        if (!disposing)
+            return;
+
+        _menu?.Dispose();
+    }
+}

Content.Client/Atmos/Consoles/AtmosAlertsComputerWindow.xaml

@@ -0,0 +1,108 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+               xmlns:ui="clr-namespace:Content.Client.Pinpointer.UI"
+               xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+               xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+               Title="{Loc 'atmos-alerts-window-title'}"
+               Resizable="False"
+               SetSize="1120 750"
+               MinSize="1120 750">
+    <BoxContainer Orientation="Vertical">
+        <!-- Main display -->
+        <BoxContainer Orientation="Horizontal" VerticalExpand="True" HorizontalExpand="True">
+            <!-- Nav map -->
+            <BoxContainer Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True">
+                <ui:NavMapControl Name="NavMap" Margin="5 5" VerticalExpand="True" HorizontalExpand="True">
+
+                    <!-- System warning -->
+                    <PanelContainer Name="SystemWarningPanel"
+                                    HorizontalAlignment="Center"
+                                    VerticalAlignment="Top"
+                                    HorizontalExpand="True"
+                                    Margin="0 48 0 0"
+                                    Visible="False">
+                        <RichTextLabel Name="SystemWarningLabel" Margin="12 8 12 8"/>
+                    </PanelContainer>
+
+                </ui:NavMapControl>
+
+                <!-- Nav map legend -->
+                <BoxContainer Orientation="Horizontal" Margin="0 10 0 10">
+                    <Label Text="{Loc 'atmos-alerts-window-label-alert-types'}"
+                           Margin="20 0 5 0"/>
+                    <TextureRect Stretch="KeepAspectCentered"
+                                TexturePath="/Textures/Interface/NavMap/beveled_circle.png"
+                                Modulate="#5A5A5A"
+                                SetSize="16 16"
+                                Margin="20 0 5 0"/>
+                    <Label Text="{Loc 'atmos-alerts-window-invalid-state'}"/>
+                    <TextureRect Stretch="KeepAspectCentered"
+                                TexturePath="/Textures/Interface/NavMap/beveled_circle.png"
+                                Modulate="#32cd32"
+                                SetSize="16 16"
+                                Margin="20 0 5 0"/>
+                    <Label Text="{Loc 'atmos-alerts-window-normal-state'}"/>
+                    <TextureRect Stretch="KeepAspectCentered"
+                                TexturePath="/Textures/Interface/NavMap/beveled_triangle.png"
+                                SetSize="16 16"
+                                Modulate="#ffb648"
+                                Margin="20 0 5 0"/>
+                    <Label Text="{Loc 'atmos-alerts-window-warning-state'}"/>
+                    <TextureRect Stretch="KeepAspectCentered"
+                                TexturePath="/Textures/Interface/NavMap/beveled_square.png"
+                                SetSize="16 16"
+                                Modulate="#ff4343"
+                                Margin="20 0 5 0"/>
+                    <Label Text="{Loc 'atmos-alerts-window-danger-state'}"/>
+                </BoxContainer>
+            </BoxContainer>
+
+            <!-- Atmosphere status -->
+            <BoxContainer Orientation="Vertical" VerticalExpand="True" SetWidth="440" Margin="0 0 10 10">
+
+                <!-- Station name -->
+                <controls:StripeBack>
+                    <PanelContainer>
+                        <RichTextLabel Name="StationName" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="0 5 0 3"/>
+                    </PanelContainer>
+                </controls:StripeBack>
+
+                <!-- Alarm status (entries added by C# code) -->
+                <TabContainer Name="MasterTabContainer" VerticalExpand="True" HorizontalExpand="True" Margin="0 10 0 0">
+                    <ScrollContainer HorizontalExpand="True" Margin="8, 8, 8, 8">
+                        <BoxContainer Name="AlertsTable" Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True" Margin="0 0 0 10"/>
+                    </ScrollContainer>
+                    <ScrollContainer HorizontalExpand="True" Margin="8, 8, 8, 8">
+                        <BoxContainer Name="AirAlarmsTable" Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True" Margin="0 0 0 10"/>
+                    </ScrollContainer>
+                    <ScrollContainer HorizontalExpand="True" Margin="8, 8, 8, 8">
+                        <BoxContainer Name="FireAlarmsTable" Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True" Margin="0 0 0 10"/>
+                    </ScrollContainer>
+                </TabContainer>
+
+                <!-- Overlay toggles -->
+                <BoxContainer Orientation="Vertical" Margin="0 10 0 0">
+                    <Label Text="{Loc 'atmos-alerts-window-toggle-overlays'}" Margin="0 0 0 5"/>
+                    <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
+                        <CheckBox Name="ShowInactiveAlarms" Text="{Loc 'atmos-alerts-window-invalid-state'}" Pressed="False" HorizontalExpand="True"/>
+                        <CheckBox Name="ShowNormalAlarms" Text="{Loc 'atmos-alerts-window-normal-state'}" Pressed="False" HorizontalExpand="True"/>
+                        <CheckBox Name="ShowWarningAlarms" Text="{Loc 'atmos-alerts-window-warning-state'}" Pressed="True" HorizontalExpand="True"/>
+                        <CheckBox Name="ShowDangerAlarms" Text="{Loc 'atmos-alerts-window-danger-state'}" Pressed="True" HorizontalExpand="True"/>
+                    </BoxContainer>
+                </BoxContainer>
+            </BoxContainer>
+
+        </BoxContainer>
+
+        <!-- Footer -->
+        <BoxContainer Orientation="Vertical">
+            <PanelContainer StyleClasses="LowDivider" />
+            <BoxContainer Orientation="Horizontal" Margin="10 2 5 0" VerticalAlignment="Bottom">
+                <Label Text="{Loc 'atmos-alerts-window-flavor-left'}" StyleClasses="WindowFooterText" />
+                <Label Text="{Loc 'atmos-alerts-window-flavor-right'}" StyleClasses="WindowFooterText"
+                        HorizontalAlignment="Right" HorizontalExpand="True"  Margin="0 0 5 0" />
+                <TextureRect StyleClasses="NTLogoDark" Stretch="KeepAspectCentered"
+                        VerticalAlignment="Center" HorizontalAlignment="Right" SetSize="19 19"/>
+            </BoxContainer>
+        </BoxContainer>
+    </BoxContainer>
+</controls:FancyWindow>

Content.Client/Atmos/Consoles/AtmosAlertsComputerWindow.xaml.cs

@@ -0,0 +1,548 @@
+using Content.Client.Message;
+using Content.Client.Pinpointer.UI;
+using Content.Client.Stylesheets;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Atmos.Components;
+using Content.Shared.Atmos.Monitor;
+using Content.Shared.Pinpointer;
+using Robust.Client.AutoGenerated;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Map;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace Content.Client.Atmos.Consoles;
+
+[GenerateTypedNameReferences]
+public sealed partial class AtmosAlertsComputerWindow : FancyWindow
+{
+    private readonly IEntityManager _entManager;
+    private readonly SpriteSystem _spriteSystem;
+
+    private EntityUid? _owner;
+    private NetEntity? _trackedEntity;
+
+    private AtmosAlertsComputerEntry[]? _airAlarms = null;
+    private AtmosAlertsComputerEntry[]? _fireAlarms = null;
+    private IEnumerable<AtmosAlertsComputerEntry>? _allAlarms = null;
+
+    private IEnumerable<AtmosAlertsComputerEntry>? _activeAlarms = null;
+    private Dictionary<NetEntity, float> _deviceSilencingProgress = new();
+
+    public event Action<NetEntity?>? SendFocusChangeMessageAction;
+    public event Action<NetEntity, bool>? SendDeviceSilencedMessageAction;
+
+    private bool _autoScrollActive = false;
+    private bool _autoScrollAwaitsUpdate = false;
+
+    private const float SilencingDuration = 2.5f;
+
+    public AtmosAlertsComputerWindow(AtmosAlertsComputerBoundUserInterface userInterface, EntityUid? owner)
+    {
+        RobustXamlLoader.Load(this);
+        _entManager = IoCManager.Resolve<IEntityManager>();
+        _spriteSystem = _entManager.System<SpriteSystem>();
+
+        // Pass the owner to nav map
+        _owner = owner;
+        NavMap.Owner = _owner;
+
+        // Set nav map colors
+        NavMap.WallColor = new Color(64, 64, 64);
+        NavMap.TileColor = Color.DimGray * NavMap.WallColor;
+
+        // Set nav map grid uid
+        var stationName = Loc.GetString("atmos-alerts-window-unknown-location");
+
+        if (_entManager.TryGetComponent<TransformComponent>(owner, out var xform))
+        {
+            NavMap.MapUid = xform.GridUid;
+
+            // Assign station name      
+            if (_entManager.TryGetComponent<MetaDataComponent>(xform.GridUid, out var stationMetaData))
+                stationName = stationMetaData.EntityName;
+
+            var msg = new FormattedMessage();
+            msg.TryAddMarkup(Loc.GetString("atmos-alerts-window-station-name", ("stationName", stationName)), out _);
+
+            StationName.SetMessage(msg);
+        }
+
+        else
+        {
+            StationName.SetMessage(stationName);
+            NavMap.Visible = false;
+        }
+
+        // Set trackable entity selected action
+        NavMap.TrackedEntitySelectedAction += SetTrackedEntityFromNavMap;
+
+        // Update nav map
+        NavMap.ForceNavMapUpdate();
+
+        // Set tab container headers
+        MasterTabContainer.SetTabTitle(0, Loc.GetString("atmos-alerts-window-tab-no-alerts"));
+        MasterTabContainer.SetTabTitle(1, Loc.GetString("atmos-alerts-window-tab-air-alarms"));
+        MasterTabContainer.SetTabTitle(2, Loc.GetString("atmos-alerts-window-tab-fire-alarms"));
+
+        // Set UI toggles
+        ShowInactiveAlarms.OnToggled += _ => OnShowAlarmsToggled(ShowInactiveAlarms, AtmosAlarmType.Invalid);
+        ShowNormalAlarms.OnToggled += _ => OnShowAlarmsToggled(ShowNormalAlarms, AtmosAlarmType.Normal);
+        ShowWarningAlarms.OnToggled += _ => OnShowAlarmsToggled(ShowWarningAlarms, AtmosAlarmType.Warning);
+        ShowDangerAlarms.OnToggled += _ => OnShowAlarmsToggled(ShowDangerAlarms, AtmosAlarmType.Danger);
+
+        // Set atmos monitoring message action
+        SendFocusChangeMessageAction += userInterface.SendFocusChangeMessage;
+        SendDeviceSilencedMessageAction += userInterface.SendDeviceSilencedMessage;
+    }
+
+    #region Toggle handling
+
+    private void OnShowAlarmsToggled(CheckBox toggle, AtmosAlarmType toggledAlarmState)
+    {
+        if (_owner == null)
+            return;
+
+        if (!_entManager.TryGetComponent<AtmosAlertsComputerComponent>(_owner.Value, out var console))
+            return;
+
+        foreach (var device in console.AtmosDevices)
+        {
+            var alarmState = GetAlarmState(device.NetEntity);
+
+            if (toggledAlarmState != alarmState)
+                continue;
+
+            if (toggle.Pressed)
+                AddTrackedEntityToNavMap(device, alarmState);
+
+            else
+                NavMap.TrackedEntities.Remove(device.NetEntity);
+        }
+    }
+
+    private void OnSilenceAlertsToggled(NetEntity netEntity, bool toggleState)
+    {
+        if (!_entManager.TryGetComponent<AtmosAlertsComputerComponent>(_owner, out var console))
+            return;
+
+        if (toggleState)
+            _deviceSilencingProgress[netEntity] = SilencingDuration;
+
+        else
+            _deviceSilencingProgress.Remove(netEntity);
+
+        foreach (AtmosAlarmEntryContainer entryContainer in AlertsTable.Children)
+        {
+            if (entryContainer.NetEntity == netEntity)
+                entryContainer.SilenceAlarmProgressBar.Visible = toggleState;
+        }
+
+        SendDeviceSilencedMessageAction?.Invoke(netEntity, toggleState);
+    }
+
+    #endregion
+
+    public void UpdateUI(EntityCoordinates? consoleCoords, AtmosAlertsComputerEntry[] airAlarms, AtmosAlertsComputerEntry[] fireAlarms, AtmosAlertsFocusDeviceData? focusData)
+    {
+        if (_owner == null)
+            return;
+
+        if (!_entManager.TryGetComponent<AtmosAlertsComputerComponent>(_owner.Value, out var console))
+            return;
+
+        if (_trackedEntity != focusData?.NetEntity)
+        {
+            SendFocusChangeMessageAction?.Invoke(_trackedEntity);
+            focusData = null;
+        }
+
+        // Retain alarm data for use inbetween updates
+        _airAlarms = airAlarms;
+        _fireAlarms = fireAlarms;
+        _allAlarms = airAlarms.Concat(fireAlarms);
+
+        var silenced = console.SilencedDevices;
+
+        _activeAlarms = _allAlarms.Where(x => x.AlarmState > AtmosAlarmType.Normal &&
+            (!silenced.Contains(x.NetEntity) || _deviceSilencingProgress.ContainsKey(x.NetEntity)));
+
+        // Reset nav map data
+        NavMap.TrackedCoordinates.Clear();
+        NavMap.TrackedEntities.Clear();
+
+        // Add tracked entities to the nav map
+        foreach (var device in console.AtmosDevices)
+        {
+            if (!NavMap.Visible)
+                continue;
+
+            var alarmState = GetAlarmState(device.NetEntity);
+
+            if (_trackedEntity != device.NetEntity)
+            {
+                // Skip air alarms if the appropriate overlay is off
+                if (!ShowInactiveAlarms.Pressed && alarmState == AtmosAlarmType.Invalid)
+                    continue;
+
+                if (!ShowNormalAlarms.Pressed && alarmState == AtmosAlarmType.Normal)
+                    continue;
+
+                if (!ShowWarningAlarms.Pressed && alarmState == AtmosAlarmType.Warning)
+                    continue;
+
+                if (!ShowDangerAlarms.Pressed && alarmState == AtmosAlarmType.Danger)
+                    continue;
+            }
+
+            AddTrackedEntityToNavMap(device, alarmState);
+        }
+
+        // Show the monitor location
+        var consoleUid = _entManager.GetNetEntity(_owner);
+
+        if (consoleCoords != null && consoleUid != null)
+        {
+            var texture = _spriteSystem.Frame0(new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/NavMap/beveled_circle.png")));
+            var blip = new NavMapBlip(consoleCoords.Value, texture, Color.Cyan, true, false);
+            NavMap.TrackedEntities[consoleUid.Value] = blip;
+        }
+
+        // Update the nav map
+        NavMap.ForceNavMapUpdate();
+
+        // Clear excess children from the tables
+        var activeAlarmCount = _activeAlarms.Count();
+
+        while (AlertsTable.ChildCount > activeAlarmCount)
+            AlertsTable.RemoveChild(AlertsTable.GetChild(AlertsTable.ChildCount - 1));
+
+        while (AirAlarmsTable.ChildCount > airAlarms.Length)
+            AirAlarmsTable.RemoveChild(AirAlarmsTable.GetChild(AirAlarmsTable.ChildCount - 1));
+
+        while (FireAlarmsTable.ChildCount > fireAlarms.Length)
+            FireAlarmsTable.RemoveChild(FireAlarmsTable.GetChild(FireAlarmsTable.ChildCount - 1));
+
+        // Update all entries in each table
+        for (int index = 0; index < _activeAlarms.Count(); index++)
+        {
+            var entry = _activeAlarms.ElementAt(index);
+            UpdateUIEntry(entry, index, AlertsTable, console, focusData);
+        }
+
+        for (int index = 0; index < airAlarms.Count(); index++)
+        {
+            var entry = airAlarms.ElementAt(index);
+            UpdateUIEntry(entry, index, AirAlarmsTable, console, focusData);
+        }
+
+        for (int index = 0; index < fireAlarms.Count(); index++)
+        {
+            var entry = fireAlarms.ElementAt(index);
+            UpdateUIEntry(entry, index, FireAlarmsTable, console, focusData);
+        }
+
+        // If no alerts are active, display a message
+        if (MasterTabContainer.CurrentTab == 0 && activeAlarmCount == 0)
+        {
+            var label = new RichTextLabel()
+            {
+                HorizontalExpand = true,
+                VerticalExpand = true,
+                HorizontalAlignment = HAlignment.Center,
+                VerticalAlignment = VAlignment.Center,
+            };
+
+            label.SetMarkup(Loc.GetString("atmos-alerts-window-no-active-alerts", ("color", StyleNano.GoodGreenFore.ToHexNoAlpha())));
+
+            AlertsTable.AddChild(label);
+        }
+
+        // Update the alerts tab with the number of active alerts
+        if (activeAlarmCount == 0)
+            MasterTabContainer.SetTabTitle(0, Loc.GetString("atmos-alerts-window-tab-no-alerts"));
+
+        else
+            MasterTabContainer.SetTabTitle(0, Loc.GetString("atmos-alerts-window-tab-alerts", ("value", activeAlarmCount)));
+
+        // Auto-scroll re-enable
+        if (_autoScrollAwaitsUpdate)
+        {
+            _autoScrollActive = true;
+            _autoScrollAwaitsUpdate = false;
+        }
+    }
+
+    private void AddTrackedEntityToNavMap(AtmosAlertsDeviceNavMapData metaData, AtmosAlarmType alarmState)
+    {
+        var data = GetBlipTexture(alarmState);
+
+        if (data == null)
+            return;
+
+        var texture = data.Value.Item1;
+        var color = data.Value.Item2;
+        var coords = _entManager.GetCoordinates(metaData.NetCoordinates);
+
+        if (_trackedEntity != null && _trackedEntity != metaData.NetEntity)
+            color *= Color.DimGray;
+
+        var selectable = true;
+        var blip = new NavMapBlip(coords, _spriteSystem.Frame0(texture), color, _trackedEntity == metaData.NetEntity, selectable);
+
+        NavMap.TrackedEntities[metaData.NetEntity] = blip;
+    }
+
+    private void UpdateUIEntry(AtmosAlertsComputerEntry entry, int index, Control table, AtmosAlertsComputerComponent console, AtmosAlertsFocusDeviceData? focusData = null)
+    {
+        // Make new UI entry if required
+        if (index >= table.ChildCount)
+        {
+            var newEntryContainer = new AtmosAlarmEntryContainer(entry.NetEntity, _entManager.GetCoordinates(entry.Coordinates));
+
+            // On click
+            newEntryContainer.FocusButton.OnButtonUp += args =>
+            {
+                if (_trackedEntity == newEntryContainer.NetEntity)
+                {
+                    _trackedEntity = null;
+                }
+
+                else
+                {
+                    _trackedEntity = newEntryContainer.NetEntity;
+
+                    if (newEntryContainer.Coordinates != null)
+                        NavMap.CenterToCoordinates(newEntryContainer.Coordinates.Value);
+                }
+
+                // Send message to console that the focus has changed
+                SendFocusChangeMessageAction?.Invoke(_trackedEntity);
+
+                // Update affected UI elements across all tables
+                UpdateConsoleTable(console, AlertsTable, _trackedEntity);
+                UpdateConsoleTable(console, AirAlarmsTable, _trackedEntity);
+                UpdateConsoleTable(console, FireAlarmsTable, _trackedEntity);
+            };
+
+            // On toggling the silence check box
+            newEntryContainer.SilenceCheckBox.OnToggled += _ => OnSilenceAlertsToggled(newEntryContainer.NetEntity, newEntryContainer.SilenceCheckBox.Pressed);
+
+            // Add the entry to the current table
+            table.AddChild(newEntryContainer);
+        }
+
+        // Update values and UI elements
+        var tableChild = table.GetChild(index);
+
+        if (tableChild is not AtmosAlarmEntryContainer)
+        {
+            table.RemoveChild(tableChild);
+            UpdateUIEntry(entry, index, table, console, focusData);
+
+            return;
+        }
+
+        var entryContainer = (AtmosAlarmEntryContainer)tableChild;
+
+        entryContainer.UpdateEntry(entry, entry.NetEntity == _trackedEntity, focusData);
+
+        if (_trackedEntity != entry.NetEntity)
+        {
+            var silenced = console.SilencedDevices;
+            entryContainer.SilenceCheckBox.Pressed = (silenced.Contains(entry.NetEntity) || _deviceSilencingProgress.ContainsKey(entry.NetEntity));
+        }
+
+        entryContainer.SilenceAlarmProgressBar.Visible = (table == AlertsTable && _deviceSilencingProgress.ContainsKey(entry.NetEntity));
+    }
+
+    private void UpdateConsoleTable(AtmosAlertsComputerComponent console, Control table, NetEntity? currTrackedEntity)
+    {
+        foreach (var tableChild in table.Children)
+        {
+            if (tableChild is not AtmosAlarmEntryContainer)
+                continue;
+
+            var entryContainer = (AtmosAlarmEntryContainer)tableChild;
+
+            if (entryContainer.NetEntity != currTrackedEntity)
+                entryContainer.RemoveAsFocus();
+
+            else if (entryContainer.NetEntity == currTrackedEntity)
+                entryContainer.SetAsFocus();
+        }
+    }
+
+    private void SetTrackedEntityFromNavMap(NetEntity? netEntity)
+    {
+        if (netEntity == null)
+            return;
+
+        if (!_entManager.TryGetComponent<AtmosAlertsComputerComponent>(_owner, out var console))
+            return;
+
+        _trackedEntity = netEntity;
+
+        if (netEntity != null)
+        {
+            // Tab switching
+            if (MasterTabContainer.CurrentTab != 0 || _activeAlarms?.Any(x => x.NetEntity == netEntity) == false)
+            {
+                var device = console.AtmosDevices.FirstOrNull(x => x.NetEntity == netEntity);
+
+                switch (device?.Group)
+                {
+                    case AtmosAlertsComputerGroup.AirAlarm:
+                        MasterTabContainer.CurrentTab = 1; break;
+                    case AtmosAlertsComputerGroup.FireAlarm:
+                        MasterTabContainer.CurrentTab = 2; break;
+                }
+            }
+
+            // Get the scroll position of the selected entity on the selected button the UI
+            ActivateAutoScrollToFocus();
+        }
+
+        // Send message to console that the focus has changed
+        SendFocusChangeMessageAction?.Invoke(_trackedEntity);
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        AutoScrollToFocus();
+
+        // Device silencing update
+        foreach ((var device, var remainingTime) in _deviceSilencingProgress)
+        {
+            var t = remainingTime - args.DeltaSeconds;
+
+            if (t <= 0)
+            {
+                _deviceSilencingProgress.Remove(device);
+
+                if (device == _trackedEntity)
+                    _trackedEntity = null;
+            }
+
+            else
+                _deviceSilencingProgress[device] = t;
+        }
+    }
+
+    private void ActivateAutoScrollToFocus()
+    {
+        _autoScrollActive = false;
+        _autoScrollAwaitsUpdate = true;
+    }
+
+    private void AutoScrollToFocus()
+    {
+        if (!_autoScrollActive)
+            return;
+
+        var scroll = MasterTabContainer.Children.ElementAt(MasterTabContainer.CurrentTab) as ScrollContainer;
+        if (scroll == null)
+            return;
+
+        if (!TryGetVerticalScrollbar(scroll, out var vScrollbar))
+            return;
+
+        if (!TryGetNextScrollPosition(out float? nextScrollPosition))
+            return;
+
+        vScrollbar.ValueTarget = nextScrollPosition.Value;
+
+        if (MathHelper.CloseToPercent(vScrollbar.Value, vScrollbar.ValueTarget))
+            _autoScrollActive = false;
+    }
+
+    private bool TryGetVerticalScrollbar(ScrollContainer scroll, [NotNullWhen(true)] out VScrollBar? vScrollBar)
+    {
+        vScrollBar = null;
+
+        foreach (var child in scroll.Children)
+        {
+            if (child is not VScrollBar)
+                continue;
+
+            var castChild = child as VScrollBar;
+
+            if (castChild != null)
+            {
+                vScrollBar = castChild;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private bool TryGetNextScrollPosition([NotNullWhen(true)] out float? nextScrollPosition)
+    {
+        nextScrollPosition = null;
+
+        var scroll = MasterTabContainer.Children.ElementAt(MasterTabContainer.CurrentTab) as ScrollContainer;
+        if (scroll == null)
+            return false;
+
+        var container = scroll.Children.ElementAt(0) as BoxContainer;
+        if (container == null || container.Children.Count() == 0)
+            return false;
+
+        // Exit if the heights of the children haven't been initialized yet
+        if (!container.Children.Any(x => x.Height > 0))
+            return false;
+
+        nextScrollPosition = 0;
+
+        foreach (var control in container.Children)
+        {
+            if (control == null || control is not AtmosAlarmEntryContainer)
+                continue;
+
+            if (((AtmosAlarmEntryContainer)control).NetEntity == _trackedEntity)
+                return true;
+
+            nextScrollPosition += control.Height;
+        }
+
+        // Failed to find control
+        nextScrollPosition = null;
+
+        return false;
+    }
+
+    private AtmosAlarmType GetAlarmState(NetEntity netEntity)
+    {
+        var alarmState = _allAlarms?.FirstOrNull(x => x.NetEntity == netEntity)?.AlarmState;
+
+        if (alarmState == null)
+            return AtmosAlarmType.Invalid;
+
+        return alarmState.Value;
+    }
+
+    private (SpriteSpecifier.Texture, Color)? GetBlipTexture(AtmosAlarmType alarmState)
+    {
+        (SpriteSpecifier.Texture, Color)? output = null;
+
+        switch (alarmState)
+        {
+            case AtmosAlarmType.Invalid:
+                output = (new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/NavMap/beveled_circle.png")), StyleNano.DisabledFore); break;
+            case AtmosAlarmType.Normal:
+                output = (new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/NavMap/beveled_circle.png")), Color.LimeGreen); break;
+            case AtmosAlarmType.Warning:
+                output = (new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/NavMap/beveled_triangle.png")), new Color(255, 182, 72)); break;
+            case AtmosAlarmType.Danger:
+                output = (new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/NavMap/beveled_square.png")), new Color(255, 67, 67)); break;
+        }
+
+        return output;
+    }
+}

Content.Client/Atmos/Monitor/UI/AirAlarmBoundUserInterface.cs

@@ -30,7 +30,6 @@ public sealed class AirAlarmBoundUserInterface : BoundUserInterface
         _window.AirAlarmModeChanged += OnAirAlarmModeChanged;
         _window.AutoModeChanged += OnAutoModeChanged;
         _window.ResyncAllRequested += ResyncAllDevices;
-        _window.AirAlarmTabChange += OnTabChanged;
     }
 
     private void ResyncAllDevices()
@@ -63,11 +62,6 @@ public sealed class AirAlarmBoundUserInterface : BoundUserInterface
         SendMessage(new AirAlarmUpdateAlarmThresholdMessage(address, type, threshold, gas));
     }
 
-    private void OnTabChanged(AirAlarmTab tab)
-    {
-        SendMessage(new AirAlarmTabSetMessage(tab));
-    }
-
     protected override void UpdateState(BoundUserInterfaceState state)
     {
         base.UpdateState(state);

Content.Client/Atmos/Monitor/UI/AirAlarmWindow.xaml.cs

@@ -23,7 +23,6 @@ public sealed partial class AirAlarmWindow : FancyWindow
     public event Action<AirAlarmMode>? AirAlarmModeChanged;
     public event Action<bool>? AutoModeChanged;
     public event Action? ResyncAllRequested;
-    public event Action<AirAlarmTab>? AirAlarmTabChange;
 
     private RichTextLabel _address => CDeviceAddress;
     private RichTextLabel _deviceTotal => CDeviceTotal;
@@ -80,11 +79,6 @@ public sealed partial class AirAlarmWindow : FancyWindow
         _tabContainer.SetTabTitle(1, Loc.GetString("air-alarm-ui-window-tab-scrubbers"));
         _tabContainer.SetTabTitle(2, Loc.GetString("air-alarm-ui-window-tab-sensors"));
 
-        _tabContainer.OnTabChanged += idx =>
-        {
-            AirAlarmTabChange!((AirAlarmTab) idx);
-        };
-
         _resyncDevices.OnPressed += _ =>
         {
             _ventDevices.RemoveAllChildren();
@@ -117,8 +111,6 @@ public sealed partial class AirAlarmWindow : FancyWindow
         {
             UpdateDeviceData(addr, dev);
         }
-
-        _tabContainer.CurrentTab = (int) state.Tab;
     }
 
     public void UpdateModeSelector(AirAlarmMode mode)

Content.Client/CartridgeLoader/Cartridges/CrewManifestUiFragment.xaml.cs

@@ -1,4 +1,5 @@
-using Content.Shared.CrewManifest;
+using Content.Client.CrewManifest.UI;
+using Content.Shared.CrewManifest;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;

Content.Client/CartridgeLoader/Cartridges/NewsReaderUiFragment.xaml

@@ -26,7 +26,7 @@
             Text="{Loc 'news-read-ui-next-text'}"
             ToolTip="{Loc 'news-read-ui-next-tooltip'}"/>
     </BoxContainer>
-    <controls:StripeBack Name="АrticleNameContainer">
+    <controls:StripeBack Name="ArticleNameContainer">
         <PanelContainer>
             <Label Name="PageNum" VerticalAlignment="Center" HorizontalAlignment="Left" Margin="4,0,0,0"/>
             <Label Name="PageName" Align="Center"/>

Content.Client/Changelog/ChangelogTab.xaml.cs

@@ -131,13 +131,13 @@ public sealed partial class ChangelogTab : Control
                     Margin = new Thickness(6, 0, 0, 0),
                 };
                 authorLabel.SetMessage(
-                    FormattedMessage.FromMarkup(Loc.GetString("changelog-author-changed", ("author", author))));
+                    FormattedMessage.FromMarkupOrThrow(Loc.GetString("changelog-author-changed", ("author", author))));
                 ChangelogBody.AddChild(authorLabel);
 
                 foreach (var change in groupedEntry.SelectMany(c => c.Changes))
                 {
                     var text = new RichTextLabel();
-                    text.SetMessage(FormattedMessage.FromMarkup(change.Message));
+                    text.SetMessage(FormattedMessage.FromMarkupOrThrow(change.Message));
                     ChangelogBody.AddChild(new BoxContainer
                     {
                         Orientation = LayoutOrientation.Horizontal,

Content.Client/Chat/UI/EmotesMenu.xaml.cs

@@ -19,9 +19,6 @@ public sealed partial class EmotesMenu : RadialMenu
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly ISharedPlayerManager _playerManager = default!;
 
-    private readonly SpriteSystem _spriteSystem;
-    private readonly EntityWhitelistSystem _whitelistSystem;
-
     public event Action<ProtoId<EmotePrototype>>? OnPlayEmote;
 
     public EmotesMenu()
@@ -29,8 +26,8 @@ public sealed partial class EmotesMenu : RadialMenu
         IoCManager.InjectDependencies(this);
         RobustXamlLoader.Load(this);
 
-        _spriteSystem = _entManager.System<SpriteSystem>();
-        _whitelistSystem = _entManager.System<EntityWhitelistSystem>();
+        var spriteSystem = _entManager.System<SpriteSystem>();
+        var whitelistSystem = _entManager.System<EntityWhitelistSystem>();
 
         var main = FindControl<RadialContainer>("Main");
 
@@ -40,8 +37,8 @@ public sealed partial class EmotesMenu : RadialMenu
             var player = _playerManager.LocalSession?.AttachedEntity;
             if (emote.Category == EmoteCategory.Invalid ||
                 emote.ChatTriggers.Count == 0 ||
-                !(player.HasValue && _whitelistSystem.IsWhitelistPassOrNull(emote.Whitelist, player.Value)) ||
-                _whitelistSystem.IsBlacklistPass(emote.Blacklist, player.Value))
+                !(player.HasValue && whitelistSystem.IsWhitelistPassOrNull(emote.Whitelist, player.Value)) ||
+                whitelistSystem.IsBlacklistPass(emote.Blacklist, player.Value))
                 continue;
 
             if (!emote.Available &&
@@ -63,7 +60,7 @@ public sealed partial class EmotesMenu : RadialMenu
             {
                 VerticalAlignment = VAlignment.Center,
                 HorizontalAlignment = HAlignment.Center,
-                Texture = _spriteSystem.Frame0(emote.Icon),
+                Texture = spriteSystem.Frame0(emote.Icon),
                 TextureScale = new Vector2(2f, 2f),
             };
 

Content.Client/Chat/UI/SpeechBubble.cs

@@ -180,7 +180,7 @@ namespace Content.Client.Chat.UI
             var msg = new FormattedMessage();
             if (fontColor != null)
                 msg.PushColor(fontColor.Value);
-            msg.AddMarkup(message);
+            msg.AddMarkupOrThrow(message);
             return msg;
         }
 

Content.Client/Chemistry/EntitySystems/ChemistryGuideDataSystem.cs

@@ -1,5 +1,5 @@
 using System.Linq;
-using Content.Client.Chemistry.Containers.EntitySystems;
+using Content.Shared.Chemistry.EntitySystems;
 using Content.Shared.Atmos.Prototypes;
 using Content.Shared.Body.Part;
 using Content.Shared.Chemistry;
@@ -16,7 +16,7 @@ namespace Content.Client.Chemistry.EntitySystems;
 /// <inheritdoc/>
 public sealed class ChemistryGuideDataSystem : SharedChemistryGuideDataSystem
 {
-    [Dependency] private readonly SolutionContainerSystem _solutionContainer = default!;
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionContainer = default!;
 
     [ValidatePrototypeId<MixingCategoryPrototype>]
     private const string DefaultMixingCategory = "DummyMix";

Content.Client/Clothing/ClientClothingSystem.cs

@@ -57,7 +57,6 @@ public sealed class ClientClothingSystem : ClothingSystem
     };
 
     [Dependency] private readonly IResourceCache _cache = default!;
-    [Dependency] private readonly ISerializationManager _serialization = default!;
     [Dependency] private readonly InventorySystem _inventorySystem = default!;
     [Dependency] private readonly DisplacementMapSystem _displacement = default!;
 

Content.Client/Commands/ActionsCommands.cs

@@ -1,6 +1,4 @@
 using Content.Client.Actions;
-using Content.Client.Actions;
-using Content.Client.Mapping;
 using Content.Shared.Administration;
 using Robust.Shared.Console;
 

Content.Client/Commands/MappingClientSideSetupCommand.cs

@@ -13,7 +13,6 @@ internal sealed class MappingClientSideSetupCommand : LocalizedCommands
 {
     [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
     [Dependency] private readonly ILightManager _lightManager = default!;
-    [Dependency] private readonly IStateManager _stateManager = default!;
 
     public override string Command => "mappingclientsidesetup";
 

Content.Client/Commands/SetMenuVisibilityCommand.cs

@@ -1,4 +1,5 @@
 using Content.Client.Verbs;
+using Content.Shared.Verbs;
 using JetBrains.Annotations;
 using Robust.Shared.Console;
 

Content.Client/Communications/UI/CommunicationsConsoleMenu.xaml

@@ -4,14 +4,14 @@
     MinSize="400 225">
     <BoxContainer Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True" Margin="5">
         <TextEdit Name="MessageInput" HorizontalExpand="True" VerticalExpand="True" Margin="0 0 0 5" MinHeight="100" />
-        <Button Name="AnnounceButton" Text="{Loc 'comms-console-menu-announcement-button'}" StyleClasses="OpenLeft" Access="Public" />
-        <Button Name="BroadcastButton" Text="{Loc 'comms-console-menu-broadcast-button'}" StyleClasses="OpenLeft" Access="Public" />
+        <Button Name="AnnounceButton" Text="{Loc 'comms-console-menu-announcement-button'}" ToolTip="{Loc 'comms-console-menu-announcement-button-tooltip'}" StyleClasses="OpenLeft" Access="Public" />
+        <Button Name="BroadcastButton" Text="{Loc 'comms-console-menu-broadcast-button'}" ToolTip="{Loc 'comms-console-menu-broadcast-button-tooltip'}" StyleClasses="OpenLeft" Access="Public" />
 
-        <OptionButton Name="AlertLevelButton" StyleClasses="OpenRight" Access="Public" />
+        <OptionButton Name="AlertLevelButton" ToolTip="{Loc 'comms-console-menu-alert-level-button-tooltip'}" StyleClasses="OpenRight" Access="Public" />
 
         <Control MinSize="10 10" />
 
         <RichTextLabel Name="CountdownLabel" VerticalExpand="True" />
-        <Button Name="EmergencyShuttleButton" Text="Placeholder Text" Access="Public" />
+        <Button Name="EmergencyShuttleButton" Text="Placeholder Text" ToolTip="{Loc 'comms-console-menu-emergency-shuttle-button-tooltip'}" Access="Public" />
     </BoxContainer>
 </controls:FancyWindow>

Content.Client/Computer/ComputerBoundUserInterface.cs

@@ -11,8 +11,6 @@ namespace Content.Client.Computer
     [Virtual]
     public class ComputerBoundUserInterface<TWindow, TState> : ComputerBoundUserInterfaceBase where TWindow : BaseWindow, IComputerWindow<TState>, new() where TState : BoundUserInterfaceState
     {
-        [Dependency] private readonly IDynamicTypeFactory _dynamicTypeFactory = default!;
-
         [ViewVariables]
         private TWindow? _window;
 

Content.Client/Construction/UI/FlatpackCreatorMenu.xaml.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using Content.Client.Materials;
+using Content.Client.Materials.UI;
 using Content.Client.Message;
 using Content.Client.UserInterface.Controls;
 using Content.Shared.Construction.Components;

Content.Client/Content.Client.csproj

@@ -23,9 +23,6 @@
     <ProjectReference Include="..\RobustToolbox\Robust.Client\Robust.Client.csproj" />
     <ProjectReference Include="..\Content.Shared\Content.Shared.csproj" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Spawners\" />
-  </ItemGroup>
   <Import Project="..\RobustToolbox\MSBuild\Robust.Properties.targets" />
   <Import Project="..\RobustToolbox\MSBuild\XamlIL.targets" />
 </Project>

Content.Client/ContextMenu/UI/EntityMenuUIController.cs

@@ -9,6 +9,7 @@ using Content.Shared.CCVar;
 using Content.Shared.Examine;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Input;
+using Content.Shared.Verbs;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
@@ -194,8 +195,20 @@ namespace Content.Client.ContextMenu.UI
                 return;
 
             // Do we need to do in-range unOccluded checks?
-            var ignoreFov = !_eyeManager.CurrentEye.DrawFov ||
-                (_verbSystem.Visibility & MenuVisibility.NoFov) == MenuVisibility.NoFov;
+            var visibility = _verbSystem.Visibility;
+
+            if (!_eyeManager.CurrentEye.DrawFov)
+            {
+                visibility &= ~MenuVisibility.NoFov;
+            }
+
+            var ev = new MenuVisibilityEvent()
+            {
+                Visibility = visibility,
+            };
+
+            _entityManager.EventBus.RaiseLocalEvent(player, ref ev);
+            visibility = ev.Visibility;
 
             _entityManager.TryGetComponent(player, out ExaminerComponent? examiner);
             var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
@@ -209,7 +222,7 @@ namespace Content.Client.ContextMenu.UI
                     continue;
                 }
 
-                if (ignoreFov)
+                if ((visibility & MenuVisibility.NoFov) == MenuVisibility.NoFov)
                     continue;
 
                 var pos = new MapCoordinates(_xform.GetWorldPosition(xform, xformQuery), xform.MapID);

Content.Client/Credits/CreditsWindow.xaml.cs

@@ -145,7 +145,7 @@ namespace Content.Client.Credits
                 var text = _resourceManager.ContentFileReadAllText($"/Credits/{path}");
                 if (markup)
                 {
-                    label.SetMessage(FormattedMessage.FromMarkup(text.Trim()));
+                    label.SetMessage(FormattedMessage.FromMarkupOrThrow(text.Trim()));
                 }
                 else
                 {

Content.Client/CrewManifest/CrewManifestUi.xaml.cs

@@ -1,3 +1,4 @@
+using Content.Client.CrewManifest.UI;
 using Content.Shared.CrewManifest;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.CustomControls;

Content.Client/CriminalRecords/CriminalRecordsConsoleWindow.xaml.cs

@@ -227,7 +227,7 @@ public sealed partial class CriminalRecordsConsoleWindow : FancyWindow
         StatusOptionButton.SelectId((int) criminalRecord.Status);
         if (criminalRecord.Reason is {} reason)
         {
-            var message = FormattedMessage.FromMarkup(Loc.GetString("criminal-records-console-wanted-reason"));
+            var message = FormattedMessage.FromMarkupOrThrow(Loc.GetString("criminal-records-console-wanted-reason"));
             message.AddText($": {reason}");
             WantedReason.SetMessage(message);
             WantedReason.Visible = true;

Content.Client/Doors/Electronics/DoorElectronicsConfigurationMenu.xaml

@@ -1,6 +1,7 @@
 <controls:FancyWindow xmlns="https://spacestation14.io"
                 xmlns:ui="clr-namespace:Content.Client.UserInterface"
-                xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls">
+                xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                Title="{Loc door-electronics-configuration-title}">
     <Control Name="AccessLevelControlContainer" />
 
 </controls:FancyWindow>

Content.Client/Entry/EntryPoint.cs

@@ -109,6 +109,7 @@ namespace Content.Client.Entry
             _prototypeManager.RegisterIgnore("lobbyBackground");
             _prototypeManager.RegisterIgnore("gamePreset");
             _prototypeManager.RegisterIgnore("noiseChannel");
+            _prototypeManager.RegisterIgnore("playerConnectionWhitelist");
             _prototypeManager.RegisterIgnore("spaceBiome");
             _prototypeManager.RegisterIgnore("worldgenConfig");
             _prototypeManager.RegisterIgnore("gameRule");

Content.Client/Examine/ExamineSystem.cs

@@ -1,7 +1,12 @@
+using System.Linq;
+using System.Numerics;
+using System.Threading;
 using Content.Client.Verbs;
 using Content.Shared.Examine;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Input;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Item;
 using Content.Shared.Verbs;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
@@ -12,13 +17,8 @@ using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.Map;
 using Robust.Shared.Utility;
-using System.Linq;
-using System.Numerics;
-using System.Threading;
 using static Content.Shared.Interaction.SharedInteractionSystem;
 using static Robust.Client.UserInterface.Controls.BoxContainer;
-using Content.Shared.Interaction.Events;
-using Content.Shared.Item;
 using Direction = Robust.Shared.Maths.Direction;
 
 namespace Content.Client.Examine
@@ -35,7 +35,6 @@ namespace Content.Client.Examine
 
         private EntityUid _examinedEntity;
         private EntityUid _lastExaminedEntity;
-        private EntityUid _playerEntity;
         private Popup? _examineTooltipOpen;
         private ScreenCoordinates _popupPos;
         private CancellationTokenSource? _requestCancelTokenSource;
@@ -74,9 +73,9 @@ namespace Content.Client.Examine
         public override void Update(float frameTime)
         {
             if (_examineTooltipOpen is not {Visible: true}) return;
-            if (!_examinedEntity.Valid || !_playerEntity.Valid) return;
+            if (!_examinedEntity.Valid || _playerManager.LocalEntity is not { } player) return;
 
-            if (!CanExamine(_playerEntity, _examinedEntity))
+            if (!CanExamine(player, _examinedEntity))
                 CloseTooltip();
         }
 
@@ -114,9 +113,8 @@ namespace Content.Client.Examine
                 return false;
             }
 
-            _playerEntity = _playerManager.LocalEntity ?? default;
-
-            if (_playerEntity == default || !CanExamine(_playerEntity, entity))
+            if (_playerManager.LocalEntity is not { } player ||
+                !CanExamine(player, entity))
             {
                 return false;
             }

Content.Client/Ghost/GhostSystem.cs

@@ -99,8 +99,8 @@ namespace Content.Client.Ghost
             if (args.Handled)
                 return;
 
-            Popup.PopupEntity(Loc.GetString("ghost-gui-toggle-ghost-visibility-popup"), args.Performer);
-
+            var locId = GhostVisibility ? "ghost-gui-toggle-ghost-visibility-popup-off" : "ghost-gui-toggle-ghost-visibility-popup-on";
+            Popup.PopupEntity(Loc.GetString(locId), args.Performer);
             if (uid == _playerManager.LocalEntity)
                 ToggleGhostVisibility();
 

Content.Client/Gravity/GravitySystem.cs

@@ -1,4 +1,5 @@
 using Content.Shared.Gravity;
+using Content.Shared.Power;
 using Robust.Client.GameObjects;
 
 namespace Content.Client.Gravity;
@@ -21,7 +22,7 @@ public sealed partial class GravitySystem : SharedGravitySystem
         if (args.Sprite == null)
             return;
 
-        if (_appearanceSystem.TryGetData<GravityGeneratorStatus>(uid, GravityGeneratorVisuals.State, out var state, args.Component))
+        if (_appearanceSystem.TryGetData<PowerChargeStatus>(uid, PowerChargeVisuals.State, out var state, args.Component))
         {
             if (comp.SpriteMap.TryGetValue(state, out var spriteState))
             {
@@ -30,7 +31,7 @@ public sealed partial class GravitySystem : SharedGravitySystem
             }
         }
 
-        if (_appearanceSystem.TryGetData<float>(uid, GravityGeneratorVisuals.Charge, out var charge, args.Component))
+        if (_appearanceSystem.TryGetData<float>(uid, PowerChargeVisuals.Charge, out var charge, args.Component))
         {
             var layer = args.Sprite.LayerMapGet(GravityGeneratorVisualLayers.Core);
             switch (charge)

Content.Client/Gravity/UI/GravityGeneratorBoundUserInterface.cs

@@ -1,38 +0,0 @@
-using Content.Shared.Gravity;
-using JetBrains.Annotations;
-using Robust.Client.UserInterface;
-
-namespace Content.Client.Gravity.UI
-{
-    [UsedImplicitly]
-    public sealed class GravityGeneratorBoundUserInterface : BoundUserInterface
-    {
-        [ViewVariables]
-        private GravityGeneratorWindow? _window;
-
-        public GravityGeneratorBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
-        {
-        }
-
-        protected override void Open()
-        {
-            base.Open();
-
-            _window = this.CreateWindow<GravityGeneratorWindow>();
-            _window.SetEntity(Owner);
-        }
-
-        protected override void UpdateState(BoundUserInterfaceState state)
-        {
-            base.UpdateState(state);
-
-            var castState = (SharedGravityGeneratorComponent.GeneratorState) state;
-            _window?.UpdateState(castState);
-        }
-
-        public void SetPowerSwitch(bool on)
-        {
-            SendMessage(new SharedGravityGeneratorComponent.SwitchGeneratorMessage(on));
-        }
-    }
-}

Content.Client/Gravity/UI/GravityGeneratorWindow.xaml.cs

@@ -1,75 +0,0 @@
-using Content.Shared.Gravity;
-using Robust.Client.AutoGenerated;
-using Robust.Client.GameObjects;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.UserInterface.XAML;
-using FancyWindow = Content.Client.UserInterface.Controls.FancyWindow;
-
-namespace Content.Client.Gravity.UI
-{
-    [GenerateTypedNameReferences]
-    public sealed partial class GravityGeneratorWindow : FancyWindow
-    {
-        private readonly ButtonGroup _buttonGroup = new();
-
-        public event Action<bool>? OnPowerSwitch;
-
-        public GravityGeneratorWindow()
-        {
-            RobustXamlLoader.Load(this);
-            IoCManager.InjectDependencies(this);
-
-            OnButton.Group = _buttonGroup;
-            OffButton.Group = _buttonGroup;
-
-            OnButton.OnPressed += _ => OnPowerSwitch?.Invoke(true);
-            OffButton.OnPressed += _ => OnPowerSwitch?.Invoke(false);
-        }
-
-        public void SetEntity(EntityUid uid)
-        {
-            EntityView.SetEntity(uid);
-        }
-
-        public void UpdateState(SharedGravityGeneratorComponent.GeneratorState state)
-        {
-            if (state.On)
-                OnButton.Pressed = true;
-            else
-                OffButton.Pressed = true;
-
-            PowerLabel.Text = Loc.GetString(
-                "gravity-generator-window-power-label",
-                ("draw", state.PowerDraw),
-                ("max", state.PowerDrawMax));
-
-            PowerLabel.SetOnlyStyleClass(MathHelper.CloseTo(state.PowerDraw, state.PowerDrawMax) ? "Good" : "Caution");
-
-            ChargeBar.Value = state.Charge;
-            ChargeText.Text = (state.Charge / 255f).ToString("P0");
-            StatusLabel.Text = Loc.GetString(state.PowerStatus switch
-            {
-                GravityGeneratorPowerStatus.Off => "gravity-generator-window-status-off",
-                GravityGeneratorPowerStatus.Discharging => "gravity-generator-window-status-discharging",
-                GravityGeneratorPowerStatus.Charging => "gravity-generator-window-status-charging",
-                GravityGeneratorPowerStatus.FullyCharged => "gravity-generator-window-status-fully-charged",
-                _ => throw new ArgumentOutOfRangeException()
-            });
-
-            StatusLabel.SetOnlyStyleClass(state.PowerStatus switch
-            {
-                GravityGeneratorPowerStatus.Off => "Danger",
-                GravityGeneratorPowerStatus.Discharging => "Caution",
-                GravityGeneratorPowerStatus.Charging => "Caution",
-                GravityGeneratorPowerStatus.FullyCharged => "Good",
-                _ => throw new ArgumentOutOfRangeException()
-            });
-
-            EtaLabel.Text = state.EtaSeconds >= 0
-                ? Loc.GetString("gravity-generator-window-eta-value", ("left", TimeSpan.FromSeconds(state.EtaSeconds)))
-                : Loc.GetString("gravity-generator-window-eta-none");
-
-            EtaLabel.SetOnlyStyleClass(state.EtaSeconds >= 0 ? "Caution" : "Disabled");
-        }
-    }
-}

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

@@ -140,7 +140,7 @@ public sealed partial class GuideReagentEmbed : BoxContainer, IDocumentTag, ISea
                 var i = 0;
                 foreach (var effectString in effect.EffectDescriptions)
                 {
-                    descMsg.AddMarkup(effectString);
+                    descMsg.AddMarkupOrThrow(effectString);
                     i++;
                     if (i < descriptionsCount)
                         descMsg.PushNewline();
@@ -174,7 +174,7 @@ public sealed partial class GuideReagentEmbed : BoxContainer, IDocumentTag, ISea
             var i = 0;
             foreach (var effectString in guideEntryRegistryPlant.PlantMetabolisms)
             {
-                descMsg.AddMarkup(effectString);
+                descMsg.AddMarkupOrThrow(effectString);
                 i++;
                 if (i < descriptionsCount)
                     descMsg.PushNewline();
@@ -195,7 +195,7 @@ public sealed partial class GuideReagentEmbed : BoxContainer, IDocumentTag, ISea
         FormattedMessage description = new();
         description.AddText(reagent.LocalizedDescription);
         description.PushNewline();
-        description.AddMarkup(Loc.GetString("guidebook-reagent-physical-description",
+        description.AddMarkupOrThrow(Loc.GetString("guidebook-reagent-physical-description",
             ("description", reagent.LocalizedPhysicalDescription)));
         ReagentDescription.SetMessage(description);
     }

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

@@ -179,7 +179,7 @@ public sealed partial class GuideReagentReaction : BoxContainer, ISearchableCont
         var i = 0;
         foreach (var (product, amount) in reagents.OrderByDescending(p => p.Value))
         {
-            msg.AddMarkup(Loc.GetString("guidebook-reagent-recipes-reagent-display",
+            msg.AddMarkupOrThrow(Loc.GetString("guidebook-reagent-recipes-reagent-display",
                 ("reagent", protoMan.Index<ReagentPrototype>(product).LocalizedName), ("ratio", amount)));
             i++;
             if (i < reagentCount)

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

@@ -23,6 +23,8 @@ public sealed partial class GuidebookWindow : FancyWindow, ILinkClickHandler
 
     private readonly ISawmill _sawmill;
 
+    public ProtoId<GuideEntryPrototype> LastEntry;
+
     public GuidebookWindow()
     {
         RobustXamlLoader.Load(this);
@@ -90,6 +92,8 @@ public sealed partial class GuidebookWindow : FancyWindow, ILinkClickHandler
 
             _sawmill.Error($"Failed to parse contents of guide document {entry.Id}.");
         }
+
+        LastEntry = entry.Id;
     }
 
     public void UpdateGuides(

Content.Client/Guidebook/GuidebookDataSystem.cs

@@ -0,0 +1,45 @@
+using Content.Shared.Guidebook;
+
+namespace Content.Client.Guidebook;
+
+/// <summary>
+/// Client system for storing and retrieving values extracted from entity prototypes
+/// for display in the guidebook (<see cref="RichText.ProtodataTag"/>).
+/// Requests data from the server on <see cref="Initialize"/>.
+/// Can also be pushed new data when the server reloads prototypes.
+/// </summary>
+public sealed class GuidebookDataSystem : EntitySystem
+{
+    private GuidebookData? _data;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<UpdateGuidebookDataEvent>(OnServerUpdated);
+
+        // Request data from the server
+        RaiseNetworkEvent(new RequestGuidebookDataEvent());
+    }
+
+    private void OnServerUpdated(UpdateGuidebookDataEvent args)
+    {
+        // Got new data from the server, either in response to our request, or because prototypes reloaded on the server
+        _data = args.Data;
+        _data.Freeze();
+    }
+
+    /// <summary>
+    /// Attempts to retrieve a value using the given identifiers.
+    /// See <see cref="GuidebookData.TryGetValue"/> for more information.
+    /// </summary>
+    public bool TryGetValue(string prototype, string component, string field, out object? value)
+    {
+        if (_data == null)
+        {
+            value = null;
+            return false;
+        }
+        return _data.TryGetValue(prototype, component, field, out value);
+    }
+}

Content.Client/Guidebook/Richtext/ProtodataTag.cs

@@ -0,0 +1,49 @@
+using System.Globalization;
+using Robust.Client.UserInterface.RichText;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Guidebook.RichText;
+
+/// <summary>
+/// RichText tag that can display values extracted from entity prototypes.
+/// In order to be accessed by this tag, the desired field/property must
+/// be tagged with <see cref="Shared.Guidebook.GuidebookDataAttribute"/>.
+/// </summary>
+public sealed class ProtodataTag : IMarkupTag
+{
+    [Dependency] private readonly ILogManager _logMan = default!;
+    [Dependency] private readonly IEntityManager _entMan = default!;
+
+    public string Name => "protodata";
+    private ISawmill Log => _log ??= _logMan.GetSawmill("protodata_tag");
+    private ISawmill? _log;
+
+    public string TextBefore(MarkupNode node)
+    {
+        // Do nothing with an empty tag
+        if (!node.Value.TryGetString(out var prototype))
+            return string.Empty;
+
+        if (!node.Attributes.TryGetValue("comp", out var component))
+            return string.Empty;
+        if (!node.Attributes.TryGetValue("member", out var member))
+            return string.Empty;
+        node.Attributes.TryGetValue("format", out var format);
+
+        var guidebookData = _entMan.System<GuidebookDataSystem>();
+
+        // Try to get the value
+        if (!guidebookData.TryGetValue(prototype, component.StringValue!, member.StringValue!, out var value))
+        {
+            Log.Error($"Failed to find protodata for {component}.{member} in {prototype}");
+            return "???";
+        }
+
+        // If we have a format string and a formattable value, format it as requested
+        if (!string.IsNullOrEmpty(format.StringValue) && value is IFormattable formattable)
+            return formattable.ToString(format.StringValue, CultureInfo.CurrentCulture);
+
+        // No format string given, so just use default ToString
+        return value?.ToString() ?? "NULL";
+    }
+}

Content.Client/HealthAnalyzer/UI/HealthAnalyzerBoundUserInterface.cs

@@ -17,6 +17,7 @@ namespace Content.Client.HealthAnalyzer.UI
         protected override void Open()
         {
             base.Open();
+
             _window = this.CreateWindow<HealthAnalyzerWindow>();
 
             _window.Title = EntMan.GetComponent<MetaDataComponent>(Owner).EntityName;

Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml

@@ -1,48 +1,64 @@
-<controls:FancyWindow
+<controls:FancyWindow
     xmlns="https://spacestation14.io"
     xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
-    SetSize="250 100">
+    MaxHeight="525"
+    MinWidth="300">
     <ScrollContainer
+        Margin="5 5 5 5"
+        ReturnMeasure="True"
         VerticalExpand="True">
         <BoxContainer
             Name="RootContainer"
+            VerticalExpand="True"
             Orientation="Vertical">
             <Label
                 Name="NoPatientDataText"
                 Text="{Loc health-analyzer-window-no-patient-data-text}" />
+
             <BoxContainer
                 Name="PatientDataContainer"
-                Orientation="Vertical"
-                Margin="0 0 5 10">
-                <BoxContainer Name="ScanModePanel" HorizontalExpand="True" Visible="False" Margin="0 5 0 0">
-                    <Label
-                    Name="ScanMode"
-                    Align="Left"
-                    Text="{Loc health-analyzer-window-scan-mode-text}"/>
-                    <Label
-                    Name="ScanModeText"
-                    Align="Right"
-                    HorizontalExpand="True"/>
+                Margin="0 0 0 5"
+                Orientation="Vertical">
+                <BoxContainer Orientation="Horizontal" Margin="0 0 0 5">
+                    <SpriteView OverrideDirection="South" Scale="2 2" Name="SpriteView" Access="Public" SetSize="64 64" />
+                    <BoxContainer Margin="5 0 0 0" Orientation="Vertical" VerticalAlignment="Top">
+                        <RichTextLabel Name="NameLabel" SetWidth="150" />
+                        <Label Name="SpeciesLabel" VerticalAlignment="Top" StyleClasses="LabelSubText" />
+                    </BoxContainer>
+                    <Label Margin="0 0 5 0" HorizontalExpand="True" HorizontalAlignment="Right" VerticalExpand="True"
+                           VerticalAlignment="Top" Name="ScanModeLabel"
+                           Text="{Loc 'health-analyzer-window-entity-unknown-text'}" />
                 </BoxContainer>
-                <Label
-                    Name="PatientName"/>
-                <Label
-                    Name="Temperature"
-                    Margin="0 5 0 0"/>
-                <Label
-                    Name="BloodLevel"
-                    Margin="0 5 0 0"/>
-                <Label
-                    Name="Bleeding"
-                    Margin="0 5 0 0"/>
-                <Label
-                    Name="patientDamageAmount"
-                    Margin="0 15 0 0"/>
+
+                <PanelContainer StyleClasses="LowDivider" />
+
+                <GridContainer Margin="0 5 0 0" Columns="2">
+                    <Label Text="{Loc 'health-analyzer-window-entity-status-text'}" />
+                    <Label Name="StatusLabel" />
+                    <Label Text="{Loc 'health-analyzer-window-entity-temperature-text'}" />
+                    <Label Name="TemperatureLabel" />
+                    <Label Text="{Loc 'health-analyzer-window-entity-blood-level-text'}" />
+                    <Label Name="BloodLabel" />
+                    <Label Text="{Loc 'health-analyzer-window-entity-damage-total-text'}" />
+                    <Label Name="DamageLabel" />
+                </GridContainer>
             </BoxContainer>
+
+            <PanelContainer Name="AlertsDivider" Visible="False" StyleClasses="LowDivider" />
+
+            <BoxContainer Name="AlertsContainer" Visible="False" Margin="0 5" Orientation="Horizontal"
+                          HorizontalExpand="True" HorizontalAlignment="Center">
+
+            </BoxContainer>
+
+            <PanelContainer StyleClasses="LowDivider" />
+
             <BoxContainer
                 Name="GroupsContainer"
+                Margin="0 5 0 5"
                 Orientation="Vertical">
             </BoxContainer>
+
         </BoxContainer>
     </ScrollContainer>
 </controls:FancyWindow>

Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs

@@ -1,12 +1,20 @@
 using System.Linq;
 using System.Numerics;
+using Content.Client.Message;
 using Content.Shared.Atmos;
 using Content.Client.UserInterface.Controls;
+using Content.Shared.Alert;
 using Content.Shared.Damage;
 using Content.Shared.Damage.Prototypes;
 using Content.Shared.FixedPoint;
+using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Prototypes;
 using Content.Shared.IdentityManagement;
+using Content.Shared.Inventory;
 using Content.Shared.MedicalScanner;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
 using Content.Shared.Nutrition.Components;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.XAML;
@@ -28,9 +36,6 @@ namespace Content.Client.HealthAnalyzer.UI
         private readonly IPrototypeManager _prototypes;
         private readonly IResourceCache _cache;
 
-        private const int AnalyzerHeight = 430;
-        private const int AnalyzerWidth = 300;
-
         public HealthAnalyzerWindow()
         {
             RobustXamlLoader.Load(this);
@@ -44,8 +49,6 @@ namespace Content.Client.HealthAnalyzer.UI
 
         public void Populate(HealthAnalyzerScannedUserMessage msg)
         {
-            GroupsContainer.RemoveAllChildren();
-
             var target = _entityManager.GetEntity(msg.TargetEntity);
 
             if (target == null
@@ -57,82 +60,96 @@ namespace Content.Client.HealthAnalyzer.UI
 
             NoPatientDataText.Visible = false;
 
-            string entityName = Loc.GetString("health-analyzer-window-entity-unknown-text");
-            if (_entityManager.HasComponent<MetaDataComponent>(target.Value))
-            {
-                entityName = Identity.Name(target.Value, _entityManager);
-            }
+            // Scan Mode
 
-            if (msg.ScanMode.HasValue)
-            {
-                ScanModePanel.Visible = true;
-                ScanModeText.Text = Loc.GetString(msg.ScanMode.Value ? "health-analyzer-window-scan-mode-active" : "health-analyzer-window-scan-mode-inactive");
-                ScanModeText.FontColorOverride = msg.ScanMode.Value ? Color.Green : Color.Red;
-            }
-            else
-            {
-                ScanModePanel.Visible = false;
-            }
+            ScanModeLabel.Text = msg.ScanMode.HasValue
+                ? msg.ScanMode.Value
+                    ? Loc.GetString("health-analyzer-window-scan-mode-active")
+                    : Loc.GetString("health-analyzer-window-scan-mode-inactive")
+                : Loc.GetString("health-analyzer-window-entity-unknown-text");
 
-            PatientName.Text = Loc.GetString(
-                "health-analyzer-window-entity-health-text",
-                ("entityName", entityName)
-            );
+            ScanModeLabel.FontColorOverride = msg.ScanMode.HasValue && msg.ScanMode.Value ? Color.Green : Color.Red;
 
-            Temperature.Text = Loc.GetString("health-analyzer-window-entity-temperature-text",
-                ("temperature", float.IsNaN(msg.Temperature) ? "N/A" : $"{msg.Temperature - Atmospherics.T0C:F1} °C ({msg.Temperature:F1} K)")
-            );
+            // Patient Information
 
-            BloodLevel.Text = Loc.GetString("health-analyzer-window-entity-blood-level-text",
-                ("bloodLevel", float.IsNaN(msg.BloodLevel) ? "N/A" : $"{msg.BloodLevel * 100:F1} %")
-            );
+            SpriteView.SetEntity(target.Value);
+
+            var name = new FormattedMessage();
+            name.PushColor(Color.White);
+            name.AddText(_entityManager.HasComponent<MetaDataComponent>(target.Value)
+                ? Identity.Name(target.Value, _entityManager)
+                : Loc.GetString("health-analyzer-window-entity-unknown-text"));
+            NameLabel.SetMessage(name);
+
+            SpeciesLabel.Text =
+                _entityManager.TryGetComponent<HumanoidAppearanceComponent>(target.Value,
+                    out var humanoidAppearanceComponent)
+                    ? Loc.GetString(_prototypes.Index<SpeciesPrototype>(humanoidAppearanceComponent.Species).Name)
+                    : Loc.GetString("health-analyzer-window-entity-unknown-species-text");
+
+            // Basic Diagnostic
+
+            TemperatureLabel.Text = !float.IsNaN(msg.Temperature)
+                ? $"{msg.Temperature - Atmospherics.T0C:F1} °C ({msg.Temperature:F1} K)"
+                : Loc.GetString("health-analyzer-window-entity-unknown-value-text");
+
+            BloodLabel.Text = !float.IsNaN(msg.BloodLevel)
+                ? $"{msg.BloodLevel * 100:F1} %"
+                : Loc.GetString("health-analyzer-window-entity-unknown-value-text");
+
+            StatusLabel.Text =
+                _entityManager.TryGetComponent<MobStateComponent>(target.Value, out var mobStateComponent)
+                    ? GetStatus(mobStateComponent.CurrentState)
+                    : Loc.GetString("health-analyzer-window-entity-unknown-text");
+
+            // Total Damage
+
+            DamageLabel.Text = damageable.TotalDamage.ToString();
+
+            // Alerts
+
+            AlertsDivider.Visible = msg.Bleeding == true;
+            AlertsContainer.Visible = msg.Bleeding == true;
 
             if (msg.Bleeding == true)
             {
-                Bleeding.Text = Loc.GetString("health-analyzer-window-entity-bleeding-text");
-                Bleeding.FontColorOverride = Color.Red;
-            }
-            else
-            {
-                Bleeding.Text = string.Empty;  // Clear the text
+                AlertsContainer.DisposeAllChildren();
+                AlertsContainer.AddChild(new Label
+                {
+                    Text = Loc.GetString("health-analyzer-window-entity-bleeding-text"),
+                    FontColorOverride = Color.Red,
+                });
             }
 
-            patientDamageAmount.Text = Loc.GetString(
-                "health-analyzer-window-entity-damage-total-text",
-                ("amount", damageable.TotalDamage)
-            );
+            // Damage Groups
 
             var damageSortedGroups =
-                damageable.DamagePerGroup.OrderBy(damage => damage.Value)
+                damageable.DamagePerGroup.OrderByDescending(damage => damage.Value)
                     .ToDictionary(x => x.Key, x => x.Value);
+
             IReadOnlyDictionary<string, FixedPoint2> damagePerType = damageable.Damage.DamageDict;
 
             DrawDiagnosticGroups(damageSortedGroups, damagePerType);
+        }
 
-            if (_entityManager.TryGetComponent(target, out HungerComponent? hunger)
-                && hunger.StarvationDamage != null
-                && hunger.CurrentThreshold <= HungerThreshold.Starving)
+        private static string GetStatus(MobState mobState)
+        {
+            return mobState switch
             {
-                var box = new Control { Margin = new Thickness(0, 0, 0, 15) };
-
-                box.AddChild(CreateDiagnosticGroupTitle(
-                    Loc.GetString("health-analyzer-window-malnutrition"),
-                    "malnutrition"));
-
-                GroupsContainer.AddChild(box);
-            }
-
-            SetHeight = AnalyzerHeight;
-            SetWidth = AnalyzerWidth;
+                MobState.Alive => Loc.GetString("health-analyzer-window-entity-alive-text"),
+                MobState.Critical => Loc.GetString("health-analyzer-window-entity-critical-text"),
+                MobState.Dead => Loc.GetString("health-analyzer-window-entity-dead-text"),
+                _ => Loc.GetString("health-analyzer-window-entity-unknown-text"),
+            };
         }
 
         private void DrawDiagnosticGroups(
-            Dictionary<string, FixedPoint2> groups, IReadOnlyDictionary<string, FixedPoint2> damageDict)
+            Dictionary<string, FixedPoint2> groups,
+            IReadOnlyDictionary<string, FixedPoint2> damageDict)
         {
-            HashSet<string> shownTypes = new();
+            GroupsContainer.RemoveAllChildren();
 
-            // Show the total damage and type breakdown for each damage group.
-            foreach (var (damageGroupId, damageAmount) in groups.Reverse())
+            foreach (var (damageGroupId, damageAmount) in groups)
             {
                 if (damageAmount == 0)
                     continue;
@@ -145,7 +162,6 @@ namespace Content.Client.HealthAnalyzer.UI
 
                 var groupContainer = new BoxContainer
                 {
-                    Margin = new Thickness(0, 0, 0, 15),
                     Align = BoxContainer.AlignMode.Begin,
                     Orientation = BoxContainer.LayoutOrientation.Vertical,
                 };
@@ -159,23 +175,16 @@ namespace Content.Client.HealthAnalyzer.UI
 
                 foreach (var type in group.DamageTypes)
                 {
-                    if (damageDict.TryGetValue(type, out var typeAmount) && typeAmount > 0)
-                    {
-                        // If damage types are allowed to belong to more than one damage group,
-                        // they may appear twice here. Mark them as duplicate.
-                        if (shownTypes.Contains(type))
-                            continue;
+                    if (!damageDict.TryGetValue(type, out var typeAmount) || typeAmount <= 0)
+                        continue;
 
-                        shownTypes.Add(type);
+                    var damageString = Loc.GetString(
+                        "health-analyzer-window-damage-type-text",
+                        ("damageType", _prototypes.Index<DamageTypePrototype>(type).LocalizedName),
+                        ("amount", typeAmount)
+                    );
 
-                        var damageString = Loc.GetString(
-                            "health-analyzer-window-damage-type-text",
-                            ("damageType", _prototypes.Index<DamageTypePrototype>(type).LocalizedName),
-                            ("amount", typeAmount)
-                        );
-
-                        groupContainer.AddChild(CreateDiagnosticItemLabel(damageString.Insert(0, "- ")));
-                    }
+                    groupContainer.AddChild(CreateDiagnosticItemLabel(damageString.Insert(0, " · ")));
                 }
             }
         }
@@ -198,7 +207,6 @@ namespace Content.Client.HealthAnalyzer.UI
         {
             return new Label
             {
-                Margin = new Thickness(2, 2),
                 Text = text,
             };
         }
@@ -207,13 +215,13 @@ namespace Content.Client.HealthAnalyzer.UI
         {
             var rootContainer = new BoxContainer
             {
+                Margin = new Thickness(0, 6, 0, 0),
                 VerticalAlignment = VAlignment.Bottom,
-                Orientation = BoxContainer.LayoutOrientation.Horizontal
+                Orientation = BoxContainer.LayoutOrientation.Horizontal,
             };
 
             rootContainer.AddChild(new TextureRect
             {
-                Margin = new Thickness(0, 3),
                 SetSize = new Vector2(30, 30),
                 Texture = GetTexture(id.ToLower())
             });

Content.Client/Info/InfoSection.xaml.cs

@@ -1,4 +1,4 @@
-using Robust.Client.AutoGenerated;
+using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Utility;
@@ -18,7 +18,7 @@ public sealed partial class InfoSection : BoxContainer
     {
         TitleLabel.Text = title;
         if (markup)
-            Content.SetMessage(FormattedMessage.FromMarkup(text.Trim()));
+            Content.SetMessage(FormattedMessage.FromMarkupOrThrow(text.Trim()));
         else
             Content.SetMessage(text);
     }

Content.Client/Info/ServerInfo.cs

@@ -24,7 +24,7 @@ namespace Content.Client.Info
         }
         public void SetInfoBlob(string markup)
         {
-            _richTextLabel.SetMessage(FormattedMessage.FromMarkup(markup));
+            _richTextLabel.SetMessage(FormattedMessage.FromMarkupOrThrow(markup));
         }
     }
 }

Content.Client/Labels/UI/HandLabelerBoundUserInterface.cs

@@ -26,6 +26,11 @@ namespace Content.Client.Labels.UI
 
             _window = this.CreateWindow<HandLabelerWindow>();
 
+            if (_entManager.TryGetComponent(Owner, out HandLabelerComponent? labeler))
+            {
+                _window.SetMaxLabelLength(labeler!.MaxLabelChars);
+            }
+
             _window.OnLabelChanged += OnLabelChanged;
             Reload();
         }

Content.Client/Labels/UI/HandLabelerWindow.xaml.cs

@@ -21,7 +21,7 @@ namespace Content.Client.Labels.UI
         {
             RobustXamlLoader.Load(this);
 
-            LabelLineEdit.OnTextEntered += e =>
+            LabelLineEdit.OnTextChanged += e =>
             {
                 _label = e.Text;
                 OnLabelChanged?.Invoke(_label);
@@ -33,6 +33,10 @@ namespace Content.Client.Labels.UI
                 _focused = false;
                 LabelLineEdit.Text = _label;
             };
+
+            // Give the editor keybard focus, since that's the only
+            // thing the user will want to be doing with this UI
+            LabelLineEdit.GrabKeyboardFocus();
         }
 
         public void SetCurrentLabel(string label)
@@ -44,5 +48,10 @@ namespace Content.Client.Labels.UI
             if (!_focused)
                 LabelLineEdit.Text = label;
         }
+
+        public void SetMaxLabelLength(int maxLength)
+        {
+            LabelLineEdit.IsValid = s => s.Length <= maxLength;
+        }
     }
 }

Content.Client/Launcher/LauncherConnecting.cs

@@ -19,6 +19,7 @@ namespace Content.Client.Launcher
         [Dependency] private readonly IRobustRandom _random = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly IConfigurationManager _cfg = default!;
+        [Dependency] private readonly IClipboardManager _clipboard = default!;
 
         private LauncherConnectingGui? _control;
 
@@ -58,7 +59,7 @@ namespace Content.Client.Launcher
 
         protected override void Startup()
         {
-            _control = new LauncherConnectingGui(this, _random, _prototypeManager, _cfg);
+            _control = new LauncherConnectingGui(this, _random, _prototypeManager, _cfg, _clipboard);
 
             _userInterfaceManager.StateRoot.AddChild(_control);
 

Content.Client/Launcher/LauncherConnectingGui.xaml

@@ -18,21 +18,38 @@
                 <Control VerticalExpand="True" Margin="0 0 0 8">
                     <BoxContainer Orientation="Vertical" Name="ConnectingStatus">
                         <Label Text="{Loc 'connecting-in-progress'}" Align="Center" />
-                        <!-- Who the fuck named these cont- oh wait I did -->
                         <Label Name="ConnectStatus" StyleClasses="LabelSubText" Align="Center" />
                     </BoxContainer>
-                    <BoxContainer Orientation="Vertical" Name="ConnectFail" Visible="False">
+                    <BoxContainer Orientation="Vertical" Name="ConnectFail" Visible="False" SeparationOverride="10">
                         <RichTextLabel Name="ConnectFailReason" VerticalAlignment="Stretch"/>
-                        <Button Name="RetryButton" Text="{Loc 'connecting-retry'}"
-                                HorizontalAlignment="Center"
-                                VerticalExpand="True" VerticalAlignment="Bottom" />
+                        <BoxContainer Orientation="Horizontal" Align="Center">
+                            <Button Name="RetryButton"
+                                    Text="{Loc 'connecting-retry'}"
+                                    HorizontalAlignment="Center"
+                                    VerticalAlignment="Bottom"
+                                    StyleClasses="OpenRight"/>
+                            <Button Name="CopyButton"
+                                    Text="{Loc 'connecting-copy'}"
+                                    HorizontalAlignment="Center"
+                                    VerticalAlignment="Bottom"
+                                    StyleClasses="OpenLeft"/>
+                        </BoxContainer>
                     </BoxContainer>
-                    <BoxContainer Orientation="Vertical" Name="Disconnected">
+                    <BoxContainer Orientation="Vertical" Name="Disconnected" Visible="False" SeparationOverride="10">
                         <Label Text="{Loc 'connecting-disconnected'}" Align="Center" />
                         <Label Name="DisconnectReason" Align="Center" />
-                        <Button Name="ReconnectButton" Text="{Loc 'connecting-reconnect'}"
-                                HorizontalAlignment="Center"
-                                VerticalExpand="True" VerticalAlignment="Bottom" />
+                        <BoxContainer Orientation="Horizontal" Align="Center" VerticalAlignment="Bottom">
+                            <Button Name="ReconnectButton"
+                                    Text="{Loc 'connecting-reconnect'}"
+                                    HorizontalAlignment="Center"
+                                    VerticalAlignment="Bottom"
+                                    StyleClasses="OpenRight"/>
+                            <Button Name="CopyButtonDisconnected"
+                                    Text="{Loc 'connecting-copy'}"
+                                    HorizontalAlignment="Center"
+                                    VerticalAlignment="Bottom"
+                                    StyleClasses="OpenLeft"/>
+                        </BoxContainer>
                     </BoxContainer>
                 </Control>
                 <Label Name="ConnectingAddress" StyleClasses="LabelSubText" HorizontalAlignment="Center" />

Content.Client/Launcher/LauncherConnectingGui.xaml.cs

@@ -28,14 +28,16 @@ namespace Content.Client.Launcher
         private readonly IRobustRandom _random;
         private readonly IPrototypeManager _prototype;
         private readonly IConfigurationManager _cfg;
+        private readonly IClipboardManager _clipboard;
 
         public LauncherConnectingGui(LauncherConnecting state, IRobustRandom random,
-            IPrototypeManager prototype, IConfigurationManager config)
+            IPrototypeManager prototype, IConfigurationManager config, IClipboardManager clipboard)
         {
             _state = state;
             _random = random;
             _prototype = prototype;
             _cfg = config;
+            _clipboard = clipboard;
 
             RobustXamlLoader.Load(this);
 
@@ -44,8 +46,11 @@ namespace Content.Client.Launcher
             Stylesheet = IoCManager.Resolve<IStylesheetManager>().SheetSpace;
 
             ChangeLoginTip();
-            ReconnectButton.OnPressed += ReconnectButtonPressed;
             RetryButton.OnPressed += ReconnectButtonPressed;
+            ReconnectButton.OnPressed += ReconnectButtonPressed;
+
+            CopyButton.OnPressed += CopyButtonPressed;
+            CopyButtonDisconnected.OnPressed += CopyButtonDisconnectedPressed;
             ExitButton.OnPressed += _ => _state.Exit();
 
             var addr = state.Address;
@@ -78,6 +83,24 @@ namespace Content.Client.Launcher
             _state.RetryConnect();
         }
 
+        private void CopyButtonPressed(BaseButton.ButtonEventArgs args)
+        {
+            CopyText(ConnectFailReason.Text);
+        }
+
+        private void CopyButtonDisconnectedPressed(BaseButton.ButtonEventArgs args)
+        {
+            CopyText(DisconnectReason.Text);
+        }
+
+        private void CopyText(string? text)
+        {
+            if (!string.IsNullOrEmpty(text))
+            {
+                _clipboard.SetText(text);
+            }
+        }
+
         private void ConnectFailReasonChanged(string? reason)
         {
             ConnectFailReason.SetMessage(reason == null

Content.Client/Light/Components/LightBehaviourComponent.cs

@@ -359,9 +359,6 @@ namespace Content.Client.Light.Components
     [RegisterComponent]
     public sealed partial class LightBehaviourComponent : SharedLightBehaviourComponent, ISerializationHooks
     {
-        [Dependency] private readonly IEntityManager _entMan = default!;
-        [Dependency] private readonly IRobustRandom _random = default!;
-
         public const string KeyPrefix = nameof(LightBehaviourComponent);
 
         public sealed class AnimationContainer

Content.Client/Lobby/UI/HumanoidProfileEditor.xaml.cs

@@ -719,6 +719,9 @@ namespace Content.Client.Lobby.UI
             PreviewDummy = _controller.LoadProfileEntity(Profile, JobOverride, ShowClothes.Pressed);
             SpriteView.SetEntity(PreviewDummy);
             _entManager.System<MetaDataSystem>().SetEntityName(PreviewDummy, Profile.Name);
+
+            // Check and set the dirty flag to enable the save/reset buttons as appropriate.
+            SetDirty();
         }
 
         /// <summary>
@@ -779,6 +782,9 @@ namespace Content.Client.Lobby.UI
                 return;
 
             _entManager.System<HumanoidAppearanceSystem>().LoadProfile(PreviewDummy, Profile);
+
+            // Check and set the dirty flag to enable the save/reset buttons as appropriate.
+            SetDirty();
         }
 
         private void OnSpeciesInfoButtonPressed(BaseButton.ButtonEventArgs args)
@@ -1015,7 +1021,6 @@ namespace Content.Client.Lobby.UI
                 roleLoadout.AddLoadout(loadoutGroup, loadoutProto, _prototypeManager);
                 _loadoutWindow.RefreshLoadouts(roleLoadout, session, collection);
                 Profile = Profile?.WithLoadout(roleLoadout);
-                SetDirty();
                 ReloadPreview();
             };
 
@@ -1024,7 +1029,6 @@ namespace Content.Client.Lobby.UI
                 roleLoadout.RemoveLoadout(loadoutGroup, loadoutProto, _prototypeManager);
                 _loadoutWindow.RefreshLoadouts(roleLoadout, session, collection);
                 Profile = Profile?.WithLoadout(roleLoadout);
-                SetDirty();
                 ReloadPreview();
             };
 
@@ -1034,7 +1038,6 @@ namespace Content.Client.Lobby.UI
             _loadoutWindow.OnClose += () =>
             {
                 JobOverride = null;
-                SetDirty();
                 ReloadPreview();
             };
 
@@ -1059,7 +1062,6 @@ namespace Content.Client.Lobby.UI
                 return;
 
             Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithMarkings(markings.GetForwardEnumerator().ToList()));
-            SetDirty();
             ReloadProfilePreview();
         }
 
@@ -1143,7 +1145,6 @@ namespace Content.Client.Lobby.UI
                 // CP14 - Custom HumanoidSkinColor - End
             }
 
-            SetDirty();
             ReloadProfilePreview();
         }
 
@@ -1174,7 +1175,6 @@ namespace Content.Client.Lobby.UI
         {
             Profile = Profile?.WithAge(newAge);
             ReloadPreview();
-            SetDirty();
         }
 
         private void SetSex(Sex newSex)
@@ -1197,14 +1197,12 @@ namespace Content.Client.Lobby.UI
             UpdateGenderControls();
             Markings.SetSex(newSex);
             ReloadPreview();
-            SetDirty();
         }
 
         private void SetGender(Gender newGender)
         {
             Profile = Profile?.WithGender(newGender);
             ReloadPreview();
-            SetDirty();
         }
 
         private void SetSpecies(string newSpecies)
@@ -1218,7 +1216,6 @@ namespace Content.Client.Lobby.UI
             RefreshLoadouts();
             UpdateSexControls(); // update sex for new species
             UpdateSpeciesGuidebookIcon();
-            SetDirty();
             ReloadPreview();
         }
 

Content.Client/Lobby/UI/Loadouts/LoadoutWindow.xaml

@@ -1,10 +1,24 @@
 <controls:FancyWindow xmlns="https://spacestation14.io"
          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
          xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+         xmlns:graphics="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
          SetSize="800 800"
-         MinSize="800 64">
+         MinSize="800 128">
+    <BoxContainer Orientation="Vertical" VerticalExpand="True">
+        <!--
+        <BoxContainer Name="RoleNameBox" Orientation="Vertical" Margin="10">
+            <Label Name="LoadoutNameLabel" Text="{Loc 'loadout-name-edit-label'}"/>
+            <PanelContainer HorizontalExpand="True" SetHeight="24">
+                <PanelContainer.PanelOverride>
+                    <graphics:StyleBoxFlat BackgroundColor="#1B1B1E" />
+                </PanelContainer.PanelOverride>
+                <LineEdit Name="RoleNameEdit" ToolTip="{Loc 'loadout-name-edit-tooltip'}" VerticalExpand="True" HorizontalExpand="True"/>
+            </PanelContainer>
+        </BoxContainer>
+        -->
         <VerticalTabContainer Name="LoadoutGroupsContainer"
-                      VerticalExpand="True"
-                      HorizontalExpand="True">
+                              VerticalExpand="True"
+                              HorizontalExpand="True">
         </VerticalTabContainer>
+    </BoxContainer>
 </controls:FancyWindow>

Content.Client/Lobby/UI/Loadouts/LoadoutWindow.xaml.cs

@@ -1,3 +1,4 @@
+using System.Numerics;
 using Content.Client.UserInterface.Controls;
 using Content.Shared.Preferences;
 using Content.Shared.Preferences.Loadouts;
@@ -5,6 +6,7 @@ using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
 
 namespace Content.Client.Lobby.UI.Loadouts;
 
@@ -24,27 +26,36 @@ public sealed partial class LoadoutWindow : FancyWindow
         Profile = profile;
         var protoManager = collection.Resolve<IPrototypeManager>();
 
-        foreach (var group in proto.Groups)
+        // Hide if no groups
+        if (proto.Groups.Count == 0)
         {
-            if (!protoManager.TryIndex(group, out var groupProto))
-                continue;
-
-            if (groupProto.Hidden)
-                continue;
-
-            var container = new LoadoutGroupContainer(profile, loadout, protoManager.Index(group), session, collection);
-            LoadoutGroupsContainer.AddTab(container, Loc.GetString(groupProto.Name));
-            _groups.Add(container);
-
-            container.OnLoadoutPressed += args =>
+            LoadoutGroupsContainer.Visible = false;
+            SetSize = Vector2.Zero;
+        }
+        else
+        {
+            foreach (var group in proto.Groups)
             {
-                OnLoadoutPressed?.Invoke(group, args);
-            };
+                if (!protoManager.TryIndex(group, out var groupProto))
+                    continue;
 
-            container.OnLoadoutUnpressed += args =>
-            {
-                OnLoadoutUnpressed?.Invoke(group, args);
-            };
+                if (groupProto.Hidden)
+                    continue;
+
+                var container = new LoadoutGroupContainer(profile, loadout, protoManager.Index(group), session, collection);
+                LoadoutGroupsContainer.AddTab(container, Loc.GetString(groupProto.Name));
+                _groups.Add(container);
+
+                container.OnLoadoutPressed += args =>
+                {
+                    OnLoadoutPressed?.Invoke(group, args);
+                };
+
+                container.OnLoadoutUnpressed += args =>
+                {
+                    OnLoadoutUnpressed?.Invoke(group, args);
+                };
+            }
         }
     }
 

Content.Client/Lobby/UI/LobbyCharacterPreviewPanel.xaml.cs

@@ -1,5 +1,6 @@
 using System.Numerics;
 using Content.Client.UserInterface.Controls;
+using Prometheus;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;

Content.Client/Lobby/UI/LobbyGui.xaml.cs

@@ -2,6 +2,7 @@ using Content.Client.Message;
 using Content.Client.UserInterface.Systems.EscapeMenu;
 using Robust.Client.AutoGenerated;
 using Robust.Client.Console;
+using Robust.Client.State;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.XAML;
 

Content.Client/MachineLinking/UI/SignalTimerBoundUserInterface.cs

@@ -7,8 +7,6 @@ namespace Content.Client.MachineLinking.UI;
 
 public sealed class SignalTimerBoundUserInterface : BoundUserInterface
 {
-    [Dependency] private readonly IGameTiming _gameTiming = default!;
-
     [ViewVariables]
     private SignalTimerWindow? _window;
 

Content.Client/MachineLinking/UI/SignalTimerWindow.xaml.cs

@@ -3,6 +3,7 @@ using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Timing;
 using Content.Client.TextScreen;
+using Robust.Client.UserInterface.Controls;
 
 namespace Content.Client.MachineLinking.UI;
 

Content.Client/MassMedia/Ui/ArticleEditorPanel.xaml

@@ -47,8 +47,10 @@
             </Control>
             <Control HorizontalExpand="True"/>
             <BoxContainer Orientation="Horizontal">
+                <Button Name="ButtonSaveDraft" SetHeight="32" SetWidth="85"
+                        StyleClasses="OpenRight" Text="{Loc news-write-ui-save-text}"/>
                 <Button Name="ButtonPreview" SetHeight="32" SetWidth="85"
-                        StyleClasses="OpenRight" Text="{Loc news-write-ui-preview-text}"/>
+                        StyleClasses="OpenBoth" Text="{Loc news-write-ui-preview-text}"/>
                 <Button Name="ButtonPublish" SetHeight="32" SetWidth="85" Text="{Loc news-write-ui-publish-text}" Access="Public"/>
             </BoxContainer>
         </BoxContainer>

Content.Client/MassMedia/Ui/ArticleEditorPanel.xaml.cs

@@ -14,6 +14,7 @@ namespace Content.Client.MassMedia.Ui;
 public sealed partial class ArticleEditorPanel : Control
 {
     public event Action? PublishButtonPressed;
+    public event Action<string, string>? ArticleDraftUpdated;
 
     private bool _preview;
 
@@ -45,6 +46,7 @@ public sealed partial class ArticleEditorPanel : Control
         ButtonPreview.OnPressed += OnPreview;
         ButtonCancel.OnPressed += OnCancel;
         ButtonPublish.OnPressed += OnPublish;
+        ButtonSaveDraft.OnPressed += OnDraftSaved;
 
         TitleField.OnTextChanged += args => OnTextChanged(args.Text.Length, args.Control, SharedNewsSystem.MaxTitleLength);
         ContentField.OnTextChanged += args => OnTextChanged(Rope.CalcTotalLength(args.TextRope), args.Control, SharedNewsSystem.MaxContentLength);
@@ -68,6 +70,9 @@ public sealed partial class ArticleEditorPanel : Control
             ButtonPublish.Disabled = false;
             ButtonPreview.Disabled = false;
         }
+
+        // save draft regardless; they can edit down the length later
+        ArticleDraftUpdated?.Invoke(TitleField.Text, Rope.Collapse(ContentField.TextRope));
     }
 
     private void OnPreview(BaseButton.ButtonEventArgs eventArgs)
@@ -92,6 +97,12 @@ public sealed partial class ArticleEditorPanel : Control
         Visible = false;
     }
 
+    private void OnDraftSaved(BaseButton.ButtonEventArgs eventArgs)
+    {
+        ArticleDraftUpdated?.Invoke(TitleField.Text, Rope.Collapse(ContentField.TextRope));
+        Visible = false;
+    }
+
     private void Reset()
     {
         _preview = false;
@@ -100,6 +111,7 @@ public sealed partial class ArticleEditorPanel : Control
         PreviewLabel.SetMarkup("");
         TitleField.Text = "";
         ContentField.TextRope = Rope.Leaf.Empty;
+        ArticleDraftUpdated?.Invoke(string.Empty, string.Empty);
     }
 
     protected override void Dispose(bool disposing)

Content.Client/MassMedia/Ui/NewsWriterBoundUserInterface.cs

@@ -25,6 +25,9 @@ public sealed class NewsWriterBoundUserInterface : BoundUserInterface
         _menu.ArticleEditorPanel.PublishButtonPressed += OnPublishButtonPressed;
         _menu.DeleteButtonPressed += OnDeleteButtonPressed;
 
+        _menu.CreateButtonPressed += OnCreateButtonPressed;
+        _menu.ArticleEditorPanel.ArticleDraftUpdated += OnArticleDraftUpdated;
+
         SendMessage(new NewsWriterArticlesRequestMessage());
     }
 
@@ -34,7 +37,7 @@ public sealed class NewsWriterBoundUserInterface : BoundUserInterface
         if (state is not NewsWriterBoundUserInterfaceState cast)
             return;
 
-        _menu?.UpdateUI(cast.Articles, cast.PublishEnabled, cast.NextPublish);
+        _menu?.UpdateUI(cast.Articles, cast.PublishEnabled, cast.NextPublish, cast.DraftTitle, cast.DraftContent);
     }
 
     private void OnPublishButtonPressed()
@@ -67,4 +70,14 @@ public sealed class NewsWriterBoundUserInterface : BoundUserInterface
 
         SendMessage(new NewsWriterDeleteMessage(articleNum));
     }
+
+    private void OnCreateButtonPressed()
+    {
+        SendMessage(new NewsWriterRequestDraftMessage());
+    }
+
+    private void OnArticleDraftUpdated(string title, string content)
+    {
+        SendMessage(new NewsWriterSaveDraftMessage(title, content));
+    }
 }

Content.Client/MassMedia/Ui/NewsWriterMenu.xaml.cs

@@ -4,6 +4,7 @@ using Robust.Client.UserInterface.XAML;
 using Content.Shared.MassMedia.Systems;
 using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 
 namespace Content.Client.MassMedia.Ui;
 
@@ -16,6 +17,8 @@ public sealed partial class NewsWriterMenu : FancyWindow
 
     public event Action<int>? DeleteButtonPressed;
 
+    public event Action? CreateButtonPressed;
+
     public NewsWriterMenu()
     {
         RobustXamlLoader.Load(this);
@@ -31,7 +34,7 @@ public sealed partial class NewsWriterMenu : FancyWindow
         ButtonCreate.OnPressed += OnCreate;
     }
 
-    public void UpdateUI(NewsArticle[] articles, bool publishEnabled, TimeSpan nextPublish)
+    public void UpdateUI(NewsArticle[] articles, bool publishEnabled, TimeSpan nextPublish, string draftTitle, string draftContent)
     {
         ArticlesContainer.Children.Clear();
         ArticleCount.Text = Loc.GetString("news-write-ui-article-count-text", ("count", articles.Length));
@@ -54,6 +57,9 @@ public sealed partial class NewsWriterMenu : FancyWindow
 
         ButtonCreate.Disabled = !publishEnabled;
         _nextPublish = nextPublish;
+
+        ArticleEditorPanel.TitleField.Text = draftTitle;
+        ArticleEditorPanel.ContentField.TextRope = new Rope.Leaf(draftContent);
     }
 
     protected override void FrameUpdate(FrameEventArgs args)
@@ -93,5 +99,6 @@ public sealed partial class NewsWriterMenu : FancyWindow
     private void OnCreate(BaseButton.ButtonEventArgs buttonEventArgs)
     {
         ArticleEditorPanel.Visible = true;
+        CreateButtonPressed?.Invoke();
     }
 }

Content.Client/Message/RichTextLabelExt.cs

@@ -15,7 +15,7 @@ public static class RichTextLabelExt
      /// </remarks>
     public static RichTextLabel SetMarkup(this RichTextLabel label, string markup)
     {
-        label.SetMessage(FormattedMessage.FromMarkup(markup));
+        label.SetMessage(FormattedMessage.FromMarkupOrThrow(markup));
         return label;
     }
 

Content.Client/Mining/MiningOverlay.cs

@@ -0,0 +1,96 @@
+using System.Numerics;
+using Content.Shared.Mining.Components;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Enums;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Mining;
+
+public sealed class MiningOverlay : Overlay
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    private readonly EntityLookupSystem _lookup;
+    private readonly SpriteSystem _sprite;
+    private readonly TransformSystem _xform;
+
+    private readonly EntityQuery<SpriteComponent> _spriteQuery;
+    private readonly EntityQuery<TransformComponent> _xformQuery;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+    public override bool RequestScreenTexture => false;
+
+    private readonly HashSet<Entity<MiningScannerViewableComponent>> _viewableEnts = new();
+
+    public MiningOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+
+        _lookup = _entityManager.System<EntityLookupSystem>();
+        _sprite = _entityManager.System<SpriteSystem>();
+        _xform = _entityManager.System<TransformSystem>();
+
+        _spriteQuery = _entityManager.GetEntityQuery<SpriteComponent>();
+        _xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        var handle = args.WorldHandle;
+
+        if (_player.LocalEntity is not { } localEntity ||
+            !_entityManager.TryGetComponent<MiningScannerViewerComponent>(localEntity, out var viewerComp))
+            return;
+
+        if (viewerComp.LastPingLocation == null)
+            return;
+
+        var scaleMatrix = Matrix3Helpers.CreateScale(Vector2.One);
+
+        _viewableEnts.Clear();
+        _lookup.GetEntitiesInRange(viewerComp.LastPingLocation.Value, viewerComp.ViewRange, _viewableEnts);
+        foreach (var ore in _viewableEnts)
+        {
+            if (!_xformQuery.TryComp(ore, out var xform) ||
+                !_spriteQuery.TryComp(ore, out var sprite))
+                continue;
+
+            if (xform.MapID != args.MapId || !sprite.Visible)
+                continue;
+
+            if (!sprite.LayerMapTryGet(MiningScannerVisualLayers.Overlay, out var idx))
+                continue;
+            var layer = sprite[idx];
+
+            if (layer.ActualRsi?.Path == null || layer.RsiState.Name == null)
+                continue;
+
+            var gridRot = xform.GridUid == null ? 0 : _xformQuery.CompOrNull(xform.GridUid.Value)?.LocalRotation ?? 0;
+            var rotationMatrix = Matrix3Helpers.CreateRotation(gridRot);
+
+            var worldMatrix = Matrix3Helpers.CreateTranslation(_xform.GetWorldPosition(xform));
+            var scaledWorld = Matrix3x2.Multiply(scaleMatrix, worldMatrix);
+            var matty = Matrix3x2.Multiply(rotationMatrix, scaledWorld);
+            handle.SetTransform(matty);
+
+            var spriteSpec = new SpriteSpecifier.Rsi(layer.ActualRsi.Path, layer.RsiState.Name);
+            var texture = _sprite.GetFrame(spriteSpec, TimeSpan.FromSeconds(layer.AnimationTime));
+
+            var animTime = (viewerComp.NextPingTime - _timing.CurTime).TotalSeconds;
+
+
+            var alpha = animTime < viewerComp.AnimationDuration
+                ? 0
+                : (float) Math.Clamp((animTime - viewerComp.AnimationDuration) / viewerComp.AnimationDuration, 0f, 1f);
+            var color = Color.White.WithAlpha(alpha);
+
+            handle.DrawTexture(texture, -(Vector2) texture.Size / 2f / EyeManager.PixelsPerMeter, layer.Rotation, modulate: color);
+
+        }
+        handle.SetTransform(Matrix3x2.Identity);
+    }
+}

Content.Client/Mining/MiningOverlaySystem.cs

@@ -0,0 +1,54 @@
+using Content.Shared.Mining.Components;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Player;
+
+namespace Content.Client.Mining;
+
+/// <summary>
+/// This handles the lifetime of the <see cref="MiningOverlay"/> for a given entity.
+/// </summary>
+public sealed class MiningOverlaySystem : EntitySystem
+{
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+    private MiningOverlay _overlay = default!;
+
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<MiningScannerViewerComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<MiningScannerViewerComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<MiningScannerViewerComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<MiningScannerViewerComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
+
+        _overlay = new();
+    }
+
+    private void OnPlayerAttached(Entity<MiningScannerViewerComponent> ent, ref LocalPlayerAttachedEvent args)
+    {
+        _overlayMan.AddOverlay(_overlay);
+    }
+
+    private void OnPlayerDetached(Entity<MiningScannerViewerComponent> ent, ref LocalPlayerDetachedEvent args)
+    {
+        _overlayMan.RemoveOverlay(_overlay);
+    }
+
+    private void OnInit(Entity<MiningScannerViewerComponent> ent, ref ComponentInit args)
+    {
+        if (_player.LocalEntity == ent)
+        {
+            _overlayMan.AddOverlay(_overlay);
+        }
+    }
+
+    private void OnShutdown(Entity<MiningScannerViewerComponent> ent, ref ComponentShutdown args)
+    {
+        if (_player.LocalEntity == ent)
+        {
+            _overlayMan.RemoveOverlay(_overlay);
+        }
+    }
+}

Content.Client/Mining/OreVeinVisualsComponent.cs

@@ -1,6 +0,0 @@
-namespace Content.Client.Mining;
-
-public sealed class OreVeinVisualsComponent
-{
-    
-}

Content.Client/Nuke/NukeMenu.xaml.cs

@@ -107,7 +107,7 @@ namespace Content.Client.Nuke
             FirstStatusLabel.Text = firstMsg;
             SecondStatusLabel.Text = secondMsg;
 
-            EjectButton.Disabled = !state.DiskInserted || state.Status == NukeStatus.ARMED;
+            EjectButton.Disabled = !state.DiskInserted || state.Status == NukeStatus.ARMED || !state.IsAnchored;
             AnchorButton.Disabled = state.Status == NukeStatus.ARMED;
             AnchorButton.Pressed = state.IsAnchored;
             ArmButton.Disabled = !state.AllowArm || !state.IsAnchored;

Content.Client/Nutrition/EntitySystems/ClientFoodSequenceSystem.cs

@@ -1,7 +1,6 @@
 using Content.Shared.Nutrition.Components;
 using Content.Shared.Nutrition.EntitySystems;
 using Robust.Client.GameObjects;
-using Robust.Shared.Utility;
 
 namespace Content.Client.Nutrition.EntitySystems;
 
@@ -50,6 +49,7 @@ public sealed class ClientFoodSequenceSystem : SharedFoodSequenceSystem
             sprite.AddBlankLayer(index);
             sprite.LayerMapSet(keyCode, index);
             sprite.LayerSetSprite(index, state.Sprite);
+            sprite.LayerSetScale(index, state.Scale);
 
             //Offset the layer
             var layerPos = start.Comp.StartPosition;

Content.Client/Options/UI/OptionsMenu.xaml.cs

@@ -1,3 +1,4 @@
+using Content.Client.Options.UI.Tabs;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;

Content.Client/PDA/PdaBoundUserInterface.cs

@@ -4,18 +4,20 @@ using Content.Shared.Containers.ItemSlots;
 using Content.Shared.PDA;
 using JetBrains.Annotations;
 using Robust.Client.UserInterface;
-using Robust.Shared.Configuration;
 
 namespace Content.Client.PDA
 {
     [UsedImplicitly]
     public sealed class PdaBoundUserInterface : CartridgeLoaderBoundUserInterface
     {
+        private readonly PdaSystem _pdaSystem;
+
         [ViewVariables]
         private PdaMenu? _menu;
 
         public PdaBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
         {
+            _pdaSystem = EntMan.System<PdaSystem>();
         }
 
         protected override void Open()
@@ -92,7 +94,13 @@ namespace Content.Client.PDA
             if (state is not PdaUpdateState updateState)
                 return;
 
-            _menu?.UpdateState(updateState);
+            if (_menu == null)
+            {
+                _pdaSystem.Log.Error("PDA state received before menu was created.");
+                return;
+            }
+
+            _menu.UpdateState(updateState);
         }
 
         protected override void AttachCartridgeUI(Control cartridgeUIFragment, string? title)

Content.Client/PDA/PdaMenu.xaml

@@ -67,14 +67,17 @@
                                        Description="{Loc 'comp-pda-ui-ringtone-button-description'}"/>
                 <pda:PdaSettingsButton Name="ActivateMusicButton"
                                        Access="Public"
+                                       Visible="False"
                                        Text="{Loc 'pda-bound-user-interface-music-button'}"
                                        Description="{Loc 'pda-bound-user-interface-music-button-description'}"/>
                 <pda:PdaSettingsButton Name="ShowUplinkButton"
                                        Access="Public"
+                                       Visible="False"
                                        Text="{Loc 'pda-bound-user-interface-show-uplink-title'}"
                                        Description="{Loc 'pda-bound-user-interface-show-uplink-description'}"/>
                 <pda:PdaSettingsButton Name="LockUplinkButton"
                                        Access="Public"
+                                       Visible="False"
                                        Text="{Loc 'pda-bound-user-interface-lock-uplink-title'}"
                                        Description="{Loc 'pda-bound-user-interface-lock-uplink-description'}"/>
             </BoxContainer>

Content.Client/Physics/Controllers/MoverController.cs

@@ -8,132 +8,131 @@ using Robust.Shared.Physics.Components;
 using Robust.Shared.Player;
 using Robust.Shared.Timing;
 
-namespace Content.Client.Physics.Controllers
+namespace Content.Client.Physics.Controllers;
+
+public sealed class MoverController : SharedMoverController
 {
-    public sealed class MoverController : SharedMoverController
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+
+    public override void Initialize()
     {
-        [Dependency] private readonly IGameTiming _timing = default!;
-        [Dependency] private readonly IPlayerManager _playerManager = default!;
+        base.Initialize();
+        SubscribeLocalEvent<RelayInputMoverComponent, LocalPlayerAttachedEvent>(OnRelayPlayerAttached);
+        SubscribeLocalEvent<RelayInputMoverComponent, LocalPlayerDetachedEvent>(OnRelayPlayerDetached);
+        SubscribeLocalEvent<InputMoverComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<InputMoverComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
 
-        public override void Initialize()
+        SubscribeLocalEvent<InputMoverComponent, UpdateIsPredictedEvent>(OnUpdatePredicted);
+        SubscribeLocalEvent<MovementRelayTargetComponent, UpdateIsPredictedEvent>(OnUpdateRelayTargetPredicted);
+        SubscribeLocalEvent<PullableComponent, UpdateIsPredictedEvent>(OnUpdatePullablePredicted);
+    }
+
+    private void OnUpdatePredicted(Entity<InputMoverComponent> entity, ref UpdateIsPredictedEvent args)
+    {
+        // Enable prediction if an entity is controlled by the player
+        if (entity.Owner == _playerManager.LocalEntity)
+            args.IsPredicted = true;
+    }
+
+    private void OnUpdateRelayTargetPredicted(Entity<MovementRelayTargetComponent> entity, ref UpdateIsPredictedEvent args)
+    {
+        if (entity.Comp.Source == _playerManager.LocalEntity)
+            args.IsPredicted = true;
+    }
+
+    private void OnUpdatePullablePredicted(Entity<PullableComponent> entity, ref UpdateIsPredictedEvent args)
+    {
+        // Enable prediction if an entity is being pulled by the player.
+        // Disable prediction if an entity is being pulled by some non-player entity.
+
+        if (entity.Comp.Puller == _playerManager.LocalEntity)
+            args.IsPredicted = true;
+        else if (entity.Comp.Puller != null)
+            args.BlockPrediction = true;
+
+        // TODO recursive pulling checks?
+        // What if the entity is being pulled by a vehicle controlled by the player?
+    }
+
+    private void OnRelayPlayerAttached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerAttachedEvent args)
+    {
+        Physics.UpdateIsPredicted(entity.Owner);
+        Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
+        if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
+            SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
+    }
+
+    private void OnRelayPlayerDetached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerDetachedEvent args)
+    {
+        Physics.UpdateIsPredicted(entity.Owner);
+        Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
+        if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
+            SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
+    }
+
+    private void OnPlayerAttached(Entity<InputMoverComponent> entity, ref LocalPlayerAttachedEvent args)
+    {
+        SetMoveInput(entity, MoveButtons.None);
+    }
+
+    private void OnPlayerDetached(Entity<InputMoverComponent> entity, ref LocalPlayerDetachedEvent args)
+    {
+        SetMoveInput(entity, MoveButtons.None);
+    }
+
+    public override void UpdateBeforeSolve(bool prediction, float frameTime)
+    {
+        base.UpdateBeforeSolve(prediction, frameTime);
+
+        if (_playerManager.LocalEntity is not {Valid: true} player)
+            return;
+
+        if (RelayQuery.TryGetComponent(player, out var relayMover))
+            HandleClientsideMovement(relayMover.RelayEntity, frameTime);
+
+        HandleClientsideMovement(player, frameTime);
+    }
+
+    private void HandleClientsideMovement(EntityUid player, float frameTime)
+    {
+        if (!MoverQuery.TryGetComponent(player, out var mover) ||
+            !XformQuery.TryGetComponent(player, out var xform))
         {
-            base.Initialize();
-            SubscribeLocalEvent<RelayInputMoverComponent, LocalPlayerAttachedEvent>(OnRelayPlayerAttached);
-            SubscribeLocalEvent<RelayInputMoverComponent, LocalPlayerDetachedEvent>(OnRelayPlayerDetached);
-            SubscribeLocalEvent<InputMoverComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
-            SubscribeLocalEvent<InputMoverComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
-
-            SubscribeLocalEvent<InputMoverComponent, UpdateIsPredictedEvent>(OnUpdatePredicted);
-            SubscribeLocalEvent<MovementRelayTargetComponent, UpdateIsPredictedEvent>(OnUpdateRelayTargetPredicted);
-            SubscribeLocalEvent<PullableComponent, UpdateIsPredictedEvent>(OnUpdatePullablePredicted);
+            return;
         }
 
-        private void OnUpdatePredicted(Entity<InputMoverComponent> entity, ref UpdateIsPredictedEvent args)
+        var physicsUid = player;
+        PhysicsComponent? body;
+        var xformMover = xform;
+
+        if (mover.ToParent && RelayQuery.HasComponent(xform.ParentUid))
         {
-            // Enable prediction if an entity is controlled by the player
-            if (entity.Owner == _playerManager.LocalEntity)
-                args.IsPredicted = true;
-        }
-
-        private void OnUpdateRelayTargetPredicted(Entity<MovementRelayTargetComponent> entity, ref UpdateIsPredictedEvent args)
-        {
-            if (entity.Comp.Source == _playerManager.LocalEntity)
-                args.IsPredicted = true;
-        }
-
-        private void OnUpdatePullablePredicted(Entity<PullableComponent> entity, ref UpdateIsPredictedEvent args)
-        {
-            // Enable prediction if an entity is being pulled by the player.
-            // Disable prediction if an entity is being pulled by some non-player entity.
-
-            if (entity.Comp.Puller == _playerManager.LocalEntity)
-                args.IsPredicted = true;
-            else if (entity.Comp.Puller != null)
-                args.BlockPrediction = true;
-
-            // TODO recursive pulling checks?
-            // What if the entity is being pulled by a vehicle controlled by the player?
-        }
-
-        private void OnRelayPlayerAttached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerAttachedEvent args)
-        {
-            Physics.UpdateIsPredicted(entity.Owner);
-            Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
-            if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
-                SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
-        }
-
-        private void OnRelayPlayerDetached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerDetachedEvent args)
-        {
-            Physics.UpdateIsPredicted(entity.Owner);
-            Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
-            if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
-                SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
-        }
-
-        private void OnPlayerAttached(Entity<InputMoverComponent> entity, ref LocalPlayerAttachedEvent args)
-        {
-            SetMoveInput(entity, MoveButtons.None);
-        }
-
-        private void OnPlayerDetached(Entity<InputMoverComponent> entity, ref LocalPlayerDetachedEvent args)
-        {
-            SetMoveInput(entity, MoveButtons.None);
-        }
-
-        public override void UpdateBeforeSolve(bool prediction, float frameTime)
-        {
-            base.UpdateBeforeSolve(prediction, frameTime);
-
-            if (_playerManager.LocalEntity is not {Valid: true} player)
-                return;
-
-            if (RelayQuery.TryGetComponent(player, out var relayMover))
-                HandleClientsideMovement(relayMover.RelayEntity, frameTime);
-
-            HandleClientsideMovement(player, frameTime);
-        }
-
-        private void HandleClientsideMovement(EntityUid player, float frameTime)
-        {
-            if (!MoverQuery.TryGetComponent(player, out var mover) ||
-                !XformQuery.TryGetComponent(player, out var xform))
+            if (!PhysicsQuery.TryGetComponent(xform.ParentUid, out body) ||
+                !XformQuery.TryGetComponent(xform.ParentUid, out xformMover))
             {
                 return;
             }
 
-            var physicsUid = player;
-            PhysicsComponent? body;
-            var xformMover = xform;
-
-            if (mover.ToParent && RelayQuery.HasComponent(xform.ParentUid))
-            {
-                if (!PhysicsQuery.TryGetComponent(xform.ParentUid, out body) ||
-                    !XformQuery.TryGetComponent(xform.ParentUid, out xformMover))
-                {
-                    return;
-                }
-
-                physicsUid = xform.ParentUid;
-            }
-            else if (!PhysicsQuery.TryGetComponent(player, out body))
-            {
-                return;
-            }
-
-            // Server-side should just be handled on its own so we'll just do this shizznit
-            HandleMobMovement(
-                player,
-                mover,
-                physicsUid,
-                body,
-                xformMover,
-                frameTime);
+            physicsUid = xform.ParentUid;
         }
-
-        protected override bool CanSound()
+        else if (!PhysicsQuery.TryGetComponent(player, out body))
         {
-            return _timing is { IsFirstTimePredicted: true, InSimulation: true };
+            return;
         }
+
+        // Server-side should just be handled on its own so we'll just do this shizznit
+        HandleMobMovement(
+            player,
+            mover,
+            physicsUid,
+            body,
+            xformMover,
+            frameTime);
+    }
+
+    protected override bool CanSound()
+    {
+        return _timing is { IsFirstTimePredicted: true, InSimulation: true };
     }
 }

Content.Client/Physics/JointVisualsOverlay.cs

@@ -1,9 +1,8 @@
+using System.Numerics;
 using Content.Shared.Physics;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Shared.Enums;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Dynamics.Joints;
 
 namespace Content.Client.Physics;
 
@@ -16,8 +15,6 @@ public sealed class JointVisualsOverlay : Overlay
 
     private IEntityManager _entManager;
 
-    private HashSet<Joint> _drawn = new();
-
     public JointVisualsOverlay(IEntityManager entManager)
     {
         _entManager = entManager;
@@ -25,7 +22,6 @@ public sealed class JointVisualsOverlay : Overlay
 
     protected override void Draw(in OverlayDrawArgs args)
     {
-        _drawn.Clear();
         var worldHandle = args.WorldHandle;
 
         var spriteSystem = _entManager.System<SpriteSystem>();
@@ -33,12 +29,14 @@ public sealed class JointVisualsOverlay : Overlay
         var joints = _entManager.EntityQueryEnumerator<JointVisualsComponent, TransformComponent>();
         var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
 
+        args.DrawingHandle.SetTransform(Matrix3x2.Identity);
+
         while (joints.MoveNext(out var visuals, out var xform))
         {
             if (xform.MapID != args.MapId)
                 continue;
 
-            var other = visuals.Target;
+            var other = _entManager.GetEntity(visuals.Target);
 
             if (!xformQuery.TryGetComponent(other, out var otherXform))
                 continue;

Content.Client/Players/PlayTimeTracking/JobRequirementsManager.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 using Content.Client.Lobby;
 using Content.Shared.CCVar;
 using Content.Shared.Players;
@@ -133,7 +133,7 @@ public sealed class JobRequirementsManager : ISharedPlaytimeManager
             reasons.Add(jobReason.ToMarkup());
         }
 
-        reason = reasons.Count == 0 ? null : FormattedMessage.FromMarkup(string.Join('\n', reasons));
+        reason = reasons.Count == 0 ? null : FormattedMessage.FromMarkupOrThrow(string.Join('\n', reasons));
         return reason == null;
     }
 

Content.Client/Power/APC/ApcBoundUserInterface.cs

@@ -19,8 +19,8 @@ namespace Content.Client.Power.APC
         protected override void Open()
         {
             base.Open();
-
             _menu = this.CreateWindow<ApcMenu>();
+            _menu.SetEntity(Owner);
             _menu.OnBreaker += BreakerPressed;
         }
 

Content.Client/Power/ActivatableUIRequiresPowerSystem.cs

@@ -18,9 +18,6 @@ public sealed class ActivatableUIRequiresPowerSystem : SharedActivatableUIRequir
             return;
         }
 
-        if (TryComp<WiresPanelComponent>(ent.Owner, out var panel) && panel.Open)
-            return;
-
         _popup.PopupClient(Loc.GetString("base-computer-ui-component-not-powered", ("machine", ent.Owner)), args.User, args.User);
         args.Cancel();
     }

Content.Client/Power/EntitySystems/PowerReceiverSystem.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using Content.Client.Power.Components;
 using Content.Shared.Power.Components;
 using Content.Shared.Power.EntitySystems;
@@ -27,4 +28,16 @@ public sealed class PowerReceiverSystem : SharedPowerReceiverSystem
 
         component.Powered = state.Powered;
     }
+
+    public override bool ResolveApc(EntityUid entity, [NotNullWhen(true)] ref SharedApcPowerReceiverComponent? component)
+    {
+        if (component != null)
+            return true;
+
+        if (!TryComp(entity, out ApcPowerReceiverComponent? receiver))
+            return false;
+
+        component = receiver;
+        return true;
+    }
 }

Content.Client/Power/Generator/GeneratorWindow.xaml.cs

@@ -3,6 +3,7 @@ using Content.Client.UserInterface.Controls;
 using Content.Shared.Power.Generator;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Network;
 
 namespace Content.Client.Power.Generator;
 

Content.Client/Power/PowerCharge/PowerChargeBoundUserInterface.cs

@@ -0,0 +1,38 @@
+using Content.Shared.Power;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.Power.PowerCharge;
+
+public sealed class PowerChargeBoundUserInterface : BoundUserInterface
+{
+    [ViewVariables]
+    private PowerChargeWindow? _window;
+
+    public PowerChargeBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+    }
+
+    public void SetPowerSwitch(bool on)
+    {
+        SendMessage(new SwitchChargingMachineMessage(on));
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+        if (!EntMan.TryGetComponent(Owner, out PowerChargeComponent? component))
+            return;
+
+        _window = this.CreateWindow<PowerChargeWindow>();
+        _window.UpdateWindow(this, Loc.GetString(component.WindowTitle));
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+        if (state is not PowerChargeState chargeState)
+            return;
+
+        _window?.UpdateState(chargeState);
+    }
+}

Content.Client/Power/PowerCharge/PowerChargeComponent.cs

@@ -0,0 +1,10 @@
+using Content.Shared.Power;
+
+namespace Content.Client.Power.PowerCharge;
+
+/// <inheritdoc cref="Content.Shared.Power.SharedPowerChargeComponent" />
+[RegisterComponent]
+public sealed partial class PowerChargeComponent : SharedPowerChargeComponent
+{
+
+}

Content.Client/Power/PowerCharge/PowerChargeWindow.xaml

@@ -1,27 +1,26 @@
 <controls:FancyWindow xmlns="https://spacestation14.io"
                 xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
-                Title="{Loc 'gravity-generator-window-title'}"
                 MinSize="270 130"
                 SetSize="360 180">
     <BoxContainer Margin="4 0" Orientation="Horizontal">
         <BoxContainer Orientation="Vertical" HorizontalExpand="True">
             <GridContainer Margin="2 0 0 0" Columns="2">
                 <!-- Power -->
-                <Label Text="{Loc 'gravity-generator-window-power'}" HorizontalExpand="True" StyleClasses="StatusFieldTitle" />
+                <Label Text="{Loc 'power-charge-window-power'}" HorizontalExpand="True" StyleClasses="StatusFieldTitle" />
                 <BoxContainer Orientation="Horizontal" MinWidth="120">
-                    <Button Name="OnButton" Text="{Loc 'gravity-generator-window-power-on'}" StyleClasses="OpenRight" />
-                    <Button Name="OffButton" Text="{Loc 'gravity-generator-window-power-off'}" StyleClasses="OpenLeft" />
+                    <Button Name="OnButton" Text="{Loc 'power-charge-window-power-on'}" StyleClasses="OpenRight" />
+                    <Button Name="OffButton" Text="{Loc 'power-charge-window-power-off'}" StyleClasses="OpenLeft" />
                 </BoxContainer>
                 <Control /> <!-- Empty control to act as a spacer in the grid. -->
                 <Label Name="PowerLabel" Text="0 / 0 W" />
                 <!-- Status -->
-                <Label Text="{Loc 'gravity-generator-window-status'}"  StyleClasses="StatusFieldTitle" />
-                <Label Name="StatusLabel" Text="{Loc 'gravity-generator-window-status-fully-charged'}" />
+                <Label Text="{Loc 'power-charge-window-status'}"  StyleClasses="StatusFieldTitle" />
+                <Label Name="StatusLabel" Text="{Loc 'power-charge-window-status-fully-charged'}" />
                 <!-- ETA -->
-                <Label Text="{Loc 'gravity-generator-window-eta'}" StyleClasses="StatusFieldTitle" />
+                <Label Text="{Loc 'power-charge-window-eta'}" StyleClasses="StatusFieldTitle" />
                 <Label Name="EtaLabel" Text="N/A" />
                 <!-- Charge -->
-                <Label Text="{Loc 'gravity-generator-window-charge'}" StyleClasses="StatusFieldTitle" />
+                <Label Text="{Loc 'power-charge-window-charge'}" StyleClasses="StatusFieldTitle" />
                 <ProgressBar Name="ChargeBar" MaxValue="255">
                     <Label Name="ChargeText" Margin="4 0" Text="0 %" />
                 </ProgressBar>
@@ -31,5 +30,4 @@
             <SpriteView Name="EntityView" SetSize="96 96" OverrideDirection="South" />
         </PanelContainer>
     </BoxContainer>
-
 </controls:FancyWindow>

Content.Client/Power/PowerCharge/PowerChargeWindow.xaml.cs

@@ -0,0 +1,72 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Power;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.Power.PowerCharge;
+
+[GenerateTypedNameReferences]
+public sealed partial class PowerChargeWindow : FancyWindow
+{
+    private readonly ButtonGroup _buttonGroup = new();
+
+    public PowerChargeWindow()
+    {
+        RobustXamlLoader.Load(this);
+
+        OnButton.Group = _buttonGroup;
+        OffButton.Group = _buttonGroup;
+    }
+
+    public void UpdateWindow(PowerChargeBoundUserInterface bui, string title)
+    {
+        Title = title;
+
+        OnButton.OnPressed += _ => bui.SetPowerSwitch(true);
+        OffButton.OnPressed += _ => bui.SetPowerSwitch(false);
+
+        EntityView.SetEntity(bui.Owner);
+    }
+
+    public void UpdateState(PowerChargeState state)
+    {
+        if (state.On)
+            OnButton.Pressed = true;
+        else
+            OffButton.Pressed = true;
+
+        PowerLabel.Text = Loc.GetString(
+            "power-charge-window-power-label",
+            ("draw", state.PowerDraw),
+            ("max", state.PowerDrawMax));
+
+        PowerLabel.SetOnlyStyleClass(MathHelper.CloseTo(state.PowerDraw, state.PowerDrawMax) ? "Good" : "Caution");
+
+        ChargeBar.Value = state.Charge;
+        ChargeText.Text = (state.Charge / 255f).ToString("P0");
+        StatusLabel.Text = Loc.GetString(state.PowerStatus switch
+        {
+            PowerChargePowerStatus.Off => "power-charge-window-status-off",
+            PowerChargePowerStatus.Discharging => "power-charge-window-status-discharging",
+            PowerChargePowerStatus.Charging => "power-charge-window-status-charging",
+            PowerChargePowerStatus.FullyCharged => "power-charge-window-status-fully-charged",
+            _ => throw new ArgumentOutOfRangeException()
+        });
+
+        StatusLabel.SetOnlyStyleClass(state.PowerStatus switch
+        {
+            PowerChargePowerStatus.Off => "Danger",
+            PowerChargePowerStatus.Discharging => "Caution",
+            PowerChargePowerStatus.Charging => "Caution",
+            PowerChargePowerStatus.FullyCharged => "Good",
+            _ => throw new ArgumentOutOfRangeException()
+        });
+
+        EtaLabel.Text = state.EtaSeconds >= 0
+            ? Loc.GetString("power-charge-window-eta-value", ("left", TimeSpan.FromSeconds(state.EtaSeconds)))
+            : Loc.GetString("power-charge-window-eta-none");
+
+        EtaLabel.SetOnlyStyleClass(state.EtaSeconds >= 0 ? "Caution" : "Disabled");
+    }
+}

Content.Client/Power/PowerMonitoringWindow.xaml.Widgets.cs

@@ -309,7 +309,7 @@ public sealed partial class PowerMonitoringWindow
                 BorderThickness = new Thickness(2),
             };
 
-            msg.AddMarkup(Loc.GetString("power-monitoring-window-rogue-power-consumer"));
+            msg.AddMarkupOrThrow(Loc.GetString("power-monitoring-window-rogue-power-consumer"));
             SystemWarningPanel.Visible = true;
         }
 
@@ -322,7 +322,7 @@ public sealed partial class PowerMonitoringWindow
                 BorderThickness = new Thickness(2),
             };
 
-            msg.AddMarkup(Loc.GetString("power-monitoring-window-power-net-abnormalities"));
+            msg.AddMarkupOrThrow(Loc.GetString("power-monitoring-window-power-net-abnormalities"));
             SystemWarningPanel.Visible = true;
         }
 

Content.Client/Radio/Ui/IntercomMenu.xaml.cs

@@ -1,3 +1,4 @@
+using System.Threading.Channels;
 using Content.Client.UserInterface.Controls;
 using Content.Shared.Radio.Components;
 using Robust.Client.AutoGenerated;

Content.Client/Replay/ContentReplayPlaybackManager.cs

@@ -1,10 +1,8 @@
-using System.IO.Compression;
 using Content.Client.Administration.Managers;
 using Content.Client.Launcher;
 using Content.Client.MainMenu;
 using Content.Client.Replay.Spectator;
 using Content.Client.Replay.UI.Loading;
-using Content.Client.Stylesheets;
 using Content.Client.UserInterface.Systems.Chat;
 using Content.Shared.Chat;
 using Content.Shared.Effects;
@@ -26,8 +24,6 @@ using Robust.Client.Replays.Playback;
 using Robust.Client.State;
 using Robust.Client.Timing;
 using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
@@ -60,7 +56,7 @@ public sealed class ContentReplayPlaybackManager
     public bool IsScreenshotMode = false;
 
     private bool _initialized;
-    
+
     /// <summary>
     /// Most recently loaded file, for re-attempting the load with error tolerance.
     /// Required because the zip reader auto-disposes and I'm too lazy to change it so that
@@ -96,32 +92,17 @@ public sealed class ContentReplayPlaybackManager
             return;
         }
 
-        ReturnToDefaultState();
+        if (_client.RunLevel == ClientRunLevel.SinglePlayerGame)
+            _client.StopSinglePlayer();
 
-        // Show a popup window with the error message
-        var text = Loc.GetString("replay-loading-failed", ("reason", exception));
-        var box = new BoxContainer
+        Action? retryAction = null;
+        Action? cancelAction = null;
+
+        if (!_cfg.GetCVar(CVars.ReplayIgnoreErrors) && LastLoad is { } last)
         {
-            Orientation = BoxContainer.LayoutOrientation.Vertical,
-            Children = {new Label {Text = text}}
-        };
-
-        var popup = new DefaultWindow { Title = "Error!" };
-        popup.Contents.AddChild(box);
-
-        // Add button for attempting to re-load the replay while ignoring some errors.
-        if (!_cfg.GetCVar(CVars.ReplayIgnoreErrors) && LastLoad is {} last)
-        {
-            var button = new Button
-            {
-                Text = Loc.GetString("replay-loading-retry"), 
-                StyleClasses = { StyleBase.ButtonCaution }
-            };
-            
-            button.OnPressed += _ =>
+            retryAction = () =>
             {
                 _cfg.SetCVar(CVars.ReplayIgnoreErrors, true);
-                popup.Dispose();
 
                 IReplayFileReader reader = last.Zip == null
                     ? new ReplayFileReaderResources(_resMan, last.Folder)
@@ -129,11 +110,20 @@ public sealed class ContentReplayPlaybackManager
 
                 _loadMan.LoadAndStartReplay(reader);
             };
-            
-            box.AddChild(button);
         }
 
-        popup.OpenCentered();
+        // If we have an explicit menu to get back to (e.g. replay browser UI), show a cancel button.
+        if (DefaultState != null)
+        {
+            cancelAction = () =>
+            {
+                _stateMan.RequestStateChange(DefaultState);
+            };
+        }
+
+        // Switch to a new game state to present the error and cancel/retry options.
+        var state = _stateMan.RequestStateChange<ReplayLoadingFailed>();
+        state.SetData(exception, cancelAction, retryAction);
     }
 
     public void ReturnToDefaultState()

Content.Client/Replay/UI/Loading/ReplayLoadingFailed.cs

@@ -0,0 +1,36 @@
+using Content.Client.Stylesheets;
+using Robust.Client.State;
+using Robust.Client.UserInterface;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Replay.UI.Loading;
+
+/// <summary>
+/// State used to display an error message if a replay failed to load.
+/// </summary>
+/// <seealso cref="ReplayLoadingFailedControl"/>
+/// <seealso cref="ContentReplayPlaybackManager"/>
+public sealed class ReplayLoadingFailed : State
+{
+    [Dependency] private readonly IStylesheetManager _stylesheetManager = default!;
+    [Dependency] private readonly IUserInterfaceManager _userInterface = default!;
+
+    private ReplayLoadingFailedControl? _control;
+
+    public void SetData(Exception exception, Action? cancelPressed, Action? retryPressed)
+    {
+        DebugTools.Assert(_control != null);
+        _control.SetData(exception, cancelPressed, retryPressed);
+    }
+
+    protected override void Startup()
+    {
+        _control = new ReplayLoadingFailedControl(_stylesheetManager);
+        _userInterface.StateRoot.AddChild(_control);
+    }
+
+    protected override void Shutdown()
+    {
+        _control?.Orphan();
+    }
+}

Content.Client/Replay/UI/Loading/ReplayLoadingFailedControl.xaml

@@ -0,0 +1,14 @@
+<Control xmlns="https://spacestation14.io"
+         xmlns:pllax="clr-namespace:Content.Client.Parallax">
+    <pllax:ParallaxControl />
+    <Control HorizontalAlignment="Center" VerticalAlignment="Center">
+        <PanelContainer StyleClasses="AngleRect" />
+        <BoxContainer Orientation="Vertical" SetSize="800 600" Margin="2">
+            <ScrollContainer Name="what" VerticalExpand="True" HScrollEnabled="False" Margin="0 0 0 2" ReturnMeasure="True">
+                <RichTextLabel Name="ReasonLabel" VerticalAlignment="Top" />
+            </ScrollContainer>
+            <Button Name="RetryButton" StyleClasses="Caution" Text="{Loc 'replay-loading-retry'}" Visible="False" />
+            <Button Name="CancelButton" Text="{Loc 'replay-loading-cancel'}" Visible="False" />
+        </BoxContainer>
+    </Control>
+</Control>

Content.Client/Replay/UI/Loading/ReplayLoadingFailedControl.xaml.cs

@@ -0,0 +1,44 @@
+using Content.Client.Stylesheets;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Replay.UI.Loading;
+
+[GenerateTypedNameReferences]
+public sealed partial class ReplayLoadingFailedControl : Control
+{
+    public ReplayLoadingFailedControl(IStylesheetManager stylesheet)
+    {
+        RobustXamlLoader.Load(this);
+
+        Stylesheet = stylesheet.SheetSpace;
+        LayoutContainer.SetAnchorPreset(this, LayoutContainer.LayoutPreset.Wide);
+    }
+
+    public void SetData(Exception exception, Action? cancelPressed, Action? retryPressed)
+    {
+        ReasonLabel.SetMessage(
+            FormattedMessage.FromUnformatted(Loc.GetString("replay-loading-failed", ("reason", exception))));
+
+        if (cancelPressed != null)
+        {
+            CancelButton.Visible = true;
+            CancelButton.OnPressed += _ =>
+            {
+                cancelPressed();
+            };
+        }
+
+        if (retryPressed != null)
+        {
+            RetryButton.Visible = true;
+            RetryButton.OnPressed += _ =>
+            {
+                retryPressed();
+            };
+        }
+    }
+}

Content.Client/Robotics/UI/RoboticsConsoleWindow.xaml.cs

@@ -128,12 +128,12 @@ public sealed partial class RoboticsConsoleWindow : FancyWindow
         };
 
         var text = new FormattedMessage();
-        text.PushMarkup(Loc.GetString("robotics-console-model", ("name", model)));
-        text.AddMarkup(Loc.GetString("robotics-console-designation"));
+        text.AddMarkupOrThrow($"{Loc.GetString("robotics-console-model", ("name", model))}\n");
+        text.AddMarkupOrThrow(Loc.GetString("robotics-console-designation"));
         text.AddText($" {data.Name}\n"); // prevent players trolling by naming borg [color=red]satan[/color]
-        text.PushMarkup(Loc.GetString("robotics-console-battery", ("charge", (int) (data.Charge * 100f)), ("color", batteryColor)));
-        text.PushMarkup(Loc.GetString("robotics-console-brain", ("brain", data.HasBrain)));
-        text.AddMarkup(Loc.GetString("robotics-console-modules", ("count", data.ModuleCount)));
+        text.AddMarkupOrThrow($"{Loc.GetString("robotics-console-battery", ("charge", (int)(data.Charge * 100f)), ("color", batteryColor))}\n");
+        text.AddMarkupOrThrow($"{Loc.GetString("robotics-console-brain", ("brain", data.HasBrain))}\n");
+        text.AddMarkupOrThrow(Loc.GetString("robotics-console-modules", ("count", data.ModuleCount)));
         BorgInfo.SetMessage(text);
 
         // how the turntables

Content.Client/Roles/RoleCodewordSystem.cs

@@ -0,0 +1,8 @@
+using Content.Shared.Roles.RoleCodeword;
+
+namespace Content.Client.Roles;
+
+public sealed class RoleCodewordSystem : SharedRoleCodewordSystem
+{
+
+}

Content.Client/RoundEnd/RoundEndSummaryWindow.cs

@@ -61,9 +61,9 @@ namespace Content.Client.RoundEnd
             //Gamemode Name
             var gamemodeLabel = new RichTextLabel();
             var gamemodeMessage = new FormattedMessage();
-            gamemodeMessage.AddMarkup(Loc.GetString("round-end-summary-window-round-id-label", ("roundId", roundId)));
+            gamemodeMessage.AddMarkupOrThrow(Loc.GetString("round-end-summary-window-round-id-label", ("roundId", roundId)));
             gamemodeMessage.AddText(" ");
-            gamemodeMessage.AddMarkup(Loc.GetString("round-end-summary-window-gamemode-name-label", ("gamemode", gamemode)));
+            gamemodeMessage.AddMarkupOrThrow(Loc.GetString("round-end-summary-window-gamemode-name-label", ("gamemode", gamemode)));
             gamemodeLabel.SetMessage(gamemodeMessage);
             roundEndSummaryContainer.AddChild(gamemodeLabel);