From 7f43f38cc71466983cbecc4fa14bc3580a0b6d35 Mon Sep 17 00:00:00 2001
From: Fishfish458 <47410468+Fishfish458@users.noreply.github.com>
Date: Mon, 7 Mar 2022 21:45:52 -0600
Subject: [PATCH] Add health analyzer and medical scanner ECS (#6907)

Co-authored-by: fishfish458 <fishfish458>
Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>
---
 Content.Client/Entry/IgnoredComponents.cs     |   1 +
 .../UI/HealthAnalyzerBoundUserInterface.cs    |  51 +++
 .../UI/HealthAnalyzerWindow.xaml              |   9 +
 .../UI/HealthAnalyzerWindow.xaml.cs           |  74 +++++
 .../MedicalScannerVisualizer.cs               |   8 +-
 .../UI/MedicalScannerBoundUserInterface.cs    |  13 +-
 .../UI/MedicalScannerWindow.xaml              |   9 +-
 .../UI/MedicalScannerWindow.xaml.cs           |  63 +---
 .../Components/HealthAnalyzerComponent.cs     |  27 ++
 .../Components/MedicalScannerComponent.cs     | 235 +-------------
 .../Medical/HealthAnalyzerSystem.cs           | 120 ++++++++
 .../Medical/MedicalScannerSystem.cs           | 290 ++++++++++++++++--
 .../SharedHealthAnalyzerComponent.cs          |  27 ++
 .../SharedMedicalScannerComponent.cs          |  40 +--
 .../components/health-analyzer-component.ftl  |   6 +
 .../components/medical-scanner-component.ftl  |   7 +-
 .../Catalog/Fills/Lockers/medical.yml         |  15 +-
 .../VendingMachines/Inventories/medical.yml   |   1 +
 .../Specific/Medical/healthanalyzer.yml       |  17 +
 .../Entities/Structures/Machines/lathe.yml    |   1 +
 .../Prototypes/Recipes/Lathes/medical.yml     |   9 +
 .../Medical/healthanalyzer.rsi/analyzer.png   | Bin 0 -> 1059 bytes
 .../Medical/healthanalyzer.rsi/icon.png       | Bin 0 -> 5806 bytes
 .../Medical/healthanalyzer.rsi/meta.json      |  33 ++
 24 files changed, 668 insertions(+), 388 deletions(-)
 create mode 100644 Content.Client/HealthAnalyzer/UI/HealthAnalyzerBoundUserInterface.cs
 create mode 100644 Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml
 create mode 100644 Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs
 create mode 100644 Content.Server/Medical/Components/HealthAnalyzerComponent.cs
 create mode 100644 Content.Server/Medical/HealthAnalyzerSystem.cs
 create mode 100644 Content.Shared/MedicalScanner/SharedHealthAnalyzerComponent.cs
 create mode 100644 Resources/Locale/en-US/medical/components/health-analyzer-component.ftl
 create mode 100644 Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml
 create mode 100644 Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/analyzer.png
 create mode 100644 Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/icon.png
 create mode 100644 Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/meta.json

diff --git a/Content.Client/Entry/IgnoredComponents.cs b/Content.Client/Entry/IgnoredComponents.cs
index fa31384c4a..3667507aa0 100644
--- a/Content.Client/Entry/IgnoredComponents.cs
+++ b/Content.Client/Entry/IgnoredComponents.cs
@@ -317,6 +317,7 @@ namespace Content.Client.Entry
             "EnergySword",
             "DoorRemote",
             "InteractionPopup",
+            "HealthAnalyzer"
         };
     }
 }
diff --git a/Content.Client/HealthAnalyzer/UI/HealthAnalyzerBoundUserInterface.cs b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerBoundUserInterface.cs
new file mode 100644
index 0000000000..c7bfffe41d
--- /dev/null
+++ b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerBoundUserInterface.cs
@@ -0,0 +1,51 @@
+using JetBrains.Annotations;
+using Robust.Client.GameObjects;
+
+using static Content.Shared.MedicalScanner.SharedHealthAnalyzerComponent;
+
+namespace Content.Client.HealthAnalyzer.UI
+{
+    [UsedImplicitly]
+    public sealed class HealthAnalyzerBoundUserInterface : BoundUserInterface
+    {
+        private HealthAnalyzerWindow? _window;
+
+        public HealthAnalyzerBoundUserInterface(ClientUserInterfaceComponent owner, object uiKey) : base(owner, uiKey)
+        {
+        }
+
+        protected override void Open()
+        {
+            base.Open();
+            _window = new HealthAnalyzerWindow
+            {
+                Title = IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner.Owner).EntityName,
+            };
+            _window.OnClose += Close;
+            _window.OpenCentered();
+        }
+
+        protected override void ReceiveMessage(BoundUserInterfaceMessage message)
+        {
+            if (_window == null)
+                return;
+
+            if (message is not HealthAnalyzerScannedUserMessage cast)
+                return;
+
+            _window.Populate(cast);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+            if (!disposing)
+                return;
+
+            if (_window != null)
+                _window.OnClose -= Close;
+
+            _window?.Dispose();
+        }
+    }
+}
diff --git a/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml
new file mode 100644
index 0000000000..1f64feec2b
--- /dev/null
+++ b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml
@@ -0,0 +1,9 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+            MinSize="250 100"
+            SetSize="250 100">
+    <BoxContainer Orientation="Vertical">
+        <Label
+            Name="Diagnostics"
+            Text="{Loc health-analyzer-window-no-patient-data-text}"/>
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs
new file mode 100644
index 0000000000..7d7bbc1232
--- /dev/null
+++ b/Content.Client/HealthAnalyzer/UI/HealthAnalyzerWindow.xaml.cs
@@ -0,0 +1,74 @@
+using System.Text;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Prototypes;
+using Content.Shared.Damage;
+
+using static Content.Shared.MedicalScanner.SharedHealthAnalyzerComponent;
+
+namespace Content.Client.HealthAnalyzer.UI
+{
+    [GenerateTypedNameReferences]
+    public sealed partial class HealthAnalyzerWindow : DefaultWindow
+    {
+        public HealthAnalyzerWindow()
+        {
+            RobustXamlLoader.Load(this);
+        }
+
+        public void Populate(HealthAnalyzerScannedUserMessage msg)
+        {
+            var text = new StringBuilder();
+            var entities = IoCManager.Resolve<IEntityManager>();
+
+            if (msg.TargetEntity != null && entities.TryGetComponent<DamageableComponent>(msg.TargetEntity, out var damageable))
+            {
+                string entityName = "Unknown";
+                if (msg.TargetEntity != null && entities.TryGetComponent<MetaDataComponent>(msg.TargetEntity.Value, out var metaData))
+                    entityName = metaData.EntityName;
+
+                IReadOnlyDictionary<string, FixedPoint2> DamagePerGroup = damageable.DamagePerGroup;
+                IReadOnlyDictionary<string, FixedPoint2> DamagePerType = damageable.Damage.DamageDict;
+
+                text.Append($"{Loc.GetString("health-analyzer-window-entity-health-text", ("entityName", entityName))}\n");
+
+                text.Append($"{Loc.GetString("health-analyzer-window-entity-damage-total-text", ("amount", damageable.TotalDamage))}\n");
+
+                HashSet<string> shownTypes = new();
+
+                var protos = IoCManager.Resolve<IPrototypeManager>();
+
+                // Show the total damage and type breakdown for each damage group.
+                foreach (var (damageGroupId, damageAmount) in DamagePerGroup)
+                {
+                    text.Append($"\n{Loc.GetString("health-analyzer-window-damage-group-text", ("damageGroup", damageGroupId), ("amount", damageAmount))}");
+                    // Show the damage for each type in that group.
+                    var group = protos.Index<DamageGroupPrototype>(damageGroupId);
+                    foreach (var type in group.DamageTypes)
+                    {
+                        if (DamagePerType.TryGetValue(type, out var typeAmount))
+                        {
+                            // 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))
+                            {
+                                shownTypes.Add(type);
+                                text.Append($"\n- {Loc.GetString("health-analyzer-window-damage-type-text", ("damageType", type), ("amount", typeAmount))}");
+                            }
+                        }
+                    }
+                    text.AppendLine();
+                }
+                Diagnostics.Text = text.ToString();
+                SetSize = (250, 600);
+            }
+            else
+            {
+                Diagnostics.Text = Loc.GetString("health-analyzer-window-no-patient-data-text");
+                SetSize = (250, 100);
+            }
+        }
+    }
+}
diff --git a/Content.Client/MedicalScanner/MedicalScannerVisualizer.cs b/Content.Client/MedicalScanner/MedicalScannerVisualizer.cs
index bb0f9e34f3..0e3d2bcf2f 100644
--- a/Content.Client/MedicalScanner/MedicalScannerVisualizer.cs
+++ b/Content.Client/MedicalScanner/MedicalScannerVisualizer.cs
@@ -27,10 +27,10 @@ namespace Content.Client.MedicalScanner
             {
                 case Off: return "closed";
                 case Open: return "open";
-                case Red: return "closed";
-                case Death: return "closed";
+                case Red: return "occupied";
+                case Death: return "occupied";
                 case Green: return "occupied";
-                case Yellow: return "closed";
+                case Yellow: return "occupied";
                 default:
                     throw new ArgumentOutOfRangeException(nameof(status), status, "unknown MedicalScannerStatus");
             }
@@ -43,7 +43,7 @@ namespace Content.Client.MedicalScanner
                 case Off: return "off_unlit";
                 case Open: return "idle_unlit";
                 case Red: return "red_unlit";
-                case Death: return "red_unlit";
+                case Death: return "off_unlit";
                 case Green: return "idle_unlit";
                 case Yellow: return "maint_unlit";
                 default:
diff --git a/Content.Client/MedicalScanner/UI/MedicalScannerBoundUserInterface.cs b/Content.Client/MedicalScanner/UI/MedicalScannerBoundUserInterface.cs
index 3807a9b9ac..175ece10d5 100644
--- a/Content.Client/MedicalScanner/UI/MedicalScannerBoundUserInterface.cs
+++ b/Content.Client/MedicalScanner/UI/MedicalScannerBoundUserInterface.cs
@@ -1,7 +1,6 @@
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
+
 using static Content.Shared.MedicalScanner.SharedMedicalScannerComponent;
 
 namespace Content.Client.MedicalScanner.UI
@@ -23,7 +22,7 @@ namespace Content.Client.MedicalScanner.UI
                 Title = IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner.Owner).EntityName,
             };
             _window.OnClose += Close;
-            _window.ScanButton.OnPressed += _ => SendMessage(new UiButtonPressedMessage(UiButton.ScanDNA));
+            _window.ScanButton.OnPressed += _ => SendMessage(new ScanButtonPressedMessage());
             _window.OpenCentered();
         }
 
@@ -31,7 +30,10 @@ namespace Content.Client.MedicalScanner.UI
         {
             base.UpdateState(state);
 
-            _window?.Populate((MedicalScannerBoundUserInterfaceState) state);
+            if (state is not MedicalScannerBoundUserInterfaceState cast)
+                return;
+
+            _window?.Populate(cast);
         }
 
         protected override void Dispose(bool disposing)
@@ -40,6 +42,9 @@ namespace Content.Client.MedicalScanner.UI
             if (!disposing)
                 return;
 
+            if (_window != null)
+                _window.OnClose -= Close;
+
             _window?.Dispose();
         }
     }
diff --git a/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml b/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml
index 54f33aa0f7..90bc8f8595 100644
--- a/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml
+++ b/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml
@@ -1,10 +1,11 @@
 <DefaultWindow xmlns="https://spacestation14.io"
-            MinSize="250 100"
-            SetSize="250 100">
+            MinSize="200 100"
+        SetSize="200 100">
     <BoxContainer Orientation="Vertical">
+        <Label Name="OccupantName"/>
         <Button Name="ScanButton"
+                Disabled="True"
                 Access="Public"
                 Text="{Loc 'medical-scanner-window-save-button-text'}" />
-        <Label Name="Diagnostics" />
-    </BoxContainer>
+</BoxContainer>
 </DefaultWindow>
diff --git a/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml.cs b/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml.cs
index fbfc603bc3..6b14916f16 100644
--- a/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml.cs
+++ b/Content.Client/MedicalScanner/UI/MedicalScannerWindow.xaml.cs
@@ -1,14 +1,7 @@
-using System.Collections.Generic;
-using System.Text;
-using Content.Shared.Damage.Prototypes;
-using Content.Shared.FixedPoint;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Prototypes;
+
 using static Content.Shared.MedicalScanner.SharedMedicalScannerComponent;
 
 namespace Content.Client.MedicalScanner.UI
@@ -23,59 +16,7 @@ namespace Content.Client.MedicalScanner.UI
 
         public void Populate(MedicalScannerBoundUserInterfaceState state)
         {
-            var text = new StringBuilder();
-
-            var entities = IoCManager.Resolve<IEntityManager>();
-            if (!state.Entity.HasValue ||
-                !state.HasDamage() ||
-                !entities.EntityExists(state.Entity.Value))
-            {
-                Diagnostics.Text = Loc.GetString("medical-scanner-window-no-patient-data-text");
-                ScanButton.Disabled = true;
-                SetSize = (250, 100);
-            }
-            else
-            {
-                text.Append($"{Loc.GetString("medical-scanner-window-entity-health-text", ("entityName", entities.GetComponent<MetaDataComponent>(state.Entity.Value).EntityName))}\n");
-
-                var totalDamage = state.DamagePerType.Values.Sum();
-
-                text.Append($"{Loc.GetString("medical-scanner-window-entity-damage-total-text", ("amount", totalDamage))}\n");
-
-                HashSet<string> shownTypes = new();
-
-                // Show the total damage and type breakdown for each damage group.
-                foreach (var (damageGroupId, damageAmount) in state.DamagePerGroup)
-                {
-                    text.Append($"\n{Loc.GetString("medical-scanner-window-damage-group-text", ("damageGroup", damageGroupId), ("amount", damageAmount))}");
-
-                    // Show the damage for each type in that group.
-                    var group = IoCManager.Resolve<IPrototypeManager>().Index<DamageGroupPrototype>(damageGroupId);
-                    foreach (var type in group.DamageTypes)
-                    {
-                        if (state.DamagePerType.TryGetValue(type, out var typeAmount))
-                        {
-                            // 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))
-                            {
-                                shownTypes.Add(type);
-                                text.Append($"\n- {Loc.GetString("medical-scanner-window-damage-type-text", ("damageType", type), ("amount", typeAmount))}");
-                            }
-                            else {
-                                text.Append($"\n- {Loc.GetString("medical-scanner-window-damage-type-duplicate-text", ("damageType", type), ("amount", typeAmount))}");
-                            }
-                        }
-                    }
-                    text.Append('\n');
-                }
-
-                Diagnostics.Text = text.ToString();
-                ScanButton.Disabled = state.IsScanned;
-
-                // TODO MEDICALSCANNER resize window based on the length of text / number of damage types?
-                // Also, maybe add color schemes for specific damage groups?
-                SetSize = (250, 600);
-            }
+            ScanButton.Disabled = !state.IsScannable;
         }
     }
 }
diff --git a/Content.Server/Medical/Components/HealthAnalyzerComponent.cs b/Content.Server/Medical/Components/HealthAnalyzerComponent.cs
new file mode 100644
index 0000000000..b7ba852605
--- /dev/null
+++ b/Content.Server/Medical/Components/HealthAnalyzerComponent.cs
@@ -0,0 +1,27 @@
+using System.Threading;
+using Content.Server.UserInterface;
+using Content.Shared.MedicalScanner;
+using Robust.Server.GameObjects;
+
+namespace Content.Server.Medical.Components
+{
+    /// <summary>
+    ///    After scanning, retrieves the target Uid to use with its related UI.
+    /// </summary>
+    [RegisterComponent]
+    [ComponentReference(typeof(SharedHealthAnalyzerComponent))]
+    public sealed class HealthAnalyzerComponent : SharedHealthAnalyzerComponent
+    {
+        /// <summary>
+        /// How long it takes to scan someone.
+        /// </summary>
+        [DataField("scanDelay")]
+        [ViewVariables]
+        public float ScanDelay = 0.8f;
+        /// <summary>
+        ///     Token for interrupting scanning do after.
+        /// </summary>
+        public CancellationTokenSource? CancelToken;
+        public BoundUserInterface? UserInterface => Owner.GetUIOrNull(HealthAnalyzerUiKey.Key);
+    }
+}
diff --git a/Content.Server/Medical/Components/MedicalScannerComponent.cs b/Content.Server/Medical/Components/MedicalScannerComponent.cs
index 0b8d0f72ac..20fe2df16b 100644
--- a/Content.Server/Medical/Components/MedicalScannerComponent.cs
+++ b/Content.Server/Medical/Components/MedicalScannerComponent.cs
@@ -1,249 +1,22 @@
-using System;
-using Content.Server.Climbing;
-using Content.Server.Cloning;
-using Content.Server.Mind.Components;
-using Content.Server.Power.Components;
-using Content.Server.Preferences.Managers;
 using Content.Server.UserInterface;
-using Content.Shared.Acts;
-using Content.Shared.Damage;
 using Content.Shared.DragDrop;
-using Content.Shared.Interaction;
 using Content.Shared.MedicalScanner;
-using Content.Shared.MobState.Components;
-using Content.Shared.Popups;
-using Content.Shared.Preferences;
 using Robust.Server.GameObjects;
 using Robust.Shared.Containers;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Network;
-using Robust.Shared.ViewVariables;
 
 namespace Content.Server.Medical.Components
 {
     [RegisterComponent]
-    [ComponentReference(typeof(IActivate))]
     [ComponentReference(typeof(SharedMedicalScannerComponent))]
-    public sealed class MedicalScannerComponent : SharedMedicalScannerComponent, IActivate, IDestroyAct
+    public sealed class MedicalScannerComponent : SharedMedicalScannerComponent
     {
-        [Dependency] private readonly IEntityManager _entMan = default!;
-        [Dependency] private readonly IServerPreferencesManager _prefsManager = null!;
-
-        public static readonly TimeSpan InternalOpenAttemptDelay = TimeSpan.FromSeconds(0.5);
-        public TimeSpan LastInternalOpenAttempt;
-
-        private ContainerSlot _bodyContainer = default!;
-
-        [ViewVariables]
-        private bool Powered => !_entMan.TryGetComponent(Owner, out ApcPowerReceiverComponent? receiver) || receiver.Powered;
-        [ViewVariables]
-        private BoundUserInterface? UserInterface => Owner.GetUIOrNull(MedicalScannerUiKey.Key);
-
-        public bool IsOccupied => _bodyContainer.ContainedEntity != null;
-
-        protected override void Initialize()
-        {
-            base.Initialize();
-
-            if (UserInterface != null)
-            {
-                UserInterface.OnReceiveMessage += OnUiReceiveMessage;
-            }
-
-            _bodyContainer = ContainerHelpers.EnsureContainer<ContainerSlot>(Owner, $"{Name}-bodyContainer");
-
-            // TODO: write this so that it checks for a change in power events and acts accordingly.
-            var newState = GetUserInterfaceState();
-            UserInterface?.SetState(newState);
-
-            UpdateUserInterface();
-        }
-
-        private static readonly MedicalScannerBoundUserInterfaceState EmptyUIState =
-            new(
-                null,
-                null,
-                false);
-
-        private MedicalScannerBoundUserInterfaceState GetUserInterfaceState()
-        {
-            var body = _bodyContainer.ContainedEntity;
-            if (body == null)
-            {
-                if (_entMan.TryGetComponent(Owner, out AppearanceComponent? appearance))
-                {
-                    appearance?.SetData(MedicalScannerVisuals.Status, MedicalScannerStatus.Open);
-                }
-
-                return EmptyUIState;
-            }
-
-            if (!_entMan.TryGetComponent(body.Value, out DamageableComponent? damageable))
-            {
-                return EmptyUIState;
-            }
-
-            if (_bodyContainer.ContainedEntity == null)
-            {
-                return new MedicalScannerBoundUserInterfaceState(body, damageable, true);
-            }
-
-            var cloningSystem = EntitySystem.Get<CloningSystem>();
-            var scanned = _entMan.TryGetComponent(_bodyContainer.ContainedEntity.Value, out MindComponent? mindComponent) &&
-                         mindComponent.Mind != null &&
-                         cloningSystem.HasDnaScan(mindComponent.Mind);
-
-            return new MedicalScannerBoundUserInterfaceState(body, damageable, scanned);
-        }
-
-        private void UpdateUserInterface()
-        {
-            if (!Powered)
-            {
-                return;
-            }
-
-            var newState = GetUserInterfaceState();
-            UserInterface?.SetState(newState);
-        }
-
-        private MedicalScannerStatus GetStatusFromDamageState(MobStateComponent state)
-        {
-            if (state.IsAlive())
-            {
-                return MedicalScannerStatus.Green;
-            }
-            else if (state.IsCritical())
-            {
-                return MedicalScannerStatus.Red;
-            }
-            else if (state.IsDead())
-            {
-                return MedicalScannerStatus.Death;
-            }
-            else
-            {
-                return MedicalScannerStatus.Yellow;
-            }
-        }
-
-        private MedicalScannerStatus GetStatus()
-        {
-            if (Powered)
-            {
-                var body = _bodyContainer.ContainedEntity;
-                if (body == null)
-                    return MedicalScannerStatus.Open;
-
-                var state = _entMan.GetComponentOrNull<MobStateComponent>(body.Value);
-
-                return state == null ? MedicalScannerStatus.Open : GetStatusFromDamageState(state);
-            }
-
-            return MedicalScannerStatus.Off;
-        }
-
-        private void UpdateAppearance()
-        {
-            if (_entMan.TryGetComponent(Owner, out AppearanceComponent? appearance))
-            {
-                appearance.SetData(MedicalScannerVisuals.Status, GetStatus());
-            }
-        }
-
-        void IActivate.Activate(ActivateEventArgs args)
-        {
-            if (!_entMan.TryGetComponent(args.User, out ActorComponent? actor))
-            {
-                return;
-            }
-
-            if (!Powered)
-                return;
-
-            UserInterface?.Open(actor.PlayerSession);
-        }
-
-        public void InsertBody(EntityUid user)
-        {
-            _bodyContainer.Insert(user);
-            UpdateUserInterface();
-            UpdateAppearance();
-        }
-
-        public void EjectBody()
-        {
-            if (_bodyContainer.ContainedEntity is not {Valid: true} contained) return;
-            _bodyContainer.Remove(contained);
-            UpdateUserInterface();
-            UpdateAppearance();
-            EntitySystem.Get<ClimbSystem>().ForciblySetClimbing(contained);
-        }
-
-        public void Update(float frameTime)
-        {
-            UpdateUserInterface();
-            UpdateAppearance();
-        }
-
-        private void OnUiReceiveMessage(ServerBoundUserInterfaceMessage obj)
-        {
-            if (obj.Message is not UiButtonPressedMessage message || obj.Session.AttachedEntity == null) return;
-
-            switch (message.Button)
-            {
-                case UiButton.ScanDNA:
-                    if (_bodyContainer.ContainedEntity != null)
-                    {
-                        var cloningSystem = EntitySystem.Get<CloningSystem>();
-
-                        if (!_entMan.TryGetComponent(_bodyContainer.ContainedEntity.Value, out MindComponent? mindComp) || mindComp.Mind == null)
-                        {
-                            obj.Session.AttachedEntity.Value.PopupMessageCursor(Loc.GetString("medical-scanner-component-msg-no-soul"));
-                            break;
-                        }
-
-                        // Null suppression based on above check. Yes, it's explicitly needed
-                        var mind = mindComp.Mind!;
-
-                        // We need the HumanoidCharacterProfile
-                        // TODO: Move this further 'outwards' into a DNAComponent or somesuch.
-                        // Ideally this ends with GameTicker & CloningSystem handing DNA to a function that sets up a body for that DNA.
-                        var mindUser = mind.UserId;
-
-                        if (mindUser.HasValue == false || mind.Session == null)
-                        {
-                            // For now assume this means soul departed
-                            obj.Session.AttachedEntity.Value.PopupMessageCursor(Loc.GetString("medical-scanner-component-msg-soul-broken"));
-                            break;
-                        }
-
-                        var profile = GetPlayerProfileAsync(mindUser.Value);
-                        cloningSystem.AddToDnaScans(new ClonerDNAEntry(mind, profile));
-                    }
-
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
+        public ContainerSlot BodyContainer = default!;
+        public BoundUserInterface? UserInterface => Owner.GetUIOrNull(MedicalScannerUiKey.Key);
 
+        // ECS this out!, when DragDropSystem and InteractionSystem refactored
         public override bool DragDropOn(DragDropEvent eventArgs)
         {
-            _bodyContainer.Insert(eventArgs.Dragged);
             return true;
         }
-
-        void IDestroyAct.OnDestroy(DestructionEventArgs eventArgs)
-        {
-            EjectBody();
-        }
-
-        private HumanoidCharacterProfile GetPlayerProfileAsync(NetUserId userId)
-        {
-            return (HumanoidCharacterProfile) _prefsManager.GetPreferences(userId).SelectedCharacter;
-        }
     }
 }
diff --git a/Content.Server/Medical/HealthAnalyzerSystem.cs b/Content.Server/Medical/HealthAnalyzerSystem.cs
new file mode 100644
index 0000000000..1c68f48deb
--- /dev/null
+++ b/Content.Server/Medical/HealthAnalyzerSystem.cs
@@ -0,0 +1,120 @@
+using System.Threading;
+using Content.Server.DoAfter;
+using Content.Server.Medical.Components;
+using Content.Shared.Damage;
+using Content.Shared.Interaction;
+using Content.Shared.MobState.Components;
+using Robust.Server.GameObjects;
+using static Content.Shared.MedicalScanner.SharedHealthAnalyzerComponent;
+
+namespace Content.Server.Medical
+{
+    public sealed class HealthAnalyzerSystem : EntitySystem
+    {
+        [Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<HealthAnalyzerComponent, ActivateInWorldEvent>(HandleActivateInWorld);
+            SubscribeLocalEvent<HealthAnalyzerComponent, AfterInteractEvent>(OnAfterInteract);
+            SubscribeLocalEvent<TargetScanSuccessfulEvent>(OnTargetScanSuccessful);
+            SubscribeLocalEvent<ScanCancelledEvent>(OnScanCancelled);
+        }
+
+        private void HandleActivateInWorld(EntityUid uid, HealthAnalyzerComponent healthAnalyzer, ActivateInWorldEvent args)
+        {
+            OpenUserInterface(args.User, healthAnalyzer);
+        }
+
+        private void OnAfterInteract(EntityUid uid, HealthAnalyzerComponent healthAnalyzer, AfterInteractEvent args)
+        {
+            if (healthAnalyzer.CancelToken != null)
+            {
+                healthAnalyzer.CancelToken.Cancel();
+                healthAnalyzer.CancelToken = null;
+                return;
+            }
+
+            if (args.Target == null)
+                return;
+
+            if (!args.CanReach)
+                return;
+
+            if (healthAnalyzer.CancelToken != null)
+                return;
+
+            if (!HasComp<MobStateComponent>(args.Target))
+                return;
+
+            healthAnalyzer.CancelToken = new CancellationTokenSource();
+            _doAfterSystem.DoAfter(new DoAfterEventArgs(args.User, healthAnalyzer.ScanDelay, healthAnalyzer.CancelToken.Token, target: args.Target)
+            {
+                BroadcastFinishedEvent = new TargetScanSuccessfulEvent(args.User, args.Target, healthAnalyzer),
+                BroadcastCancelledEvent = new ScanCancelledEvent(healthAnalyzer),
+                BreakOnTargetMove = true,
+                BreakOnUserMove = true,
+                BreakOnStun = true,
+                NeedHand = true
+            });
+        }
+
+        private void OnTargetScanSuccessful(TargetScanSuccessfulEvent args)
+        {
+            args.Component.CancelToken = null;
+            UpdateScannedUser(args.Component.Owner, args.User, args.Target, args.Component);
+        }
+
+        private void OpenUserInterface(EntityUid user, HealthAnalyzerComponent healthAnalyzer)
+        {
+            if (!TryComp<ActorComponent>(user, out var actor))
+                return;
+
+            healthAnalyzer.UserInterface?.Open(actor.PlayerSession);
+        }
+
+        public void UpdateScannedUser(EntityUid uid, EntityUid user, EntityUid? target, HealthAnalyzerComponent? healthAnalyzer)
+        {
+            if (!Resolve(uid, ref healthAnalyzer))
+                return;
+
+            if (target == null || healthAnalyzer.UserInterface == null)
+                return;
+
+            if (!HasComp<DamageableComponent>(target))
+                return;
+
+            OpenUserInterface(user, healthAnalyzer);
+            healthAnalyzer.UserInterface?.SendMessage(new HealthAnalyzerScannedUserMessage(target));
+        }
+
+        private static void OnScanCancelled(ScanCancelledEvent args)
+        {
+            args.HealthAnalyzer.CancelToken = null;
+        }
+
+        private sealed class ScanCancelledEvent : EntityEventArgs
+        {
+            public readonly HealthAnalyzerComponent HealthAnalyzer;
+            public ScanCancelledEvent(HealthAnalyzerComponent healthAnalyzer)
+            {
+                HealthAnalyzer = healthAnalyzer;
+            }
+        }
+
+        private sealed class TargetScanSuccessfulEvent : EntityEventArgs
+        {
+            public EntityUid User { get; }
+            public EntityUid? Target { get; }
+            public HealthAnalyzerComponent Component { get; }
+
+            public TargetScanSuccessfulEvent(EntityUid user, EntityUid? target, HealthAnalyzerComponent component)
+            {
+                User = user;
+                Target = target;
+                Component = component;
+            }
+        }
+    }
+}
diff --git a/Content.Server/Medical/MedicalScannerSystem.cs b/Content.Server/Medical/MedicalScannerSystem.cs
index 0e8d22cc10..e3d0a981f5 100644
--- a/Content.Server/Medical/MedicalScannerSystem.cs
+++ b/Content.Server/Medical/MedicalScannerSystem.cs
@@ -1,29 +1,77 @@
+using Content.Server.Climbing;
+using Content.Server.Cloning;
 using Content.Server.Medical.Components;
+using Content.Server.Mind.Components;
+using Content.Server.Popups;
+using Content.Server.Power.Components;
+using Content.Server.Preferences.Managers;
 using Content.Shared.ActionBlocker;
+using Content.Shared.Acts;
+using Content.Shared.CharacterAppearance.Components;
+using Content.Shared.Damage;
+using Content.Shared.DragDrop;
+using Content.Shared.Interaction;
+using Content.Shared.MobState.Components;
 using Content.Shared.Movement;
+using Content.Shared.Preferences;
 using Content.Shared.Verbs;
 using JetBrains.Annotations;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Timing;
+using Robust.Server.GameObjects;
+using Robust.Shared.Containers;
+using Robust.Shared.Network;
+using Robust.Shared.Player;
+using static Content.Shared.MedicalScanner.SharedMedicalScannerComponent;
 
 namespace Content.Server.Medical
 {
-    [UsedImplicitly]
-    internal sealed class MedicalScannerSystem : EntitySystem
+    public sealed class MedicalScannerSystem : EntitySystem
     {
-        [Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
-        [Dependency] private readonly IGameTiming _gameTiming = default!;
+        [Dependency] private readonly IServerPreferencesManager _prefsManager = null!;
         [Dependency] private readonly ActionBlockerSystem _blocker = default!;
+        [Dependency] private readonly ClimbSystem _climbSystem = default!;
+        [Dependency] private readonly CloningSystem _cloningSystem = default!;
+        [Dependency] private readonly PopupSystem _popupSystem = default!;
+
+        private const float UpdateRate = 1f;
+        private float _updateDif;
 
         public override void Initialize()
         {
             base.Initialize();
 
+            SubscribeLocalEvent<MedicalScannerComponent, ComponentInit>(OnComponentInit);
+            SubscribeLocalEvent<MedicalScannerComponent, ActivateInWorldEvent>(OnActivated);
             SubscribeLocalEvent<MedicalScannerComponent, RelayMovementEntityEvent>(OnRelayMovement);
             SubscribeLocalEvent<MedicalScannerComponent, GetVerbsEvent<InteractionVerb>>(AddInsertOtherVerb);
             SubscribeLocalEvent<MedicalScannerComponent, GetVerbsEvent<AlternativeVerb>>(AddAlternativeVerbs);
+            SubscribeLocalEvent<MedicalScannerComponent, DestructionEventArgs>(OnDestroyed);
+            SubscribeLocalEvent<MedicalScannerComponent, DragDropEvent>(HandleDragDropOn);
+            SubscribeLocalEvent<MedicalScannerComponent, ScanButtonPressedMessage>(OnScanButtonPressed);
+        }
+
+        private void OnComponentInit(EntityUid uid, MedicalScannerComponent scannerComponent, ComponentInit args)
+        {
+            base.Initialize();
+
+            scannerComponent.BodyContainer = scannerComponent.Owner.EnsureContainer<ContainerSlot>($"{scannerComponent.Name}-bodyContainer");
+            UpdateUserInterface(uid, scannerComponent);
+        }
+
+        private void OnActivated(EntityUid uid, MedicalScannerComponent scannerComponent, ActivateInWorldEvent args)
+        {
+            if (!TryComp<ActorComponent>(args.User, out var actor) || !IsPowered(scannerComponent))
+                return;
+
+            scannerComponent.UserInterface?.Toggle(actor.PlayerSession);
+            UpdateUserInterface(uid, scannerComponent);
+        }
+
+        private void OnRelayMovement(EntityUid uid, MedicalScannerComponent scannerComponent, RelayMovementEntityEvent args)
+        {
+            if (!_blocker.CanInteract(args.Entity, scannerComponent.Owner))
+                return;
+
+            EjectBody(uid, scannerComponent);
         }
 
         private void AddInsertOtherVerb(EntityUid uid, MedicalScannerComponent component, GetVerbsEvent<InteractionVerb> args)
@@ -31,14 +79,20 @@ namespace Content.Server.Medical
             if (args.Using == null ||
                 !args.CanAccess ||
                 !args.CanInteract ||
-                component.IsOccupied ||
+                IsOccupied(component) ||
                 !component.CanInsert(args.Using.Value))
                 return;
 
-            InteractionVerb verb = new();
-            verb.Act = () => component.InsertBody(args.Using.Value);
-            verb.Category = VerbCategory.Insert;
-            verb.Text = EntityManager.GetComponent<MetaDataComponent>(args.Using.Value).EntityName;
+            string name = "Unknown";
+            if (TryComp<MetaDataComponent>(args.Using.Value, out var metadata))
+                name = metadata.EntityName;
+
+            InteractionVerb verb = new()
+            {
+                Act = () => InsertBody(component.Owner, args.Target, component),
+                Category = VerbCategory.Insert,
+                Text = name
+            };
             args.Verbs.Add(verb);
         }
 
@@ -48,52 +102,226 @@ namespace Content.Server.Medical
                 return;
 
             // Eject verb
-            if (component.IsOccupied)
+            if (IsOccupied(component))
             {
                 AlternativeVerb verb = new();
-                verb.Act = () => component.EjectBody();
+                verb.Act = () => EjectBody(uid, component);
                 verb.Category = VerbCategory.Eject;
                 verb.Text = Loc.GetString("medical-scanner-verb-noun-occupant");
                 args.Verbs.Add(verb);
             }
 
             // Self-insert verb
-            if (!component.IsOccupied &&
+            if (!IsOccupied(component) &&
                 component.CanInsert(args.User) &&
-                _actionBlockerSystem.CanMove(args.User))
+                _blocker.CanMove(args.User))
             {
                 AlternativeVerb verb = new();
-                verb.Act = () => component.InsertBody(args.User);
+                verb.Act = () => InsertBody(component.Owner, args.User, component);
                 verb.Text = Loc.GetString("medical-scanner-verb-enter");
-                // TODO VERN ICON
-                // TODO VERB CATEGORY
-                // create a verb category for "enter"?
-                // See also, disposal unit.  Also maybe add verbs for entering lockers/body bags?
                 args.Verbs.Add(verb);
             }
         }
 
-        private void OnRelayMovement(EntityUid uid, MedicalScannerComponent component, RelayMovementEntityEvent args)
+        private void OnDestroyed(EntityUid uid, MedicalScannerComponent scannerComponent, DestructionEventArgs args)
         {
-            if (_blocker.CanInteract(args.Entity, null))
+            EjectBody(uid, scannerComponent);
+        }
+
+        private void HandleDragDropOn(EntityUid uid, MedicalScannerComponent scannerComponent, DragDropEvent args)
+        {
+            InsertBody(uid, args.Dragged, scannerComponent);
+        }
+
+        private void OnScanButtonPressed(EntityUid uid, MedicalScannerComponent scannerComponent, ScanButtonPressedMessage args)
+        {
+            TrySaveCloningData(uid, scannerComponent);
+        }
+
+        private static readonly MedicalScannerBoundUserInterfaceState EmptyUIState =
+            new(false);
+
+        private MedicalScannerBoundUserInterfaceState GetUserInterfaceState(EntityUid uid,  MedicalScannerComponent scannerComponent)
+        {
+            EntityUid? containedBody = scannerComponent.BodyContainer.ContainedEntity;
+
+            if (containedBody == null)
             {
-                if (_gameTiming.CurTime <
-                    component.LastInternalOpenAttempt + MedicalScannerComponent.InternalOpenAttemptDelay)
+                UpdateAppearance(uid, scannerComponent);
+                return EmptyUIState;
+            }
+
+            if (!HasComp<DamageableComponent>(containedBody))
+                return EmptyUIState;
+
+            if (!HasComp<HumanoidAppearanceComponent>(containedBody))
+                return EmptyUIState;
+
+            if (!TryComp<MindComponent>(containedBody, out var mindComponent) || mindComponent.Mind == null)
+                return EmptyUIState;
+
+            bool isScanned = _cloningSystem.HasDnaScan(mindComponent.Mind);
+
+            return new MedicalScannerBoundUserInterfaceState(!isScanned);
+        }
+
+        private void UpdateUserInterface(EntityUid uid, MedicalScannerComponent scannerComponent)
+        {
+            if (!IsPowered(scannerComponent))
+            {
+                return;
+            }
+
+            var newState = GetUserInterfaceState(uid, scannerComponent);
+            scannerComponent.UserInterface?.SetState(newState);
+        }
+
+        private MedicalScannerStatus GetStatus(MedicalScannerComponent scannerComponent)
+        {
+            if (IsPowered(scannerComponent))
+            {
+                var body = scannerComponent.BodyContainer.ContainedEntity;
+                if (body == null)
+                    return MedicalScannerStatus.Open;
+
+                if (!TryComp<MobStateComponent>(body.Value, out var state))
                 {
-                    return;
+                    return MedicalScannerStatus.Open;
                 }
 
-                component.LastInternalOpenAttempt = _gameTiming.CurTime;
-                component.EjectBody();
+                return GetStatusFromDamageState(state);
+            }
+            return MedicalScannerStatus.Off;
+        }
+
+        public bool IsPowered(MedicalScannerComponent scannerComponent)
+        {
+            if (TryComp<ApcPowerReceiverComponent>(scannerComponent.Owner, out var receiver))
+            {
+                return receiver.Powered;
+            }
+            return false;
+        }
+
+        public bool IsOccupied(MedicalScannerComponent scannerComponent)
+        {
+            return scannerComponent.BodyContainer.ContainedEntity != null;
+        }
+
+        private MedicalScannerStatus GetStatusFromDamageState(MobStateComponent state)
+        {
+            if (state.IsAlive())
+                return MedicalScannerStatus.Green;
+
+            if (state.IsCritical())
+                return MedicalScannerStatus.Red;
+
+            if (state.IsDead())
+                return MedicalScannerStatus.Death;
+
+            return MedicalScannerStatus.Yellow;
+        }
+
+        private void UpdateAppearance(EntityUid uid, MedicalScannerComponent scannerComponent)
+        {
+            if (TryComp<AppearanceComponent>(scannerComponent.Owner, out var appearance))
+            {
+                appearance.SetData(MedicalScannerVisuals.Status, GetStatus(scannerComponent));
             }
         }
 
         public override void Update(float frameTime)
         {
-            foreach (var comp in EntityManager.EntityQuery<MedicalScannerComponent>())
+            base.Update(frameTime);
+
+            _updateDif += frameTime;
+            if (_updateDif < UpdateRate)
+                return;
+
+            _updateDif -= UpdateRate;
+
+            foreach (var scanner in EntityQuery<MedicalScannerComponent>())
             {
-                comp.Update(frameTime);
+                UpdateAppearance(scanner.Owner, scanner);
             }
         }
+
+        public void InsertBody(EntityUid uid, EntityUid user, MedicalScannerComponent? scannerComponent)
+        {
+            if (!Resolve(uid, ref scannerComponent))
+                return;
+
+            if (scannerComponent.BodyContainer.ContainedEntity != null)
+                return;
+
+            if (!TryComp<MobStateComponent>(user, out var comp))
+                return;
+
+            scannerComponent.BodyContainer.Insert(user);
+            UpdateUserInterface(uid, scannerComponent);
+            UpdateAppearance(scannerComponent.Owner, scannerComponent);
+        }
+
+        public void EjectBody(EntityUid uid, MedicalScannerComponent? scannerComponent)
+        {
+            if (!Resolve(uid, ref scannerComponent))
+                return;
+
+            if (scannerComponent.BodyContainer.ContainedEntity is not {Valid: true} contained) return;
+
+            scannerComponent.BodyContainer.Remove(contained);
+            _climbSystem.ForciblySetClimbing(contained);
+            UpdateUserInterface(uid, scannerComponent);
+            UpdateAppearance(scannerComponent.Owner, scannerComponent);
+        }
+
+        public void TrySaveCloningData(EntityUid uid, MedicalScannerComponent? scannerComponent)
+        {
+            if (!Resolve(uid, ref scannerComponent))
+                return;
+
+            EntityUid? body = scannerComponent.BodyContainer.ContainedEntity;
+
+            if (body == null)
+                return;
+
+            // Check to see if they are humanoid
+            if (!TryComp<HumanoidAppearanceComponent>(body, out var humanoid))
+            {
+                _popupSystem.PopupEntity(Loc.GetString("medical-scanner-component-msg-no-humanoid-component"), uid, Filter.Pvs(uid));
+                return;
+            }
+
+            if (!TryComp<MindComponent>(body, out var mindComp) || mindComp.Mind == null)
+            {
+                _popupSystem.PopupEntity(Loc.GetString("medical-scanner-component-msg-no-soul"), uid, Filter.Pvs(uid));
+                return;
+            }
+
+            // Null suppression based on above check. Yes, it's explicitly needed
+            var mind = mindComp.Mind;
+            // We need the HumanoidCharacterProfile
+            // TODO: Move this further 'outwards' into a DNAComponent or somesuch.
+            // Ideally this ends with GameTicker & CloningSystem handing DNA to a function that sets up a body for that DNA.
+            var mindUser = mind.UserId;
+
+            if (mindUser.HasValue == false || mind.Session == null)
+            {
+                // For now assume this means soul departed
+                _popupSystem.PopupEntity(Loc.GetString("medical-scanner-component-msg-soul-broken"), uid, Filter.Pvs(uid));
+                return;
+            }
+
+             // TODO get synchronously
+             //  This must be changed to grab the details of the mob itself, not session preferences
+            var profile = GetPlayerProfileAsync(mindUser.Value);
+            _cloningSystem.AddToDnaScans(new ClonerDNAEntry(mind, profile));
+            UpdateUserInterface(uid, scannerComponent);
+        }
+
+        private HumanoidCharacterProfile GetPlayerProfileAsync(NetUserId userId)
+        {
+            return (HumanoidCharacterProfile) _prefsManager.GetPreferences(userId).SelectedCharacter;
+        }
     }
 }
diff --git a/Content.Shared/MedicalScanner/SharedHealthAnalyzerComponent.cs b/Content.Shared/MedicalScanner/SharedHealthAnalyzerComponent.cs
new file mode 100644
index 0000000000..3366fbfd3d
--- /dev/null
+++ b/Content.Shared/MedicalScanner/SharedHealthAnalyzerComponent.cs
@@ -0,0 +1,27 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.MedicalScanner
+{
+    public abstract class SharedHealthAnalyzerComponent : Component
+    {
+        /// <summary>
+        ///     On interacting with an entity retrieves the entity UID for use with getting the current damage of the mob.
+        /// </summary>
+        [Serializable, NetSerializable]
+        public sealed class HealthAnalyzerScannedUserMessage : BoundUserInterfaceMessage
+        {
+            public readonly EntityUid? TargetEntity;
+
+            public HealthAnalyzerScannedUserMessage(EntityUid? targetEntity)
+            {
+                TargetEntity = targetEntity;
+            }
+        }
+
+        [Serializable, NetSerializable]
+        public enum HealthAnalyzerUiKey : byte
+        {
+            Key
+        }
+    }
+}
diff --git a/Content.Shared/MedicalScanner/SharedMedicalScannerComponent.cs b/Content.Shared/MedicalScanner/SharedMedicalScannerComponent.cs
index d4a8244c76..893a24cf53 100644
--- a/Content.Shared/MedicalScanner/SharedMedicalScannerComponent.cs
+++ b/Content.Shared/MedicalScanner/SharedMedicalScannerComponent.cs
@@ -1,11 +1,5 @@
-using System;
-using System.Collections.Generic;
 using Content.Shared.Body.Components;
-using Content.Shared.Damage;
 using Content.Shared.DragDrop;
-using Content.Shared.FixedPoint;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Serialization;
 
 namespace Content.Shared.MedicalScanner
@@ -15,25 +9,11 @@ namespace Content.Shared.MedicalScanner
         [Serializable, NetSerializable]
         public sealed class MedicalScannerBoundUserInterfaceState : BoundUserInterfaceState
         {
-            public readonly EntityUid? Entity;
-            public readonly IReadOnlyDictionary<string, FixedPoint2> DamagePerGroup;
-            public readonly IReadOnlyDictionary<string, FixedPoint2> DamagePerType;
-            public readonly bool IsScanned;
+            public readonly bool IsScannable;
 
-            public MedicalScannerBoundUserInterfaceState(
-                EntityUid? entity,
-                DamageableComponent? damageable,
-                bool isScanned)
+            public MedicalScannerBoundUserInterfaceState(bool isScannable)
             {
-                Entity = entity;
-                DamagePerGroup = damageable?.DamagePerGroup ?? new();
-                DamagePerType = damageable?.Damage?.DamageDict ?? new();
-                IsScanned = isScanned;
-            }
-
-            public bool HasDamage()
-            {
-                return DamagePerType.Count > 0;
+                IsScannable = isScannable;
             }
         }
 
@@ -61,20 +41,8 @@ namespace Content.Shared.MedicalScanner
         }
 
         [Serializable, NetSerializable]
-        public enum UiButton
+        public sealed class ScanButtonPressedMessage : BoundUserInterfaceMessage
         {
-            ScanDNA,
-        }
-
-        [Serializable, NetSerializable]
-        public sealed class UiButtonPressedMessage : BoundUserInterfaceMessage
-        {
-            public readonly UiButton Button;
-
-            public UiButtonPressedMessage(UiButton button)
-            {
-                Button = button;
-            }
         }
 
         public bool CanInsert(EntityUid entity)
diff --git a/Resources/Locale/en-US/medical/components/health-analyzer-component.ftl b/Resources/Locale/en-US/medical/components/health-analyzer-component.ftl
new file mode 100644
index 0000000000..24fa303181
--- /dev/null
+++ b/Resources/Locale/en-US/medical/components/health-analyzer-component.ftl
@@ -0,0 +1,6 @@
+health-analyzer-window-no-patient-data-text = No patient data.
+health-analyzer-window-entity-health-text = {$entityName}'s health:
+health-analyzer-window-entity-damage-total-text = Total Damage: {$amount}
+health-analyzer-window-damage-group-text = {$damageGroup}: {$amount}
+health-analyzer-window-damage-type-text = {$damageType}: {$amount}
+health-analyzer-window-damage-type-duplicate-text = {$damageType}: {$amount} (duplicate)
diff --git a/Resources/Locale/en-US/medical/components/medical-scanner-component.ftl b/Resources/Locale/en-US/medical/components/medical-scanner-component.ftl
index 8ecd815057..c934c81b38 100644
--- a/Resources/Locale/en-US/medical/components/medical-scanner-component.ftl
+++ b/Resources/Locale/en-US/medical/components/medical-scanner-component.ftl
@@ -2,6 +2,7 @@
 
 medical-scanner-component-msg-no-soul = ERROR: Body is completely devoid of soul
 medical-scanner-component-msg-soul-broken = ERROR: Soul present, but defunct / departed
+medical-scanner-component-msg-no-humanoid-component = ERROR: Body is incompatible
 
 ## EnterVerb
 
@@ -11,9 +12,3 @@ medical-scanner-verb-noun-occupant = occupant
 ## UI
 
 medical-scanner-window-save-button-text = Scan and Save DNA
-medical-scanner-window-no-patient-data-text = No patient data.
-medical-scanner-window-entity-health-text = {$entityName}'s health:
-medical-scanner-window-entity-damage-total-text = Total Damage: {$amount}
-medical-scanner-window-damage-group-text = {$damageGroup}: {$amount}
-medical-scanner-window-damage-type-text = {$damageType}: {$amount}
-medical-scanner-window-damage-type-duplicate-text = {$damageType}: {$amount} (duplicate)
diff --git a/Resources/Prototypes/Catalog/Fills/Lockers/medical.yml b/Resources/Prototypes/Catalog/Fills/Lockers/medical.yml
index f232bbcf22..e5935a8ffc 100644
--- a/Resources/Prototypes/Catalog/Fills/Lockers/medical.yml
+++ b/Resources/Prototypes/Catalog/Fills/Lockers/medical.yml
@@ -23,23 +23,20 @@
   components:
   - type: StorageFill
     contents:
+      - id: HandheldHealthAnalyzer
       - id: ClothingHandsGlovesLatex
-        prob: 1
       - id: ClothingHeadsetMedical
-        prob: 1
      # - id: ClothingEyesHudMedical #Removed until working properly
-     #   prob: 1
       - id: ClothingBeltMedical
-        prob: 1
-      - id: ClothingHeadHatSurgcapBlue
-        prob: 1
-        orGroup: Surgcaps
       - id: ClothingHeadHatSurgcapGreen
         prob: 0.1
         orGroup: Surgcaps
       - id: ClothingHeadHatSurgcapPurple
         prob: 0.05
         orGroup: Surgcaps
+      - id: ClothingHeadHatSurgcapBlue
+        prob: 0.90
+        orGroup: Surgcaps
       - id: UniformScrubsColorBlue
         prob: 0.5
         orGroup: Surgshrubs
@@ -50,7 +47,6 @@
         prob: 0.05
         orGroup: Surgshrubs
       - id: ClothingMaskSterile
-        prob: 1
 
 - type: entity
   id: LockerChemistryFilled
@@ -60,8 +56,5 @@
   - type: StorageFill
     contents:
       - id: BoxSyringe
-        prob: 1
       - id: BoxBeaker
-        prob: 1
       - id: BoxPillCanister
-        prob: 1
diff --git a/Resources/Prototypes/Catalog/VendingMachines/Inventories/medical.yml b/Resources/Prototypes/Catalog/VendingMachines/Inventories/medical.yml
index 2ebd778749..498880ee6e 100644
--- a/Resources/Prototypes/Catalog/VendingMachines/Inventories/medical.yml
+++ b/Resources/Prototypes/Catalog/VendingMachines/Inventories/medical.yml
@@ -4,6 +4,7 @@
   animationDuration: 1.8
   spriteName: medical
   startingInventory:
+    HandheldHealthAnalyzer: 4
     Brutepack: 5
     Ointment: 5
     EpinephrineChemistryBottle: 3
diff --git a/Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml b/Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml
new file mode 100644
index 0000000000..4427deef97
--- /dev/null
+++ b/Resources/Prototypes/Entities/Objects/Specific/Medical/healthanalyzer.yml
@@ -0,0 +1,17 @@
+- type: entity
+  name: health analyzer
+  parent: BaseItem
+  id: HandheldHealthAnalyzer
+  description: A hand-held body scanner capable of distinguishing vital signs of the subject.
+  components:
+  - type: Sprite
+    sprite: Objects/Specific/Medical/healthanalyzer.rsi
+    netsync: false
+    state: analyzer
+  - type: ActivatableUI
+    key: enum.HealthAnalyzerUiKey.Key
+  - type: UserInterface
+    interfaces:
+      - key: enum.HealthAnalyzerUiKey.Key
+        type: HealthAnalyzerBoundUserInterface
+  - type: HealthAnalyzer
diff --git a/Resources/Prototypes/Entities/Structures/Machines/lathe.yml b/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
index 9e5a6298b5..ed00d94586 100644
--- a/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
+++ b/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
@@ -65,6 +65,7 @@
       - Spade
       - CableStack
       - HandheldGPSBasic
+      - HandheldHealthAnalyzer
   - type: Appearance
     visuals:
     - type: AutolatheVisualizer
diff --git a/Resources/Prototypes/Recipes/Lathes/medical.yml b/Resources/Prototypes/Recipes/Lathes/medical.yml
index 4857ec9684..01673908af 100644
--- a/Resources/Prototypes/Recipes/Lathes/medical.yml
+++ b/Resources/Prototypes/Recipes/Lathes/medical.yml
@@ -64,3 +64,12 @@
     Glass: 1200
     Steel: 1000
     Plastic: 1400
+
+- type: latheRecipe
+  id: HandheldHealthAnalyzer
+  icon: Objects/Specific/Medical/healthanalyzer.rsi/icon.png
+  result: HandheldHealthAnalyzer
+  completetime: 1000
+  materials:
+    Glass: 500
+    Steel: 500
diff --git a/Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/analyzer.png b/Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/analyzer.png
new file mode 100644
index 0000000000000000000000000000000000000000..3fbab3f112c1d2dffb80f16d93f83a3e57b20aae
GIT binary patch
literal 1059
zcmeAS@N?(olHy`uVBq!ia0vp^4M3d0!3HF+R#ka2FfhOJba4!+nDch7ceZe#M4SE5
zR&DdLhe|?@1|Ac{^e41(|8LOf(p&YwNxZB3(V^FBy8<t`27K5SAd(~A^p{t!dwS9W
zXV1cmryRWg9odoLZ!7tHlI2Ou%V%uPtIfPK&scr=+>{5k%1l5Df#AaVo7~r#{v7@C
zUgnA8>ecl*KiQe~+x}m-#(zfUwx*}s^xM_7h4$6_dvT3Vy7|cb&HoP^RBoK~`)=HZ
z9rgJS%Bvl>+Y0`;8yE1`OcY2NT+WI78NT)IpY>|rSn9Tm*HmmQ-1$2(Ip^<6ZMVHI
zif)SwPLwu3f86fd*VFn%6`MZYe|vb1&!4ito$U=X)3kTg{+-m(VN-3a{i;evJ??(*
zZf%2^EPuZJ?c{b?YxVcn#na)!?1E_@FYn%W{UlS}?|(;FH$3`3W%6=;uh%D&BR|%6
zb)4Ae<$BK7ef^Q2J0n+Ke;s{$-t$zcHwORQ)@qf{>M#Cio)sGTV$I1vch=0Ay-#KC
zH~sXwr(%Y){~uv3SW%SYJ;!Zv*i^s0dRtGf+~>%9ctPFM)%m~Nk1EtX4f}n6Md;k0
zrQ2`)*A_pYGVAx5c;=}VJ(E`bmfHI2TKu6EoWI>S-thT*N_Jn#!|QV&{*){E*DL05
z$?ui+C9!q)KNNnLt#{<gd4|Y<<8uP#n0@~g-v04l{j2eT-)Gm0wQC)BaY?!RJ+&^+
z?9<2B`{wVMD+=`X%Jzo$-uqosl1=O4f9dAGzw2Ln@x$lM>r(!_`?FGAolnNz^vlb$
zSLNe-&$m20f1Mu^r3lh>$%&soHvN9duCa4|9mAiON1lHEeCl|<`2JVw66yAT8C1Vt
z<_{<WGx)Fa3-C3rs@ZeG&F(^)ot;+0E3Ntezg%oS@gY_2FGFD6#DmZ8?~qrR<0~$>
z()!eK_noo79t&Mq_ualHj?XZ||B%CT#z|}o)SNe7h}<kUzpr?=%A0G(zk8#uzS^<q
z&a!<Izc9aGW&P!lBkJO^bE?1osts?i-~Bab#|!?B;`Fy^5|Q=?oYH-5&QI>2|NrhY
zE&26j7X3B*>~606`_TMW%0KSg{0}PcMLhZZ`5V;9KNu1I1hW>Dh*-+UmqESNU_W<D
zP1V=iA?tot{CQUQi_z=da`^>Mzzq3S@(MjC-(T;)^?ud-1sZja>l!q!yuaSvqo$bs
zsC?pi{Ym#V<kq=Qh&_Jr@Z$>?A3t1oSMP6O{-#b)0BFsY+nU>KvAu47$6nT%Qx29t
z^q=*34akfYjurE+hx;aJ%gdWHuKUIL>D%#*y1y8|{640L<Su!*v$@X4&t~-hI!mAb
PJ4npa)z4*}Q$iB}BQq5H

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/icon.png b/Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..4517250a5aa10f1858ab65cd76428a65ba18a412
GIT binary patch
literal 5806
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
H?HBiNNIVS!

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/meta.json b/Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/meta.json
new file mode 100644
index 0000000000..af66c180db
--- /dev/null
+++ b/Resources/Textures/Objects/Specific/Medical/healthanalyzer.rsi/meta.json
@@ -0,0 +1,33 @@
+{
+    "version": 1,
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from tgstation at commit https://github.com/tgstation/tgstation/commit/f07f847706d85b7cfa4b398e5175732212b69a63",
+    "states": [
+        {
+            "name": "analyzer",
+            "delays": [
+                [
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.1,
+                    0.5
+                ]
+            ]
+        },
+        {
+            "name": "icon"
+        }
+    ]
+}