Bodysystem and damagesystem rework (#1544)

* Things and stuff with grids, unfinished w/ code debug changes.

* Updated submodule and also lost some progress cause I fucked it up xd

* First unfinished draft of the BodySystem. Doesn't compile.

* More changes to make it compile, but still just a framework. Doesn't do anything at the moment.

* Many cleanup changes.

* Revert "Merge branch 'master' of https://github.com/GlassEclipse/space-station-14 into body_system"

This reverts commit ddd4aebbc76cf2a0b7b102f72b93d55a0816c88c, reversing
changes made to 12d0dd752706bdda8879393bd8191a1199a0c978.

* Commit human.yml

* Updated a lot of things to be more classy, more progress overall, etc. etc.

* Latest update with many changes

* Minor changes

* Fixed Travis build bug

* Adds first draft of Body Scanner console, apparently I also forgot to tie Mechanisms into body parts so now a heart just sits in the Torso like a good boy :)

* Commit rest of stuff

* Latest changes

* Latest changes again

* 14 naked cowboys

* Yay!

* Latest changes (probably doesnt compile)

* Surgery!!!!!!!!!~1116y

* Cleaned some stuff up

* More cleanup

* Refactoring of code. Basic surgery path now done.

* Removed readme, has been added to HackMD

* Fixes typo (and thus test errors)

* WIP changes, committing so I can pull latest master changes

* Still working on that god awful merge

* Latest changes

* Latest changes!!

* Beginning of refactor to BoundUserInterface

* Surgery!

* Latest changes - fixes pr change requests and random fixes

* oops

* Fixes bodypart recursion

* Beginning of work on revamping the damage system.

* More latest changes

* Latest changes

* Finished merge

* Commit before removing old healthcode

* Almost done with removing speciescomponent...

* It compiles!!!

* yahoo more work

* Fixes to make it work

* Merge conflict fixes

* Deleting species visualizer was a mistake

* IDE warnings are VERBOTEN

* makes the server not kill itself on startup, some cleanup (#1)

* Namespaces, comments and exception fixes

* Fix conveyor and conveyor switch serialization

SS14 in reactive when

* Move damage, acts and body to shared

Damage cleanup
Comment cleanup

* Rename SpeciesComponent to RotationComponent and cleanup

Damage cleanup
Comment cleanup

* Fix nullable warnings

* Address old reviews

Fix off welder suicide damage type, deathmatch and suspicion

* Fix new test fail with units being able to accept items when unpowered

* Remove RotationComponent, change references to IBodyManagerComponent

* Add a bloodstream to humans

* More cleanups

* Add body conduits, connections, connectors substances and valves

* Revert "Add body conduits, connections, connectors substances and valves"

This reverts commit 9ab0b50e6b15fe98852d7b0836c0cdbf4bd76d20.

* Implement the heart mechanism behavior with the circulatory network

* Added network property to mechanism behaviors

* Changed human organ sprites and added missing ones

* Fix tests

* Add individual body part sprite rendering

* Fix error where dropped mechanisms are not initialized

* Implement client/server body damage

* Make DamageContainer take care of raising events

* Reimplement medical scanner with the new body system

* Improve the medical scanner ui

* Merge conflict fixes

* Fix crash when colliding with something

* Fix microwave suicides and eyes sprite rendering

* Fix nullable reference error

* Fix up surgery client side

* Fix missing using from merge conflict

* Add breathing

*inhale

* Merge conflict fixes

* Fix accumulatedframetime being reset to 0 instead of decreased by the threshold

https://github.com/space-wizards/space-station-14/pull/1617

* Use and add to the new AtmosHelpers

* Fix feet

* Add proper coloring to dropped body parts

* Fix Urist's lungs being too strong

* Merge conflict fixes

* Merge conflict fixes

* Merge conflict fixes

Co-authored-by: GlassEclipse <tsymall5@gmail.com>
Co-authored-by: Pieter-Jan Briers <pieterjan.briers+git@gmail.com>
Co-authored-by: AJCM-git <60196617+AJCM-git@users.noreply.github.com>

Content.Shared/GameObjects/Components/Body/IBodyManagerComponent.cs

@@ -0,0 +1,9 @@
+using Content.Shared.GameObjects.Components.Damage;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Shared.GameObjects.Components.Body
+{
+    public interface IBodyManagerComponent : IDamageableComponent
+    {
+    }
+}

Content.Shared/GameObjects/Components/Body/SharedBodyManagerComponent.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using Content.Shared.GameObjects.Components.Damage;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.GameObjects.Components.Body
+{
+    public abstract class SharedBodyManagerComponent : DamageableComponent, IBodyManagerComponent
+    {
+        public override string Name => "BodyManager";
+
+        public override uint? NetID => ContentNetIDs.BODY_MANAGER;
+
+        public override List<DamageState> SupportedDamageStates => new List<DamageState> {DamageState.Alive, DamageState.Critical, DamageState.Dead};
+
+        public override DamageState CurrentDamageState =>
+            CurrentDamageState = TotalDamage > 200
+                ? DamageState.Dead
+                : TotalDamage > 100
+                    ? DamageState.Critical
+                    : DamageState.Alive;
+    }
+
+    [Serializable, NetSerializable]
+    public sealed class BodyPartAddedMessage : ComponentMessage
+    {
+        public readonly string RSIPath;
+        public readonly string RSIState;
+        public readonly Enum RSIMap;
+
+        public BodyPartAddedMessage(string rsiPath, string rsiState, Enum rsiMap)
+        {
+            Directed = true;
+            RSIPath = rsiPath;
+            RSIState = rsiState;
+            RSIMap = rsiMap;
+        }
+    }
+
+    [Serializable, NetSerializable]
+    public sealed class BodyPartRemovedMessage : ComponentMessage
+    {
+        public readonly Enum RSIMap;
+        public readonly EntityUid? Dropped;
+
+        public BodyPartRemovedMessage(Enum rsiMap, EntityUid? dropped = null)
+        {
+            Directed = true;
+            RSIMap = rsiMap;
+            Dropped = dropped;
+        }
+    }
+
+    [Serializable, NetSerializable]
+    public sealed class MechanismSpriteAddedMessage : ComponentMessage
+    {
+        public readonly Enum RSIMap;
+
+        public MechanismSpriteAddedMessage(Enum rsiMap)
+        {
+            Directed = true;
+            RSIMap = rsiMap;
+        }
+    }
+
+    [Serializable, NetSerializable]
+    public sealed class MechanismSpriteRemovedMessage : ComponentMessage
+    {
+        public readonly Enum RSIMap;
+
+        public MechanismSpriteRemovedMessage(Enum rsiMap)
+        {
+            Directed = true;
+            RSIMap = rsiMap;
+        }
+    }
+
+    /// <summary>
+    ///     Used to determine whether a BodyPart can connect to another BodyPart.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public enum BodyPartCompatibility
+    {
+        Universal = 0,
+        Biological,
+        Mechanical
+    }
+
+    /// <summary>
+    ///     Each BodyPart has a BodyPartType used to determine a variety of things.
+    ///     For instance, what slots it can fit into.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public enum BodyPartType
+    {
+        Other = 0,
+        Torso,
+        Head,
+        Arm,
+        Hand,
+        Leg,
+        Foot
+    }
+
+    /// <summary>
+    ///     Defines a surgery operation that can be performed.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public enum SurgeryType
+    {
+        None = 0,
+        Incision,
+        Retraction,
+        Cauterization,
+        VesselCompression,
+        Drilling,
+        Amputation
+    }
+}

Content.Shared/GameObjects/Components/Damage/DamageState.cs

@@ -0,0 +1,20 @@
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Shared.GameObjects.Components.Damage
+{
+    // TODO: Fix summary
+    /// <summary>
+    ///     Defines what state an <see cref="IEntity"/> with a
+    ///     <see cref="IDamageableComponent"/> is in.
+    ///     Not all states must be supported - for instance, the
+    ///     <see cref="RuinableComponent"/> only supports
+    ///     <see cref="DamageState.Alive"/> and <see cref="DamageState.Dead"/>,
+    ///     as inanimate objects don't go into crit.
+    /// </summary>
+    public enum DamageState
+    {
+        Alive,
+        Critical,
+        Dead
+    }
+}

Content.Shared/GameObjects/Components/Damage/DamageableComponent.cs

@@ -1,40 +1,227 @@
-using System;
+#nullable enable
+using System;
 using System.Collections.Generic;
+using Content.Shared.Damage;
+using Content.Shared.Damage.DamageContainer;
+using Content.Shared.Damage.ResistanceSet;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
 
 namespace Content.Shared.GameObjects.Components.Damage
 {
-    public abstract class SharedDamageableComponent : Component
+    /// <summary>
+    ///     Component that allows attached entities to take damage.
+    ///     This basic version never dies (thus can take an indefinite amount of damage).
+    /// </summary>
+    [ComponentReference(typeof(IDamageableComponent))]
+    public class DamageableComponent : Component, IDamageableComponent
     {
+#pragma warning disable 649
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+#pragma warning restore 649
+
         public override string Name => "Damageable";
-        public sealed override uint? NetID => ContentNetIDs.DAMAGEABLE;
-    }
 
-    // The IDs of the items get synced over the network.
-    [Serializable, NetSerializable]
-    public class DamageComponentState : ComponentState
-    {
-        public Dictionary<DamageType, int> CurrentDamage = new Dictionary<DamageType, int>();
+        public event Action<HealthChangedEventArgs> HealthChangedEvent = default!;
 
-        public DamageComponentState(Dictionary<DamageType, int> damage) : base(ContentNetIDs.DAMAGEABLE)
+        [ViewVariables] private ResistanceSet Resistance { get; set; } = default!;
+
+        [ViewVariables] private DamageContainer Damage { get; set; } = default!;
+
+        public virtual List<DamageState> SupportedDamageStates => new List<DamageState> {DamageState.Alive};
+
+        public virtual DamageState CurrentDamageState { get; protected set; } = DamageState.Alive;
+
+        [ViewVariables] public int TotalDamage => Damage.TotalDamage;
+
+        public IReadOnlyDictionary<DamageClass, int> DamageClasses => Damage.DamageClasses;
+
+        public IReadOnlyDictionary<DamageType, int> DamageTypes => Damage.DamageTypes;
+
+        public override void ExposeData(ObjectSerializer serializer)
         {
-            CurrentDamage = damage;
+            base.ExposeData(serializer);
+
+            if (serializer.Reading)
+            {
+                // Doesn't write to file, TODO?
+                // Yes, TODO
+                var containerId = "biologicalDamageContainer";
+                var resistanceId = "defaultResistances";
+
+                serializer.DataField(ref containerId, "damageContainer", "biologicalDamageContainer");
+                serializer.DataField(ref resistanceId, "resistances", "defaultResistances");
+
+                if (!_prototypeManager.TryIndex(containerId!, out DamageContainerPrototype damage))
+                {
+                    throw new InvalidOperationException(
+                        $"No {nameof(DamageContainerPrototype)} found with name {containerId}");
+                }
+
+                Damage = new DamageContainer(OnHealthChanged, damage);
+
+                if (!_prototypeManager.TryIndex(resistanceId!, out ResistanceSetPrototype resistance))
+                {
+                    throw new InvalidOperationException(
+                        $"No {nameof(ResistanceSetPrototype)} found with name {resistanceId}");
+                }
+
+                Resistance = new ResistanceSet(resistance);
+            }
+        }
+
+        public bool TryGetDamage(DamageType type, out int damage)
+        {
+            return Damage.TryGetDamageValue(type, out damage);
+        }
+
+        public bool ChangeDamage(DamageType type, int amount, bool ignoreResistances,
+            IEntity? source = null,
+            HealthChangeParams? extraParams = null)
+        {
+            if (Damage.SupportsDamageType(type))
+            {
+                var finalDamage = amount;
+                if (!ignoreResistances)
+                {
+                    finalDamage = Resistance.CalculateDamage(type, amount);
+                }
+
+                Damage.ChangeDamageValue(type, finalDamage);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool ChangeDamage(DamageClass @class, int amount, bool ignoreResistances,
+            IEntity? source = null,
+            HealthChangeParams? extraParams = null)
+        {
+            if (Damage.SupportsDamageClass(@class))
+            {
+                var types = @class.ToTypes();
+
+                if (amount < 0)
+                {
+                    // Changing multiple types is a bit more complicated. Might be a better way (formula?) to do this,
+                    // but essentially just loops between each damage category until all healing is used up.
+                    var healingLeft = amount;
+                    var healThisCycle = 1;
+
+                    // While we have healing left...
+                    while (healingLeft > 0 && healThisCycle != 0)
+                    {
+                        // Infinite loop fallback, if no healing was done in a cycle
+                        // then exit
+                        healThisCycle = 0;
+
+                        int healPerType;
+                        if (healingLeft > -types.Count && healingLeft < 0)
+                        {
+                            // Say we were to distribute 2 healing between 3
+                            // this will distribute 1 to each (and stop after 2 are given)
+                            healPerType = -1;
+                        }
+                        else
+                        {
+                            // Say we were to distribute 62 healing between 3
+                            // this will distribute 20 to each, leaving 2 for next loop
+                            healPerType = healingLeft / types.Count;
+                        }
+
+                        foreach (var type in types)
+                        {
+                            var healAmount =
+                                Math.Max(Math.Max(healPerType, -Damage.GetDamageValue(type)),
+                                    healingLeft);
+
+                            Damage.ChangeDamageValue(type, healAmount);
+                            healThisCycle += healAmount;
+                            healingLeft -= healAmount;
+                        }
+                    }
+
+                    return true;
+                }
+
+                var damageLeft = amount;
+
+                while (damageLeft > 0)
+                {
+                    int damagePerType;
+
+                    if (damageLeft < types.Count && damageLeft > 0)
+                    {
+                        damagePerType = 1;
+                    }
+                    else
+                    {
+                        damagePerType = damageLeft / types.Count;
+                    }
+
+                    foreach (var type in types)
+                    {
+                        var damageAmount = Math.Min(damagePerType, damageLeft);
+                        Damage.ChangeDamageValue(type, damageAmount);
+                        damageLeft -= damageAmount;
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool SetDamage(DamageType type, int newValue, IEntity? source = null,
+            HealthChangeParams? extraParams = null)
+        {
+            if (Damage.SupportsDamageType(type))
+            {
+                Damage.SetDamageValue(type, newValue);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public void Heal()
+        {
+            Damage.Heal();
+        }
+
+        public void ForceHealthChangedEvent()
+        {
+            var data = new List<HealthChangeData>();
+
+            foreach (var type in Damage.SupportedTypes)
+            {
+                var damage = Damage.GetDamageValue(type);
+                var datum = new HealthChangeData(type, damage, 0);
+                data.Add(datum);
+            }
+
+            OnHealthChanged(data);
+        }
+
+        private void OnHealthChanged(List<HealthChangeData> changes)
+        {
+            var args = new HealthChangedEventArgs(this, changes);
+            OnHealthChanged(args);
+        }
+
+        protected virtual void OnHealthChanged(HealthChangedEventArgs e)
+        {
+            Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, e);
+            HealthChangedEvent?.Invoke(e);
+            Dirty();
         }
     }
-
-    /// <summary>
-    /// Damage types used in-game.
-    /// Total should never be used directly - it's a derived value.
-    /// </summary>
-    public enum DamageType
-    {
-        Total,
-        Brute,
-        Heat,
-        Cold,
-        Acid,
-        Toxic,
-        Electric
-    }
 }

Content.Shared/GameObjects/Components/Damage/IDamageableComponent.cs

@@ -0,0 +1,223 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Damage;
+using Content.Shared.GameObjects.Components.Body;
+using Content.Shared.GameObjects.EntitySystems;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Shared.GameObjects.Components.Damage
+{
+    public interface IDamageableComponent : IComponent, IExAct
+    {
+        /// <summary>
+        ///     Called when the entity's <see cref="IDamageableComponent"/> values change.
+        ///     Of note is that a "deal 0 damage" call will still trigger this event
+        ///     (including both damage negated by resistance or simply inputting 0 as
+        ///     the amount of damage to deal).
+        /// </summary>
+        event Action<HealthChangedEventArgs> HealthChangedEvent;
+
+        /// <summary>
+        ///     List of all <see cref="DamageState">DamageStates</see> that
+        ///     <see cref="CurrentDamageState"/> can be.
+        /// </summary>
+        List<DamageState> SupportedDamageStates { get; }
+
+        /// <summary>
+        ///     The <see cref="DamageState"/> currently representing this component.
+        /// </summary>
+        DamageState CurrentDamageState { get; }
+
+        /// <summary>
+        ///     Sum of all damages taken.
+        /// </summary>
+        int TotalDamage { get; }
+
+        /// <summary>
+        ///     The amount of damage mapped by <see cref="DamageClass"/>.
+        /// </summary>
+        IReadOnlyDictionary<DamageClass, int> DamageClasses { get; }
+
+        /// <summary>
+        ///     The amount of damage mapped by <see cref="DamageType"/>.
+        /// </summary>
+        IReadOnlyDictionary<DamageType, int> DamageTypes { get; }
+
+        /// <summary>
+        ///     Gets the amount of damage of a type.
+        /// </summary>
+        /// <param name="type">The type to get the damage of.</param>
+        /// <param name="damage">The amount of damage of that type.</param>
+        /// <returns>
+        ///     True if the given <see cref="type"/> is supported, false otherwise.
+        /// </returns>
+        bool TryGetDamage(DamageType type, [NotNullWhen(true)] out int damage);
+
+        /// <summary>
+        ///     Changes the specified <see cref="DamageType"/>, applying
+        ///     resistance values only if it is damage.
+        /// </summary>
+        /// <param name="type">Type of damage being changed.</param>
+        /// <param name="amount">
+        ///     Amount of damage being received (positive for damage, negative for heals).
+        /// </param>
+        /// <param name="ignoreResistances">
+        ///     Whether or not to ignore resistances.
+        ///     Healing always ignores resistances, regardless of this input.
+        /// </param>
+        /// <param name="source">
+        ///     The entity that dealt or healed the damage, if any.
+        /// </param>
+        /// <param name="extraParams">
+        ///     Extra parameters that some components may require, such as a specific limb to target.
+        /// </param>
+        /// <returns>
+        ///     False if the given type is not supported or improper
+        ///     <see cref="HealthChangeParams"/> were provided; true otherwise.
+        /// </returns>
+        bool ChangeDamage(DamageType type, int amount, bool ignoreResistances, IEntity? source = null,
+            HealthChangeParams? extraParams = null);
+
+        /// <summary>
+        ///     Changes the specified <see cref="DamageClass"/>, applying
+        ///     resistance values only if it is damage.
+        ///     Spreads amount evenly between the <see cref="DamageType"></see>s
+        ///     represented by that class.
+        /// </summary>
+        /// <param name="class">Class of damage being changed.</param>
+        /// <param name="amount">
+        ///     Amount of damage being received (positive for damage, negative for heals).
+        /// </param>
+        /// <param name="ignoreResistances">
+        ///     Whether to ignore resistances.
+        ///     Healing always ignores resistances, regardless of this input.
+        /// </param>
+        /// <param name="source">Entity that dealt or healed the damage, if any.</param>
+        /// <param name="extraParams">
+        ///     Extra parameters that some components may require,
+        ///     such as a specific limb to target.
+        /// </param>
+        /// <returns>
+        ///     Returns false if the given class is not supported or improper
+        ///     <see cref="HealthChangeParams"/> were provided; true otherwise.
+        /// </returns>
+        bool ChangeDamage(DamageClass @class, int amount, bool ignoreResistances, IEntity? source = null,
+            HealthChangeParams? extraParams = null);
+
+        /// <summary>
+        ///     Forcefully sets the specified <see cref="DamageType"/> to the given
+        ///     value, ignoring resistance values.
+        /// </summary>
+        /// <param name="type">Type of damage being changed.</param>
+        /// <param name="newValue">New damage value to be set.</param>
+        /// <param name="source">Entity that set the new damage value.</param>
+        /// <param name="extraParams">
+        ///     Extra parameters that some components may require,
+        ///     such as a specific limb to target.
+        /// </param>
+        /// <returns>
+        ///     Returns false if the given type is not supported or improper
+        ///     <see cref="HealthChangeParams"/> were provided; true otherwise.
+        /// </returns>
+        bool SetDamage(DamageType type, int newValue, IEntity? source = null, HealthChangeParams? extraParams = null);
+
+        /// <summary>
+        ///     Sets all damage values to zero.
+        /// </summary>
+        void Heal();
+
+        /// <summary>
+        ///     Invokes the HealthChangedEvent with the current values of health.
+        /// </summary>
+        void ForceHealthChangedEvent();
+
+        void IExAct.OnExplosion(ExplosionEventArgs eventArgs)
+        {
+            var damage = eventArgs.Severity switch
+            {
+                ExplosionSeverity.Light => 20,
+                ExplosionSeverity.Heavy => 60,
+                ExplosionSeverity.Destruction => 250,
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            ChangeDamage(DamageType.Piercing, damage, false, null);
+            ChangeDamage(DamageType.Heat, damage, false, null);
+        }
+    }
+
+    /// <summary>
+    ///     Data class with information on how to damage a
+    ///     <see cref="IDamageableComponent"/>.
+    ///     While not necessary to damage for all instances, classes such as
+    ///     <see cref="SharedBodyManagerComponent"/> may require it for extra data
+    ///     (such as selecting which limb to target).
+    /// </summary>
+    public class HealthChangeParams : EventArgs
+    {
+    }
+
+    /// <summary>
+    ///     Data class with information on how the <see cref="DamageType"/>
+    ///     values of a <see cref="IDamageableComponent"/> have changed.
+    /// </summary>
+    public class HealthChangedEventArgs : EventArgs
+    {
+        /// <summary>
+        ///     Reference to the <see cref="IDamageableComponent"/> that invoked the event.
+        /// </summary>
+        public readonly IDamageableComponent Damageable;
+
+        /// <summary>
+        ///     List containing data on each <see cref="DamageType"/> that was changed.
+        /// </summary>
+        public readonly List<HealthChangeData> Data;
+
+        public HealthChangedEventArgs(IDamageableComponent damageable, List<HealthChangeData> data)
+        {
+            Damageable = damageable;
+            Data = data;
+        }
+
+        public HealthChangedEventArgs(IDamageableComponent damageable, DamageType type, int newValue, int delta)
+        {
+            Damageable = damageable;
+
+            var datum = new HealthChangeData(type, newValue, delta);
+            var data = new List<HealthChangeData> {datum};
+
+            Data = data;
+        }
+    }
+
+    /// <summary>
+    ///     Data class with information on how the value of a
+    ///     single <see cref="DamageType"/> has changed.
+    /// </summary>
+    public struct HealthChangeData
+    {
+        /// <summary>
+        ///     Type of damage that changed.
+        /// </summary>
+        public DamageType Type;
+
+        /// <summary>
+        ///     The new current value for that damage.
+        /// </summary>
+        public int NewValue;
+
+        /// <summary>
+        ///     How much the health value changed from its last value (negative is heals, positive is damage).
+        /// </summary>
+        public int Delta;
+
+        public HealthChangeData(DamageType type, int newValue, int delta)
+        {
+            Type = type;
+            NewValue = newValue;
+            Delta = delta;
+        }
+    }
+}

Content.Shared/GameObjects/Components/Damage/IOnHealthChangedBehavior.cs

@@ -0,0 +1,22 @@
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Shared.GameObjects.Components.Damage
+{
+    // TODO
+    /// <summary>
+    ///     Component interface that gets triggered after the values of a
+    ///     <see cref="IDamageableComponent"/> on the same <see cref="IEntity"/> change.
+    /// </summary>
+    public interface IOnHealthChangedBehavior
+    {
+        /// <summary>
+        ///     Called when the entity's <see cref="IDamageableComponent"/>
+        ///     is healed or hurt.
+        ///     Of note is that a "deal 0 damage" call will still trigger
+        ///     this function (including both damage negated by resistance or
+        ///     simply inputting 0 as the amount of damage to deal).
+        /// </summary>
+        /// <param name="e">Details of how the health changed.</param>
+        public void OnHealthChanged(HealthChangedEventArgs e);
+    }
+}

Content.Shared/GameObjects/Components/Medical/SharedMedicalScannerComponent.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Content.Shared.Damage;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameObjects.Components.UserInterface;
 using Robust.Shared.Serialization;
@@ -13,18 +14,23 @@ namespace Content.Shared.GameObjects.Components.Medical
         [Serializable, NetSerializable]
         public class MedicalScannerBoundUserInterfaceState : BoundUserInterfaceState
         {
-            public readonly int CurrentHealth;
-            public readonly int MaxHealth;
-            public readonly Dictionary<string, int> DamageDictionary;
+            public readonly EntityUid? Entity;
+            public readonly Dictionary<DamageClass, int> DamageClasses;
+            public readonly Dictionary<DamageType, int> DamageTypes;
 
             public MedicalScannerBoundUserInterfaceState(
-                int currentHealth,
-                int maxHealth,
-                Dictionary<string, int> damageDictionary)
+                EntityUid? entity,
+                Dictionary<DamageClass, int> damageClasses,
+                Dictionary<DamageType, int> damageTypes)
             {
-                CurrentHealth = currentHealth;
-                MaxHealth = maxHealth;
-                DamageDictionary = damageDictionary;
+                Entity = entity;
+                DamageClasses = damageClasses;
+                DamageTypes = damageTypes;
+            }
+
+            public bool HasDamage()
+            {
+                return DamageClasses.Count > 0 || DamageTypes.Count > 0;
             }
         }
 

Content.Shared/GameObjects/Components/Mobs/SharedSpeciesComponent.cs

@@ -1,31 +0,0 @@
-using System;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization;
-
-namespace Content.Shared.GameObjects.Components.Mobs
-{
-    public abstract class SharedSpeciesComponent : Component
-    {
-        public sealed override string Name => "Species";
-
-        [Serializable, NetSerializable]
-        public enum MobVisuals
-        {
-            RotationState
-        }
-
-        [Serializable, NetSerializable]
-        public enum MobState
-        {
-            /// <summary>
-            ///     Mob is standing up
-            /// </summary>
-            Standing,
-
-            /// <summary>
-            ///     Mob is laying down
-            /// </summary>
-            Down,
-        }
-    }
-}

Content.Shared/GameObjects/Components/Movement/MovementSpeedModifierComponent.cs

@@ -1,4 +1,4 @@
-using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
 
@@ -10,6 +10,7 @@ namespace Content.Shared.GameObjects.Components.Movement
         public const float DefaultBaseWalkSpeed = 4.0f;
         public const float DefaultBaseSprintSpeed = 7.0f;
 
+
         public override string Name => "MovementSpeedModifier";
 
         private float _cachedWalkSpeedModifier = 1.0f;

Content.Shared/GameObjects/Components/Movement/SharedPlayerInputMoverComponent.cs

@@ -1,6 +1,8 @@
 #nullable enable
 using System;
+using Content.Shared.GameObjects.Components.Body;
 using Content.Shared.GameObjects.Components.Mobs;
+using Content.Shared.GameObjects.Components.Rotation;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameObjects.Components;
 using Robust.Shared.Interfaces.Configuration;
@@ -268,7 +270,7 @@ namespace Content.Shared.GameObjects.Components.Movement
         bool ICollideSpecial.PreventCollide(IPhysBody collidedWith)
         {
             // Don't collide with other mobs
-            return collidedWith.Entity.HasComponent<SharedSpeciesComponent>();
+            return collidedWith.Entity.HasComponent<IBodyManagerComponent>();
         }
 
         [Serializable, NetSerializable]

Content.Shared/GameObjects/Components/Rotation/RotationComponent.cs

@@ -0,0 +1,26 @@
+using System;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.GameObjects.Components.Rotation
+{
+    [Serializable, NetSerializable]
+    public enum RotationVisuals
+    {
+        RotationState
+    }
+
+    [Serializable, NetSerializable]
+    public enum RotationState
+    {
+        /// <summary>
+        ///     Standing up
+        /// </summary>
+        Vertical,
+
+        /// <summary>
+        ///     Laying down
+        /// </summary>
+        Horizontal,
+    }
+}