Shitmed: Implementing Existing Newmed Code Into SS14

Content.Client/Body/Components/BrainComponent.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Client.Body.Components
+{
+    [RegisterComponent]
+    public sealed partial class BrainComponent : Component
+    {
+    }
+}

Content.Client/Body/Components/LungComponent.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Client.Body.Components
+{
+    [RegisterComponent]
+    public sealed partial class LungComponent : Component
+    {
+    }
+}

Content.Client/Body/Components/StomachComponent.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Client.Body.Components
+{
+    [RegisterComponent]
+    public sealed partial class StomachComponent : Component
+    {
+    }
+}

Content.Client/Body/Systems/BodySystem.cs

@@ -1,7 +1,83 @@
 using Content.Shared.Body.Systems;
+using Content.Shared.Body.Part;
+using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Markings;
+using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
+using Content.Shared.Body.Components;
 
 namespace Content.Client.Body.Systems;
 
 public sealed class BodySystem : SharedBodySystem
 {
+    [Dependency] private readonly MarkingManager _markingManager = default!;
+
+    private void ApplyMarkingToPart(MarkingPrototype markingPrototype,
+        IReadOnlyList<Color>? colors,
+        bool visible,
+        SpriteComponent sprite)
+    {
+        for (var j = 0; j < markingPrototype.Sprites.Count; j++)
+        {
+            var markingSprite = markingPrototype.Sprites[j];
+
+            if (markingSprite is not SpriteSpecifier.Rsi rsi)
+            {
+                continue;
+            }
+
+            var layerId = $"{markingPrototype.ID}-{rsi.RsiState}";
+
+            if (!sprite.LayerMapTryGet(layerId, out _))
+            {
+                var layer = sprite.AddLayer(markingSprite, j + 1);
+                sprite.LayerMapSet(layerId, layer);
+                sprite.LayerSetSprite(layerId, rsi);
+            }
+
+            sprite.LayerSetVisible(layerId, visible);
+
+            if (!visible)
+            {
+                continue;
+            }
+
+            // Okay so if the marking prototype is modified but we load old marking data this may no longer be valid
+            // and we need to check the index is correct.
+            // So if that happens just default to white?
+            if (colors != null && j < colors.Count)
+            {
+                sprite.LayerSetColor(layerId, colors[j]);
+            }
+            else
+            {
+                sprite.LayerSetColor(layerId, Color.White);
+            }
+        }
+    }
+
+    protected override void ApplyPartMarkings(EntityUid target, BodyPartAppearanceComponent component)
+    {
+        if (!TryComp(target, out SpriteComponent? sprite))
+            return;
+
+        if (component.Color != null)
+            sprite.Color = component.Color.Value;
+
+        foreach (var (visualLayer, markingList) in component.Markings)
+        {
+            foreach (var marking in markingList)
+            {
+                if (!_markingManager.TryGetMarking(marking, out var markingPrototype))
+                    continue;
+
+                ApplyMarkingToPart(markingPrototype, marking.MarkingColors, marking.Visible, sprite);
+            }
+        }
+    }
+
+    protected override void RemoveBodyMarkings(EntityUid target, BodyPartAppearanceComponent partAppearance, HumanoidAppearanceComponent bodyAppearance)
+    {
+        return;
+    }
 }

Content.Client/Hands/Systems/HandsSystem.cs

@@ -3,6 +3,7 @@
 using Content.Client.Examine;
 using Content.Client.Strip;
 using Content.Client.Verbs.UI;
+using Content.Shared.Body.Part;
 using Content.Shared.Hands;
 using Content.Shared.Hands.Components;
 using Content.Shared.Hands.EntitySystems;
@@ -38,7 +39,6 @@ public sealed class HandsSystem : SharedHandsSystem
         public event Action<string, EntityUid>? OnPlayerItemRemoved;
         public event Action<string>? OnPlayerHandBlocked;
         public event Action<string>? OnPlayerHandUnblocked;
-
         public override void Initialize()
         {
             base.Initialize();
@@ -49,6 +49,8 @@ public override void Initialize()
             SubscribeLocalEvent<HandsComponent, ComponentShutdown>(OnHandsShutdown);
             SubscribeLocalEvent<HandsComponent, ComponentHandleState>(HandleComponentState);
             SubscribeLocalEvent<HandsComponent, VisualsChangedEvent>(OnVisualsChanged);
+            SubscribeLocalEvent<HandsComponent, BodyPartRemovedEvent>(HandleBodyPartRemoved);
+            SubscribeLocalEvent<HandsComponent, BodyPartDisabledEvent>(HandleBodyPartDisabled);
 
             OnHandSetActive += OnHandActivated;
         }
@@ -236,8 +238,46 @@ public void UIHandAltActivateItem(string handName)
             RaisePredictiveEvent(new RequestHandAltInteractEvent(handName));
         }
 
+        #region pulling
+
+        #endregion
+
         #region visuals
 
+        private void HideLayers(EntityUid uid, HandsComponent component, Entity<BodyPartComponent> part, SpriteComponent? sprite = null)
+        {
+            if (part.Comp.PartType != BodyPartType.Hand || !Resolve(uid, ref sprite, logMissing: false))
+                return;
+
+            var location = part.Comp.Symmetry switch
+            {
+                BodyPartSymmetry.None => HandLocation.Middle,
+                BodyPartSymmetry.Left => HandLocation.Left,
+                BodyPartSymmetry.Right => HandLocation.Right,
+                _ => throw new ArgumentOutOfRangeException(nameof(part.Comp.Symmetry))
+            };
+
+            if (component.RevealedLayers.TryGetValue(location, out var revealedLayers))
+            {
+                foreach (var key in revealedLayers)
+                {
+                    sprite.RemoveLayer(key);
+                }
+
+                revealedLayers.Clear();
+            }
+        }
+
+        private void HandleBodyPartRemoved(EntityUid uid, HandsComponent component, ref BodyPartRemovedEvent args)
+        {
+            HideLayers(uid, component, args.Part);
+        }
+
+        private void HandleBodyPartDisabled(EntityUid uid, HandsComponent component, ref BodyPartDisabledEvent args)
+        {
+            HideLayers(uid, component, args.Part);
+        }
+
         protected override void HandleEntityInserted(EntityUid uid, HandsComponent hands, EntInsertedIntoContainerMessage args)
         {
             base.HandleEntityInserted(uid, hands, args);
@@ -262,6 +302,7 @@ protected override void HandleEntityRemoved(EntityUid uid, HandsComponent hands,
 
             if (!hands.Hands.TryGetValue(args.Container.ID, out var hand))
                 return;
+
             UpdateHandVisuals(uid, args.Entity, hand);
             _stripSys.UpdateUi(uid);
 

Content.Client/HealthAnalyzer/UI/HealthAnalyzerBoundUserInterface.cs

@@ -1,4 +1,5 @@
 using Content.Shared.MedicalScanner;
+using Content.Shared.Targeting;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 
@@ -22,6 +23,7 @@ protected override void Open()
                 Title = EntMan.GetComponent<MetaDataComponent>(Owner).EntityName,
             };
             _window.OnClose += Close;
+            _window.OnBodyPartSelected += SendBodyPartMessage;
             _window.OpenCentered();
         }
 
@@ -36,14 +38,25 @@ protected override void ReceiveMessage(BoundUserInterfaceMessage message)
             _window.Populate(cast);
         }
 
+        private void SendBodyPartMessage(TargetBodyPart? part, EntityUid target)
+        {
+            if (part == null)
+                SendMessage(new HealthAnalyzerPartMessage(EntMan.GetNetEntity(target), null));
+            else
+                SendMessage(new HealthAnalyzerPartMessage(EntMan.GetNetEntity(target), part.Value));
+        }
+
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
             if (!disposing)
                 return;
 
             if (_window != null)
+            {
                 _window.OnClose -= Close;
+                _window.OnBodyPartSelected -= SendBodyPartMessage;
+            }
 
             _window?.Dispose();
         }