Re-organize all projects (#4166)

Content.Shared/MobState/DamageStateHelpers.cs

@@ -0,0 +1,27 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+
+namespace Content.Shared.MobState
+{
+    public static class DamageStateHelpers
+    {
+        /// <summary>
+        ///     Enumerates over <see cref="DamageState"/>, returning them in order
+        ///     of alive to dead.
+        /// </summary>
+        /// <returns>An enumerable of <see cref="DamageState"/>.</returns>
+        public static IEnumerable<DamageState> AliveToDead()
+        {
+            foreach (DamageState state in Enum.GetValues(typeof(DamageState)))
+            {
+                if (state == DamageState.Invalid)
+                {
+                    continue;
+                }
+
+                yield return state;
+            }
+        }
+    }
+}

Content.Shared/MobState/DamageStateVisuals.cs

@@ -0,0 +1,29 @@
+#nullable enable
+using System;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.MobState
+{
+    [Serializable, NetSerializable]
+    public enum DamageStateVisuals
+    {
+        State
+    }
+
+    /// <summary>
+    ///     Defines what state an <see cref="IEntity"/> is in.
+    ///
+    ///     Ordered from most alive to least alive.
+    ///     To enumerate them in this way see
+    ///     <see cref="DamageStateHelpers.AliveToDead"/>.
+    /// </summary>
+    [Serializable, NetSerializable]
+    public enum DamageState : byte
+    {
+        Invalid = 0,
+        Alive = 1,
+        Critical = 2,
+        Dead = 3
+    }
+}

Content.Shared/MobState/IMobStateComponent.cs

@@ -0,0 +1,50 @@
+#nullable enable
+using System.Diagnostics.CodeAnalysis;
+using Content.Shared.MobState.State;
+using Robust.Shared.GameObjects;
+
+namespace Content.Shared.MobState
+{
+    public interface IMobStateComponent : IComponent
+    {
+        IMobState? CurrentState { get; }
+
+        bool IsAlive();
+
+        bool IsCritical();
+
+        bool IsDead();
+
+        bool IsIncapacitated();
+
+        (IMobState state, int threshold)? GetEarliestIncapacitatedState(int minimumDamage);
+
+        (IMobState state, int threshold)? GetEarliestCriticalState(int minimumDamage);
+
+        (IMobState state, int threshold)? GetEarliestDeadState(int minimumDamage);
+
+        (IMobState state, int threshold)? GetPreviousCriticalState(int maximumDamage);
+
+        bool TryGetEarliestIncapacitatedState(
+            int minimumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold);
+
+        bool TryGetEarliestCriticalState(
+            int minimumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold);
+
+        bool TryGetEarliestDeadState(
+            int minimumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold);
+
+        bool TryGetPreviousCriticalState(
+            int maximumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold);
+
+        void UpdateState(int damage, bool syncing = false);
+    }
+}

Content.Shared/MobState/MobStateChangedMessage.cs

@@ -0,0 +1,27 @@
+#nullable enable
+using Content.Shared.MobState.State;
+using Robust.Shared.GameObjects;
+
+namespace Content.Shared.MobState
+{
+    public class MobStateChangedMessage : ComponentMessage
+    {
+        public MobStateChangedMessage(
+            IMobStateComponent component,
+            IMobState? oldMobState,
+            IMobState currentMobState)
+        {
+            Component = component;
+            OldMobState = oldMobState;
+            CurrentMobState = currentMobState;
+        }
+
+        public IEntity Entity => Component.Owner;
+
+        public IMobStateComponent Component { get; }
+
+        public IMobState? OldMobState { get; }
+
+        public IMobState CurrentMobState { get; }
+    }
+}

Content.Shared/MobState/State/BaseMobState.cs

@@ -0,0 +1,98 @@
+#nullable enable
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Shared.MobState.State
+{
+    [ImplicitDataDefinitionForInheritors]
+    public abstract class BaseMobState : IMobState
+    {
+        protected abstract DamageState DamageState { get; }
+
+        public virtual bool IsAlive()
+        {
+            return DamageState == DamageState.Alive;
+        }
+
+        public virtual bool IsCritical()
+        {
+            return DamageState == DamageState.Critical;
+        }
+
+        public virtual bool IsDead()
+        {
+            return DamageState == DamageState.Dead;
+        }
+
+        public virtual bool IsIncapacitated()
+        {
+            return IsCritical() || IsDead();
+        }
+
+        public virtual void EnterState(IEntity entity) { }
+
+        public virtual void ExitState(IEntity entity) { }
+
+        public virtual void UpdateState(IEntity entity, int threshold) { }
+
+        public virtual bool CanInteract()
+        {
+            return true;
+        }
+
+        public virtual bool CanMove()
+        {
+            return true;
+        }
+
+        public virtual bool CanUse()
+        {
+            return true;
+        }
+
+        public virtual bool CanThrow()
+        {
+            return true;
+        }
+
+        public virtual bool CanSpeak()
+        {
+            return true;
+        }
+
+        public virtual bool CanDrop()
+        {
+            return true;
+        }
+
+        public virtual bool CanPickup()
+        {
+            return true;
+        }
+
+        public virtual bool CanEmote()
+        {
+            return true;
+        }
+
+        public virtual bool CanAttack()
+        {
+            return true;
+        }
+
+        public virtual bool CanEquip()
+        {
+            return true;
+        }
+
+        public virtual bool CanUnequip()
+        {
+            return true;
+        }
+
+        public virtual bool CanChangeDirection()
+        {
+            return true;
+        }
+    }
+}

Content.Shared/MobState/State/IMobState.cs

@@ -0,0 +1,42 @@
+#nullable enable
+using Content.Shared.ActionBlocker;
+using Robust.Shared.GameObjects;
+
+namespace Content.Shared.MobState.State
+{
+    /// <summary>
+    ///     Defines the blocking effects of an associated <see cref="DamageState"/>
+    ///     (i.e. Normal, Critical, Dead) and what effects to apply upon entering or
+    ///     exiting the state.
+    /// </summary>
+    public interface IMobState : IActionBlocker
+    {
+        bool IsAlive();
+
+        bool IsCritical();
+
+        bool IsDead();
+
+        /// <summary>
+        ///     Checks if the mob is in a critical or dead state.
+        ///     See <see cref="IsCritical"/> and <see cref="IsDead"/>.
+        /// </summary>
+        /// <returns>true if it is, false otherwise.</returns>
+        bool IsIncapacitated();
+
+        /// <summary>
+        ///     Called when this state is entered.
+        /// </summary>
+        void EnterState(IEntity entity);
+
+        /// <summary>
+        ///     Called when this state is left for a different state.
+        /// </summary>
+        void ExitState(IEntity entity);
+
+        /// <summary>
+        ///     Called when this state is updated.
+        /// </summary>
+        void UpdateState(IEntity entity, int threshold);
+    }
+}

Content.Shared/MobState/State/SharedCriticalMobState.cs

@@ -0,0 +1,92 @@
+#nullable enable
+using Content.Shared.Alert;
+using Content.Shared.Standing;
+using Robust.Shared.GameObjects;
+
+namespace Content.Shared.MobState.State
+{
+    /// <summary>
+    ///     A state in which an entity is disabled from acting due to sufficient damage (considered unconscious).
+    /// </summary>
+    public abstract class SharedCriticalMobState : BaseMobState
+    {
+        protected override DamageState DamageState => DamageState.Critical;
+
+        public override void EnterState(IEntity entity)
+        {
+            base.EnterState(entity);
+
+            if (entity.TryGetComponent(out SharedAlertsComponent? status))
+            {
+                status.ShowAlert(AlertType.HumanCrit); // TODO: combine humancrit-0 and humancrit-1 into a gif and display it
+            }
+        }
+
+        public override void ExitState(IEntity entity)
+        {
+            base.ExitState(entity);
+
+            EntitySystem.Get<SharedStandingStateSystem>().Standing(entity);
+        }
+
+        public override bool CanInteract()
+        {
+            return false;
+        }
+
+        public override bool CanMove()
+        {
+            return false;
+        }
+
+        public override bool CanUse()
+        {
+            return false;
+        }
+
+        public override bool CanThrow()
+        {
+            return false;
+        }
+
+        public override bool CanSpeak()
+        {
+            return false;
+        }
+
+        public override bool CanDrop()
+        {
+            return false;
+        }
+
+        public override bool CanPickup()
+        {
+            return false;
+        }
+
+        public override bool CanEmote()
+        {
+            return false;
+        }
+
+        public override bool CanAttack()
+        {
+            return false;
+        }
+
+        public override bool CanEquip()
+        {
+            return false;
+        }
+
+        public override bool CanUnequip()
+        {
+            return false;
+        }
+
+        public override bool CanChangeDirection()
+        {
+            return false;
+        }
+    }
+}

Content.Shared/MobState/State/SharedDeadMobState.cs

@@ -0,0 +1,95 @@
+using Robust.Shared.GameObjects;
+
+namespace Content.Shared.MobState.State
+{
+    public abstract class SharedDeadMobState : BaseMobState
+    {
+        protected override DamageState DamageState => DamageState.Dead;
+
+        public override void EnterState(IEntity entity)
+        {
+            base.EnterState(entity);
+            var wake = entity.EnsureComponent<CollisionWakeComponent>();
+            wake.Enabled = true;
+        }
+
+        public override void ExitState(IEntity entity)
+        {
+            base.ExitState(entity);
+            if (entity.HasComponent<CollisionWakeComponent>())
+            {
+                entity.RemoveComponent<CollisionWakeComponent>();
+            }
+        }
+
+        public override bool CanInteract()
+        {
+            return false;
+        }
+
+        public override bool CanMove()
+        {
+            return false;
+        }
+
+        public override bool CanUse()
+        {
+            return false;
+        }
+
+        public override bool CanThrow()
+        {
+            return false;
+        }
+
+        public override bool CanSpeak()
+        {
+            return false;
+        }
+
+        public override bool CanDrop()
+        {
+            return false;
+        }
+
+        public override bool CanPickup()
+        {
+            return false;
+        }
+
+        public override bool CanEmote()
+        {
+            return false;
+        }
+
+        public override bool CanAttack()
+        {
+            return false;
+        }
+
+        public override bool CanEquip()
+        {
+            return false;
+        }
+
+        public override bool CanUnequip()
+        {
+            return false;
+        }
+
+        public override bool CanChangeDirection()
+        {
+            return false;
+        }
+
+        public bool CanShiver()
+        {
+            return false;
+        }
+
+        public bool CanSweat()
+        {
+            return false;
+        }
+    }
+}

Content.Shared/MobState/State/SharedMobStateComponent.cs

@@ -0,0 +1,408 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Alert;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Components;
+using Content.Shared.NetIDs;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Players;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Shared.MobState.State
+{
+    /// <summary>
+    ///     When attached to an <see cref="IDamageableComponent"/>,
+    ///     this component will handle critical and death behaviors for mobs.
+    ///     Additionally, it handles sending effects to clients
+    ///     (such as blur effect for unconsciousness) and managing the health HUD.
+    /// </summary>
+    public abstract class SharedMobStateComponent : Component, IMobStateComponent, IActionBlocker
+    {
+        public override string Name => "MobState";
+
+        public override uint? NetID => ContentNetIDs.MOB_STATE;
+
+        /// <summary>
+        ///     States that this <see cref="SharedMobStateComponent"/> mapped to
+        ///     the amount of damage at which they are triggered.
+        ///     A threshold is reached when the total damage of an entity is equal
+        ///     to or higher than the int key, but lower than the next threshold.
+        ///     Ordered from lowest to highest.
+        /// </summary>
+        [ViewVariables]
+        [DataField("thresholds")]
+        private readonly SortedDictionary<int, IMobState> _lowestToHighestStates = default!;
+
+        // TODO Remove Nullability?
+        [ViewVariables]
+        public IMobState? CurrentState { get; private set; }
+
+        [ViewVariables]
+        public int? CurrentThreshold { get; private set; }
+
+        public IEnumerable<KeyValuePair<int, IMobState>> _highestToLowestStates => _lowestToHighestStates.Reverse();
+
+        protected override void Startup()
+        {
+            base.Startup();
+
+            if (CurrentState != null && CurrentThreshold != null)
+            {
+                UpdateState(null, (CurrentState, CurrentThreshold.Value));
+            }
+        }
+
+        public override void OnRemove()
+        {
+            if (Owner.TryGetComponent(out SharedAlertsComponent? status))
+            {
+                status.ClearAlert(AlertType.HumanHealth);
+            }
+
+            base.OnRemove();
+        }
+
+        public override ComponentState GetComponentState(ICommonSession player)
+        {
+            return new MobStateComponentState(CurrentThreshold);
+        }
+
+        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
+        {
+            base.HandleComponentState(curState, nextState);
+
+            if (curState is not MobStateComponentState state)
+            {
+                return;
+            }
+
+            if (CurrentThreshold == state.CurrentThreshold)
+            {
+                return;
+            }
+
+            if (state.CurrentThreshold == null)
+            {
+                RemoveState(true);
+            }
+            else
+            {
+                UpdateState(state.CurrentThreshold.Value, true);
+            }
+        }
+
+        public override void HandleMessage(ComponentMessage message, IComponent? component)
+        {
+            base.HandleMessage(message, component);
+
+            switch (message)
+            {
+                case DamageChangedMessage msg:
+                    if (msg.Damageable.Owner != Owner)
+                    {
+                        break;
+                    }
+
+                    UpdateState(msg.Damageable.TotalDamage);
+
+                    break;
+            }
+        }
+
+        public bool IsAlive()
+        {
+            return CurrentState?.IsAlive() ?? false;
+        }
+
+        public bool IsCritical()
+        {
+            return CurrentState?.IsCritical() ?? false;
+        }
+
+        public bool IsDead()
+        {
+            return CurrentState?.IsDead() ?? false;
+        }
+
+        public bool IsIncapacitated()
+        {
+            return CurrentState?.IsIncapacitated() ?? false;
+        }
+
+        public (IMobState state, int threshold)? GetState(int damage)
+        {
+            foreach (var (threshold, state) in _lowestToHighestStates.Reverse())
+            {
+                if (damage >= threshold)
+                {
+                    return (state, threshold);
+                }
+            }
+
+            return null;
+        }
+
+        public bool TryGetState(
+            int damage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold)
+        {
+            var highestState = GetState(damage);
+
+            if (highestState == null)
+            {
+                state = default;
+                threshold = default;
+                return false;
+            }
+
+            (state, threshold) = highestState.Value;
+            return true;
+        }
+
+        private (IMobState state, int threshold)? GetEarliestState(int minimumDamage, Predicate<IMobState> predicate)
+        {
+            foreach (var (threshold, state) in _lowestToHighestStates)
+            {
+                if (threshold < minimumDamage ||
+                    !predicate(state))
+                {
+                    continue;
+                }
+
+                return (state, threshold);
+            }
+
+            return null;
+        }
+
+        private (IMobState state, int threshold)? GetPreviousState(int maximumDamage, Predicate<IMobState> predicate)
+        {
+            foreach (var (threshold, state) in _highestToLowestStates)
+            {
+                if (threshold > maximumDamage ||
+                    !predicate(state))
+                {
+                    continue;
+                }
+
+                return (state, threshold);
+            }
+
+            return null;
+        }
+
+        public (IMobState state, int threshold)? GetEarliestCriticalState(int minimumDamage)
+        {
+            return GetEarliestState(minimumDamage, s => s.IsCritical());
+        }
+
+        public (IMobState state, int threshold)? GetEarliestIncapacitatedState(int minimumDamage)
+        {
+            return GetEarliestState(minimumDamage, s => s.IsIncapacitated());
+        }
+
+        public (IMobState state, int threshold)? GetEarliestDeadState(int minimumDamage)
+        {
+            return GetEarliestState(minimumDamage, s => s.IsDead());
+        }
+
+        public (IMobState state, int threshold)? GetPreviousCriticalState(int minimumDamage)
+        {
+            return GetPreviousState(minimumDamage, s => s.IsCritical());
+        }
+
+        private bool TryGetState(
+            (IMobState state, int threshold)? tuple,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold)
+        {
+            if (tuple == null)
+            {
+                state = default;
+                threshold = default;
+                return false;
+            }
+
+            (state, threshold) = tuple.Value;
+            return true;
+        }
+
+        public bool TryGetEarliestCriticalState(
+            int minimumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold)
+        {
+            var earliestState = GetEarliestCriticalState(minimumDamage);
+
+            return TryGetState(earliestState, out state, out threshold);
+        }
+
+        public bool TryGetEarliestIncapacitatedState(
+            int minimumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold)
+        {
+            var earliestState = GetEarliestIncapacitatedState(minimumDamage);
+
+            return TryGetState(earliestState, out state, out threshold);
+        }
+
+        public bool TryGetEarliestDeadState(
+            int minimumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold)
+        {
+            var earliestState = GetEarliestDeadState(minimumDamage);
+
+            return TryGetState(earliestState, out state, out threshold);
+        }
+
+        public bool TryGetPreviousCriticalState(
+            int maximumDamage,
+            [NotNullWhen(true)] out IMobState? state,
+            out int threshold)
+        {
+            var earliestState = GetPreviousCriticalState(maximumDamage);
+
+            return TryGetState(earliestState, out state, out threshold);
+        }
+
+        private void RemoveState(bool syncing = false)
+        {
+            var old = CurrentState;
+            CurrentState = null;
+            CurrentThreshold = null;
+
+            UpdateState(old, null);
+
+            if (!syncing)
+            {
+                Dirty();
+            }
+        }
+
+        public void UpdateState(int damage, bool syncing = false)
+        {
+            if (!TryGetState(damage, out var newState, out var threshold))
+            {
+                return;
+            }
+
+            UpdateState(CurrentState, (newState, threshold));
+
+            if (!syncing)
+            {
+                Dirty();
+            }
+        }
+
+        private void UpdateState(IMobState? old, (IMobState state, int threshold)? current)
+        {
+            if (!current.HasValue)
+            {
+                old?.ExitState(Owner);
+                return;
+            }
+
+            var (state, threshold) = current.Value;
+
+            CurrentThreshold = threshold;
+
+            if (state == old)
+            {
+                state.UpdateState(Owner, threshold);
+                return;
+            }
+
+            old?.ExitState(Owner);
+
+            CurrentState = state;
+
+            state.EnterState(Owner);
+            state.UpdateState(Owner, threshold);
+
+            var message = new MobStateChangedMessage(this, old, state);
+
+            SendMessage(message);
+            Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, message);
+        }
+
+        bool IActionBlocker.CanInteract()
+        {
+            return CurrentState?.CanInteract() ?? true;
+        }
+
+        bool IActionBlocker.CanMove()
+        {
+            return CurrentState?.CanMove() ?? true;
+        }
+
+        bool IActionBlocker.CanUse()
+        {
+            return CurrentState?.CanUse() ?? true;
+        }
+
+        bool IActionBlocker.CanThrow()
+        {
+            return CurrentState?.CanThrow() ?? true;
+        }
+
+        bool IActionBlocker.CanSpeak()
+        {
+            return CurrentState?.CanSpeak() ?? true;
+        }
+
+        bool IActionBlocker.CanDrop()
+        {
+            return CurrentState?.CanDrop() ?? true;
+        }
+
+        bool IActionBlocker.CanPickup()
+        {
+            return CurrentState?.CanPickup() ?? true;
+        }
+
+        bool IActionBlocker.CanEmote()
+        {
+            return CurrentState?.CanEmote() ?? true;
+        }
+
+        bool IActionBlocker.CanAttack()
+        {
+            return CurrentState?.CanAttack() ?? true;
+        }
+
+        bool IActionBlocker.CanEquip()
+        {
+            return CurrentState?.CanEquip() ?? true;
+        }
+
+        bool IActionBlocker.CanUnequip()
+        {
+            return CurrentState?.CanUnequip() ?? true;
+        }
+
+        bool IActionBlocker.CanChangeDirection()
+        {
+            return CurrentState?.CanChangeDirection() ?? true;
+        }
+    }
+
+    [Serializable, NetSerializable]
+    public class MobStateComponentState : ComponentState
+    {
+        public readonly int? CurrentThreshold;
+
+        public MobStateComponentState(int? currentThreshold) : base(ContentNetIDs.MOB_STATE)
+        {
+            CurrentThreshold = currentThreshold;
+        }
+    }
+}

Content.Shared/MobState/State/SharedNormalMobState.cs

@@ -0,0 +1,72 @@
+#nullable enable
+
+namespace Content.Shared.MobState.State
+{
+    /// <summary>
+    ///     The standard state an entity is in; no negative effects.
+    /// </summary>
+    public abstract class SharedNormalMobState : BaseMobState
+    {
+        protected override DamageState DamageState => DamageState.Alive;
+
+        public override bool CanInteract()
+        {
+            return true;
+        }
+
+        public override bool CanMove()
+        {
+            return true;
+        }
+
+        public override bool CanUse()
+        {
+            return true;
+        }
+
+        public override bool CanThrow()
+        {
+            return true;
+        }
+
+        public override bool CanSpeak()
+        {
+            return true;
+        }
+
+        public override bool CanDrop()
+        {
+            return true;
+        }
+
+        public override bool CanPickup()
+        {
+            return true;
+        }
+
+        public override bool CanEmote()
+        {
+            return true;
+        }
+
+        public override bool CanAttack()
+        {
+            return true;
+        }
+
+        public override bool CanEquip()
+        {
+            return true;
+        }
+
+        public override bool CanUnequip()
+        {
+            return true;
+        }
+
+        public override bool CanChangeDirection()
+        {
+            return true;
+        }
+    }
+}