Mobstate Refactor (#13389)

Refactors mobstate and moves mob health thresholds to their own component

Co-authored-by: DrSmugleaf <drsmugleaf@gmail.com>

Content.Shared/Mobs/Systems/MobStateSystem.StateMachine.cs

@@ -0,0 +1,130 @@
+using Content.Shared.Database;
+using Content.Shared.Mobs.Components;
+
+namespace Content.Shared.Mobs.Systems;
+
+public partial class MobStateSystem
+{
+    #region Public API
+
+    /// <summary>
+    /// Check if an Entity can be set to a particular MobState
+    /// </summary>
+    /// <param name="entity">Target Entity</param>
+    /// <param name="mobState">MobState to check</param>
+    /// <param name="component">MobState Component owned by the target</param>
+    /// <returns>If the entity can be set to that MobState</returns>
+    public bool HasState(EntityUid entity, MobState mobState, MobStateComponent? component = null)
+    {
+        return Resolve(entity, ref component, false) && component.AllowedStates.Contains(mobState);
+    }
+
+    /// <summary>
+    /// Run a MobState update check. This will trigger update events if the state has been changed.
+    /// </summary>
+    /// <param name="entity">Target Entity we want to change the MobState of</param>
+    /// <param name="component">MobState Component attached to the entity</param>
+    /// <param name="origin">Entity that caused the state update (if applicable)</param>
+    public void UpdateMobState(EntityUid entity, MobStateComponent? component = null, EntityUid? origin = null)
+    {
+        if (!Resolve(entity, ref component))
+            return;
+
+        var ev = new UpdateMobStateEvent {Target = entity, Component = component, Origin = origin};
+        RaiseLocalEvent(entity, ref ev);
+        ChangeState(entity, component, ev.State);
+    }
+
+    /// <summary>
+    /// Change the MobState and trigger MobState update events
+    /// </summary>
+    /// <param name="entity">Target Entity we want to change the MobState of</param>
+    /// <param name="mobState">The new MobState we want to set</param>
+    /// <param name="component">MobState Component attached to the entity</param>
+    /// <param name="origin">Entity that caused the state update (if applicable)</param>
+    public void ChangeMobState(EntityUid entity, MobState mobState, MobStateComponent? component = null,
+        EntityUid? origin = null)
+    {
+        if (!Resolve(entity, ref component))
+            return;
+
+        var ev = new UpdateMobStateEvent {Target = entity, Component = component, Origin = origin};
+        RaiseLocalEvent(entity, ref ev);
+        ChangeState(entity, component, ev.State);
+    }
+
+    #endregion
+
+    #region Virtual API
+
+    /// <summary>
+    /// Called when a new MobState is entered.
+    /// </summary>
+    /// <param name="entity">The owner of the MobState Component</param>
+    /// <param name="component">MobState Component owned by the target</param>
+    /// <param name="state">The new MobState</param>
+    protected virtual void OnEnterState(EntityUid entity, MobStateComponent component, MobState state)
+    {
+        OnStateEnteredSubscribers(entity, component, state);
+    }
+
+    /// <summary>
+    ///  Called when this entity changes MobState
+    /// </summary>
+    /// <param name="entity">The owner of the MobState Component</param>
+    /// <param name="component">MobState Component owned by the target</param>
+    /// <param name="oldState">The previous MobState</param>
+    /// <param name="newState">The new MobState</param>
+    protected virtual void OnStateChanged(EntityUid entity, MobStateComponent component, MobState oldState,
+        MobState newState)
+    {
+    }
+
+    /// <summary>
+    /// Called when a new MobState is exited.
+    /// </summary>
+    /// <param name="entity">The owner of the MobState Component</param>
+    /// <param name="component">MobState Component owned by the target</param>
+    /// <param name="state">The old MobState</param>
+    protected virtual void OnExitState(EntityUid entity, MobStateComponent component, MobState state)
+    {
+        OnStateExitSubscribers(entity, component, state);
+    }
+
+    #endregion
+
+    #region Private Implementation
+
+    //Actually change the MobState
+    private void ChangeState(EntityUid target, MobStateComponent component, MobState newState, EntityUid? origin = null)
+    {
+        var oldState = component.CurrentState;
+        //make sure we are allowed to enter the new state
+        if (oldState == newState || !component.AllowedStates.Contains(newState))
+            return;
+
+        OnExitState(target, component, oldState);
+        component.CurrentState = newState;
+        OnEnterState(target, component, newState);
+
+        var ev = new MobStateChangedEvent(target, component, oldState, newState, origin);
+        OnStateChanged(target, component, oldState, newState);
+        RaiseLocalEvent(target, ev, true);
+        _adminLogger.Add(LogType.Damaged, oldState == MobState.Alive ? LogImpact.Low : LogImpact.Medium,
+            $"{ToPrettyString(component.Owner):user} state changed from {oldState} to {newState}");
+        Dirty(component);
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Event that gets triggered when we want to update the mobstate. This allows for systems to override MobState changes
+/// </summary>
+/// <param name="Target">The Entity whose MobState is changing</param>
+/// <param name="Component">The MobState Component owned by the Target</param>
+/// <param name="State">The new MobState we want to set</param>
+/// <param name="Origin">Entity that caused the state update (if applicable)</param>
+[ByRefEvent]
+public record struct UpdateMobStateEvent(EntityUid Target, MobStateComponent Component, MobState State,
+    EntityUid? Origin = null);

Content.Shared/Mobs/Systems/MobStateSystem.Subscribers.cs

@@ -0,0 +1,152 @@
+using Content.Shared.Bed.Sleep;
+using Content.Shared.Disease.Events;
+using Content.Shared.DragDrop;
+using Content.Shared.Emoting;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Inventory.Events;
+using Content.Shared.Item;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Movement.Events;
+using Content.Shared.Pulling.Events;
+using Content.Shared.Speech;
+using Content.Shared.Standing;
+using Content.Shared.Strip.Components;
+using Content.Shared.Throwing;
+using Robust.Shared.Physics.Components;
+
+namespace Content.Shared.Mobs.Systems;
+
+public partial class MobStateSystem
+{
+    //General purpose event subscriptions. If you can avoid it register these events inside their own systems
+    private void SubscribeEvents()
+    {
+        SubscribeLocalEvent<MobStateComponent, BeforeGettingStrippedEvent>(OnGettingStripped);
+        SubscribeLocalEvent<MobStateComponent, ChangeDirectionAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, UseAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, InteractionAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, ThrowAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, SpeakAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, IsEquippingAttemptEvent>(OnEquipAttempt);
+        SubscribeLocalEvent<MobStateComponent, EmoteAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, IsUnequippingAttemptEvent>(OnUnequipAttempt);
+        SubscribeLocalEvent<MobStateComponent, DropAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, PickupAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, StartPullAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, UpdateCanMoveEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, StandAttemptEvent>(CheckAct);
+        SubscribeLocalEvent<MobStateComponent, TryingToSleepEvent>(OnSleepAttempt);
+        SubscribeLocalEvent<MobStateComponent, AttemptSneezeCoughEvent>(OnSneezeAttempt);
+    }
+
+    private void OnStateExitSubscribers(EntityUid target, MobStateComponent component, MobState state)
+    {
+        var uid = component.Owner;
+        switch (state)
+        {
+            case MobState.Alive:
+                //unused
+                break;
+            case MobState.Critical:
+                _standing.Stand(uid);
+                break;
+            case MobState.Dead:
+                RemComp<CollisionWakeComponent>(uid);
+                _standing.Stand(uid);
+                if (!_standing.IsDown(uid) && TryComp<PhysicsComponent>(uid, out var physics))
+                {
+                    _physics.SetCanCollide(physics, true);
+                }
+
+                break;
+            case MobState.Invalid:
+                //unused
+                break;
+            default:
+                throw new NotImplementedException();
+        }
+    }
+
+    private void OnStateEnteredSubscribers(EntityUid target, MobStateComponent component, MobState state)
+    {
+        var uid = component.Owner;
+        _blocker.UpdateCanMove(uid); //update movement anytime a state changes
+        switch (state)
+        {
+            case MobState.Alive:
+                _standing.Stand(uid);
+                _appearance.SetData(uid, MobStateVisuals.State, MobState.Alive);
+                break;
+            case MobState.Critical:
+                _standing.Down(uid);
+                _appearance.SetData(uid, MobStateVisuals.State, MobState.Critical);
+                break;
+            case MobState.Dead:
+                EnsureComp<CollisionWakeComponent>(uid);
+                _standing.Down(uid);
+
+                if (_standing.IsDown(uid) && TryComp<PhysicsComponent>(uid, out var physics))
+                {
+                    _physics.SetCanCollide(physics, false);
+                }
+
+                _appearance.SetData(uid, MobStateVisuals.State, MobState.Dead);
+                break;
+            case MobState.Invalid:
+                //unused;
+                break;
+            default:
+                throw new NotImplementedException();
+        }
+    }
+
+    #region Event Subscribers
+
+    private void OnSleepAttempt(EntityUid target, MobStateComponent component, ref TryingToSleepEvent args)
+    {
+        if (IsDead(target, component))
+            args.Cancelled = true;
+    }
+
+    private void OnSneezeAttempt(EntityUid target, MobStateComponent component, ref AttemptSneezeCoughEvent args)
+    {
+        if (IsDead(target, component))
+            args.Cancelled = true;
+    }
+
+    private void OnGettingStripped(EntityUid target, MobStateComponent component, BeforeGettingStrippedEvent args)
+    {
+        // Incapacitated or dead targets get stripped two or three times as fast. Makes stripping corpses less tedious.
+        if (IsDead(target, component))
+            args.Multiplier /= 3;
+        else if (IsCritical(target, component))
+            args.Multiplier /= 2;
+    }
+
+    private void CheckAct(EntityUid target, MobStateComponent component, CancellableEntityEventArgs args)
+    {
+        switch (component.CurrentState)
+        {
+            case MobState.Dead:
+            case MobState.Critical:
+                args.Cancel();
+                break;
+        }
+    }
+
+    private void OnEquipAttempt(EntityUid target, MobStateComponent component, IsEquippingAttemptEvent args)
+    {
+        // is this a self-equip, or are they being stripped?
+        if (args.Equipee == target)
+            CheckAct(target, component, args);
+    }
+
+    private void OnUnequipAttempt(EntityUid target, MobStateComponent component, IsUnequippingAttemptEvent args)
+    {
+        // is this a self-equip, or are they being stripped?
+        if (args.Unequipee == target)
+            CheckAct(target, component, args);
+    }
+
+    #endregion
+}

Content.Shared/Mobs/Systems/MobStateSystem.cs

@@ -0,0 +1,116 @@
+using Content.Shared.ActionBlocker;
+using Content.Shared.Administration.Logs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Standing;
+using Robust.Shared.GameStates;
+using Robust.Shared.Physics.Systems;
+
+namespace Content.Shared.Mobs.Systems;
+
+[Virtual]
+public partial class MobStateSystem : EntitySystem
+{
+    [Dependency] private readonly ActionBlockerSystem _blocker = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+    [Dependency] private readonly StandingStateSystem _standing = default!;
+    [Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
+    [Dependency] private readonly ILogManager _logManager = default!;
+    private ISawmill _sawmill = default!;
+
+    public override void Initialize()
+    {
+        _sawmill = _logManager.GetSawmill("MobState");
+        base.Initialize();
+        SubscribeEvents();
+        SubscribeLocalEvent<MobStateComponent, ComponentGetState>(OnGetComponentState);
+        SubscribeLocalEvent<MobStateComponent, ComponentHandleState>(OnHandleComponentState);
+    }
+
+    #region Public API
+
+    /// <summary>
+    ///  Check if a Mob is Alive
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="component">The MobState component owned by the target</param>
+    /// <returns>If the entity is alive</returns>
+    public bool IsAlive(EntityUid target, MobStateComponent? component = null)
+    {
+        if (!Resolve(target, ref component, false))
+            return false;
+        return component.CurrentState == MobState.Alive;
+    }
+
+    /// <summary>
+    ///  Check if a Mob is Critical
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="component">The MobState component owned by the target</param>
+    /// <returns>If the entity is Critical</returns>
+    public bool IsCritical(EntityUid target, MobStateComponent? component = null)
+    {
+        if (!Resolve(target, ref component, false))
+            return false;
+        return component.CurrentState == MobState.Critical;
+    }
+
+    /// <summary>
+    ///  Check if a Mob is Dead
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="component">The MobState component owned by the target</param>
+    /// <returns>If the entity is Dead</returns>
+    public bool IsDead(EntityUid target, MobStateComponent? component = null)
+    {
+        if (!Resolve(target, ref component, false))
+            return false;
+        return component.CurrentState == MobState.Dead;
+    }
+
+    /// <summary>
+    ///  Check if a Mob is Critical or Dead
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="component">The MobState component owned by the target</param>
+    /// <returns>If the entity is Critical or Dead</returns>
+    public bool IsIncapacitated(EntityUid target, MobStateComponent? component = null)
+    {
+        if (!Resolve(target, ref component, false))
+            return false;
+        return component.CurrentState is MobState.Critical or MobState.Dead;
+    }
+
+    /// <summary>
+    ///  Check if a Mob is in an Invalid state
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="component">The MobState component owned by the target</param>
+    /// <returns>If the entity is in an Invalid State</returns>
+    public bool IsInvalidState(EntityUid target, MobStateComponent? component = null)
+    {
+        if (!Resolve(target, ref component, false))
+            return false;
+        return component.CurrentState is MobState.Invalid;
+    }
+
+    #endregion
+
+    #region Private Implementation
+
+    private void OnHandleComponentState(EntityUid uid, MobStateComponent component, ref ComponentHandleState args)
+    {
+        if (args.Current is not MobStateComponentState state)
+            return;
+
+        component.CurrentState = state.CurrentState;
+        component.AllowedStates = new HashSet<MobState>(state.AllowedStates);
+    }
+
+    private void OnGetComponentState(EntityUid uid, MobStateComponent component, ref ComponentGetState args)
+    {
+        args.State = new MobStateComponentState(component.CurrentState, component.AllowedStates);
+    }
+
+    #endregion
+}

Content.Shared/Mobs/Systems/MobThresholdSystem.cs

@@ -0,0 +1,394 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Content.Shared.Alert;
+using Content.Shared.Damage;
+using Content.Shared.FixedPoint;
+using Content.Shared.Mobs.Components;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Mobs.Systems;
+
+public sealed class MobThresholdSystem : EntitySystem
+{
+    [Dependency] private readonly MobStateSystem _mobStateSystem = default!;
+    [Dependency] private readonly AlertsSystem _alerts = default!;
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<MobThresholdsComponent, MapInitEvent>(MobThresholdMapInit);
+        SubscribeLocalEvent<MobThresholdsComponent, ComponentShutdown>(MobThresholdShutdown);
+        SubscribeLocalEvent<MobThresholdsComponent, DamageChangedEvent>(OnDamaged);
+        SubscribeLocalEvent<MobThresholdsComponent, ComponentGetState>(OnGetComponentState);
+        SubscribeLocalEvent<MobThresholdsComponent, ComponentHandleState>(OnHandleComponentState);
+        SubscribeLocalEvent<MobThresholdsComponent, UpdateMobStateEvent>(OnUpdateMobState);
+    }
+
+    #region Public API
+
+    /// <summary>
+    /// Get the Damage Threshold for the appropriate state if it exists
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="mobState">MobState we want the Damage Threshold of</param>
+    /// <param name="thresholdComponent">Threshold Component Owned by the target</param>
+    /// <returns>the threshold or 0 if it doesn't exist</returns>
+    public FixedPoint2 GetThresholdForState(EntityUid target, MobState mobState,
+        MobThresholdsComponent? thresholdComponent = null)
+    {
+        if (!Resolve(target, ref thresholdComponent))
+            return FixedPoint2.Zero;
+
+        foreach (var pair in thresholdComponent.Thresholds)
+        {
+            if (pair.Value == mobState)
+            {
+                return pair.Key;
+            }
+        }
+
+        return FixedPoint2.Zero;
+    }
+
+    /// <summary>
+    /// Try to get the Damage Threshold for the appropriate state if it exists
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="mobState">MobState we want the Damage Threshold of</param>
+    /// <param name="threshold">The damage Threshold for the given state</param>
+    /// <param name="thresholdComponent">Threshold Component Owned by the target</param>
+    /// <returns>true if successfully retrieved a threshold</returns>
+    public bool TryGetThresholdForState(EntityUid target, MobState mobState,
+        [NotNullWhen(true)] out FixedPoint2? threshold,
+        MobThresholdsComponent? thresholdComponent = null)
+    {
+        threshold = null;
+        if (!Resolve(target, ref thresholdComponent))
+            return false;
+
+        foreach (var pair in thresholdComponent.Thresholds)
+        {
+            if (pair.Value == mobState)
+            {
+                threshold = pair.Key;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Try to get the a percentage of the Damage Threshold for the appropriate state if it exists
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="mobState">MobState we want the Damage Threshold of</param>
+    /// <param name="damage">The Damage being applied</param>
+    /// <param name="percentage">Percentage of Damage compared to the Threshold</param>
+    /// <param name="thresholdComponent">Threshold Component Owned by the target</param>
+    /// <returns>true if successfully retrieved a percentage</returns>
+    public bool TryGetPercentageForState(EntityUid target, MobState mobState, FixedPoint2 damage,
+        [NotNullWhen(true)] out FixedPoint2? percentage,
+        MobThresholdsComponent? thresholdComponent = null)
+    {
+        percentage = null;
+        if (!TryGetThresholdForState(target, mobState, out var threshold, thresholdComponent))
+            return false;
+
+        percentage = damage / threshold;
+        return true;
+    }
+
+    /// <summary>
+    /// Try to get the Damage Threshold for crit or death. Outputs the first found threshold.
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="threshold">The Damage Threshold for incapacitation</param>
+    /// <param name="thresholdComponent">Threshold Component owned by the target</param>
+    /// <returns>true if successfully retrieved incapacitation threshold</returns>
+    public bool TryGetIncapThreshold(EntityUid target, [NotNullWhen(true)] out FixedPoint2? threshold,
+        MobThresholdsComponent? thresholdComponent = null)
+    {
+        threshold = null;
+        if (!Resolve(target, ref thresholdComponent))
+            return false;
+
+        return TryGetThresholdForState(target, MobState.Critical, out threshold, thresholdComponent)
+               || TryGetThresholdForState(target, MobState.Dead, out threshold, thresholdComponent);
+    }
+
+    /// <summary>
+    /// Try to get a percentage of the Damage Threshold for crit or death. Outputs the first found percentage.
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="damage">The damage being applied</param>
+    /// <param name="percentage">Percentage of Damage compared to the Incapacitation Threshold</param>
+    /// <param name="thresholdComponent">Threshold Component Owned by the target</param>
+    /// <returns>true if successfully retrieved incapacitation percentage</returns>
+    public bool TryGetIncapPercentage(EntityUid target, FixedPoint2 damage,
+        [NotNullWhen(true)] out FixedPoint2? percentage,
+        MobThresholdsComponent? thresholdComponent = null)
+    {
+        percentage = null;
+        if (!TryGetIncapThreshold(target, out var threshold, thresholdComponent))
+            return false;
+
+        if (damage == 0)
+        {
+            percentage = 0;
+            return true;
+        }
+
+        percentage = FixedPoint2.Min(1.0f, damage / threshold.Value);
+        return true;
+    }
+
+    /// <summary>
+    /// Try to get the Damage Threshold for death
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="threshold">The Damage Threshold for death</param>
+    /// <param name="thresholdComponent">Threshold Component owned by the target</param>
+    /// <returns>true if successfully retrieved incapacitation threshold</returns>
+    public bool TryGetDeadThreshold(EntityUid target, [NotNullWhen(true)] out FixedPoint2? threshold,
+        MobThresholdsComponent? thresholdComponent = null)
+    {
+        threshold = null;
+        if (!Resolve(target, ref thresholdComponent))
+            return false;
+
+        return TryGetThresholdForState(target, MobState.Dead, out threshold, thresholdComponent);
+    }
+
+    /// <summary>
+    /// Try to get a percentage of the Damage Threshold for death
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="damage">The damage being applied</param>
+    /// <param name="percentage">Percentage of Damage compared to the Death Threshold</param>
+    /// <param name="thresholdComponent">Threshold Component Owned by the target</param>
+    /// <returns>true if successfully retrieved death percentage</returns>
+    public bool TryGetDeadPercentage(EntityUid target, FixedPoint2 damage,
+        [NotNullWhen(true)] out FixedPoint2? percentage,
+        MobThresholdsComponent? thresholdComponent = null)
+    {
+        percentage = null;
+        if (!TryGetDeadThreshold(target, out var threshold, thresholdComponent))
+            return false;
+
+        if (damage == 0)
+        {
+            percentage = 0;
+            return true;
+        }
+
+        percentage = FixedPoint2.Min(1.0f, damage / threshold.Value);
+        return true;
+    }
+
+    /// <summary>
+    /// Takes the damage from one entity and scales it relative to the health of another
+    /// </summary>
+    /// <param name="target1">The entity whose damage will be scaled</param>
+    /// <param name="target2">The entity whose health the damage will scale to</param>
+    /// <param name="damage">The newly scaled damage. Can be null</param>
+    public bool GetScaledDamage(EntityUid target1, EntityUid target2, out DamageSpecifier? damage)
+    {
+        damage = null;
+
+        if (!TryComp<DamageableComponent>(target1, out var oldDamage))
+            return false;
+
+        if (!TryComp<MobThresholdsComponent>(target1, out var threshold1) ||
+            !TryComp<MobThresholdsComponent>(target2, out var threshold2))
+            return false;
+
+        if (!TryGetThresholdForState(target1, MobState.Dead, out var ent1DeadThreshold, threshold1))
+            ent1DeadThreshold = 0;
+
+        if (!TryGetThresholdForState(target2, MobState.Dead, out var ent2DeadThreshold, threshold2))
+            ent2DeadThreshold = 0;
+
+        damage = (oldDamage.Damage / ent1DeadThreshold.Value) * ent2DeadThreshold.Value;
+        return true;
+    }
+
+    /// <summary>
+    /// Set a MobState Threshold or create a new one if it doesn't exist
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="damage">Damageable Component owned by the target</param>
+    /// <param name="mobState">MobState Component owned by the target</param>
+    /// <param name="threshold">MobThreshold Component owned by the target</param>
+    public void SetMobStateThreshold(EntityUid target, FixedPoint2 damage, MobState mobState,
+        MobThresholdsComponent? threshold = null)
+    {
+        if (!Resolve(target, ref threshold))
+            return;
+
+        threshold.Thresholds[damage] = mobState;
+        VerifyThresholds(target, threshold);
+    }
+
+    /// <summary>
+    /// Checks to see if we should change states based on thresholds.
+    /// Call this if you change the amount of damagable without triggering a damageChangedEvent or if you change
+    /// </summary>
+    /// <param name="target">Target Entity</param>
+    /// <param name="threshold">Threshold Component owned by the Target</param>
+    /// <param name="mobState">MobState Component owned by the Target</param>
+    /// <param name="damageable">Damageable Component owned by the Target</param>
+    public void VerifyThresholds(EntityUid target, MobThresholdsComponent? threshold = null,
+        MobStateComponent? mobState = null, DamageableComponent? damageable = null)
+    {
+        if (!Resolve(target, ref mobState, ref threshold, ref damageable))
+            return;
+
+        CheckThresholds(target, mobState, threshold, damageable);
+    }
+
+    #endregion
+
+    #region Private Implementation
+
+    private void CheckThresholds(EntityUid target, MobStateComponent mobStateComponent,
+        MobThresholdsComponent thresholdsComponent, DamageableComponent damageableComponent)
+    {
+        foreach (var (threshold, mobState) in thresholdsComponent.Thresholds)
+        {
+            if (damageableComponent.TotalDamage < threshold)
+                continue;
+
+            TriggerThreshold(target, thresholdsComponent.CurrentThresholdState, mobState, mobStateComponent,
+                thresholdsComponent);
+        }
+
+        var ev = new MobThresholdChecked(target, mobStateComponent, thresholdsComponent, damageableComponent);
+        RaiseLocalEvent(target, ref ev, true);
+        UpdateAlerts(target, mobStateComponent.CurrentState, thresholdsComponent, damageableComponent);
+    }
+
+    private void TriggerThreshold(
+        EntityUid target,
+        MobState oldState,
+        MobState newState,
+        MobStateComponent? mobState = null,
+        MobThresholdsComponent? thresholds = null)
+    {
+        if (oldState == newState ||
+            !Resolve(target, ref mobState, ref thresholds))
+        {
+            return;
+        }
+
+        thresholds.CurrentThresholdState = newState;
+        _mobStateSystem.UpdateMobState(target, mobState);
+
+        Dirty(target);
+    }
+
+    private void UpdateAlerts(EntityUid target, MobState currentMobState, MobThresholdsComponent? threshold = null,
+        DamageableComponent? damageable = null)
+    {
+        if (!Resolve(target, ref threshold, ref damageable))
+            return;
+
+        // don't handle alerts if they are managed by another system... BobbySim (soon TM)
+        if (!threshold.TriggersAlerts)
+            return;
+
+        switch (currentMobState)
+        {
+            case MobState.Alive:
+            {
+                var severity = _alerts.GetMinSeverity(AlertType.HumanHealth);
+                if (TryGetIncapPercentage(target, damageable.TotalDamage, out var percentage))
+                {
+                    severity = (short) MathF.Floor(percentage.Value.Float() *
+                                                   _alerts.GetMaxSeverity(AlertType.HumanHealth));
+                }
+
+                _alerts.ShowAlert(target, AlertType.HumanHealth, severity);
+                break;
+            }
+            case MobState.Critical:
+            {
+                _alerts.ShowAlert(target, AlertType.HumanCrit);
+                break;
+            }
+            case MobState.Dead:
+            {
+                _alerts.ShowAlert(target, AlertType.HumanDead);
+                break;
+            }
+            case MobState.Invalid:
+            default:
+                throw new ArgumentOutOfRangeException(nameof(currentMobState), currentMobState, null);
+        }
+    }
+
+    private void OnDamaged(EntityUid target, MobThresholdsComponent mobThresholdsComponent, DamageChangedEvent args)
+    {
+        var mobStateComp = EnsureComp<MobStateComponent>(target);
+        CheckThresholds(target, mobStateComp, mobThresholdsComponent, args.Damageable);
+    }
+
+    private void OnHandleComponentState(EntityUid target, MobThresholdsComponent component,
+        ref ComponentHandleState args)
+    {
+        if (args.Current is not MobThresholdComponentState state)
+            return;
+
+        component.Thresholds = new SortedDictionary<FixedPoint2, MobState>(state.Thresholds);
+        component.CurrentThresholdState = state.CurrentThresholdState;
+    }
+
+    private void OnGetComponentState(EntityUid target, MobThresholdsComponent component, ref ComponentGetState args)
+    {
+        args.State = new MobThresholdComponentState(component.CurrentThresholdState,
+            new Dictionary<FixedPoint2, MobState>(component.Thresholds));
+    }
+
+    private void MobThresholdMapInit(EntityUid target, MobThresholdsComponent component, MapInitEvent args)
+    {
+        // TODO remove when body sim is implemented
+        EnsureComp<MobStateComponent>(target);
+        EnsureComp<DamageableComponent>(target);
+
+        if (!component.Thresholds.TryFirstOrNull(out var newState))
+            return;
+
+        component.CurrentThresholdState = newState.Value.Value;
+
+        TriggerThreshold(target, MobState.Invalid, newState.Value.Value, thresholds: component);
+        UpdateAlerts(target, newState.Value.Value, component);
+    }
+
+    private void MobThresholdShutdown(EntityUid target, MobThresholdsComponent component, ComponentShutdown args)
+    {
+        if (component.TriggersAlerts)
+            _alerts.ClearAlertCategory(target, AlertCategory.Health);
+    }
+
+    private void OnUpdateMobState(EntityUid target, MobThresholdsComponent component, ref UpdateMobStateEvent args)
+    {
+        if (component.CurrentThresholdState != MobState.Invalid)
+            args.State = component.CurrentThresholdState;
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Event that triggers when an entity with a mob threshold is checked
+/// </summary>
+/// <param name="Target">Target entity</param>
+/// <param name="Threshold">Threshold Component owned by the Target</param>
+/// <param name="MobState">MobState Component owned by the Target</param>
+/// <param name="Damageable">Damageable Component owned by the Target</param>
+[ByRefEvent]
+public readonly record struct MobThresholdChecked(EntityUid Target, MobStateComponent MobState,
+    MobThresholdsComponent Threshold, DamageableComponent Damageable)
+{
+}