Add prediction for standing states and mob states (#1937)

Content.Client/GameObjects/Components/Body/BodyManagerComponent.cs

@@ -14,7 +14,7 @@ namespace Content.Client.GameObjects.Components.Body
 {
     [RegisterComponent]
     [ComponentReference(typeof(IDamageableComponent))]
-    [ComponentReference(typeof(IBodyManagerComponent))]
+    [ComponentReference(typeof(ISharedBodyManagerComponent))]
     public class BodyManagerComponent : SharedBodyManagerComponent, IClientDraggable
     {
         [Dependency] private readonly IEntityManager _entityManager = default!;

Content.Client/GameObjects/Components/Mobs/State/CriticalState.cs

@@ -0,0 +1,30 @@
+using Content.Client.GameObjects.EntitySystems;
+using Content.Shared.GameObjects.Components.Damage;
+using Content.Shared.GameObjects.Components.Mobs;
+using Content.Shared.GameObjects.Components.Mobs.State;
+using Robust.Client.GameObjects;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Client.GameObjects.Components.Mobs.State
+{
+    public class CriticalState : SharedCriticalState
+    {
+        public override void EnterState(IEntity entity)
+        {
+            if (entity.TryGetComponent(out AppearanceComponent appearance))
+            {
+                appearance.SetData(DamageStateVisuals.State, DamageState.Critical);
+            }
+
+            EntitySystem.Get<StandingStateSystem>().Down(entity);
+        }
+
+        public override void ExitState(IEntity entity)
+        {
+            EntitySystem.Get<StandingStateSystem>().Standing(entity);
+        }
+
+        public override void UpdateState(IEntity entity) { }
+    }
+}

Content.Client/GameObjects/Components/Mobs/State/DeadState.cs

@@ -0,0 +1,41 @@
+using Content.Client.GameObjects.EntitySystems;
+using Content.Shared.GameObjects.Components.Damage;
+using Content.Shared.GameObjects.Components.Mobs;
+using Content.Shared.GameObjects.Components.Mobs.State;
+using Robust.Client.GameObjects;
+using Robust.Shared.GameObjects.Components;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Client.GameObjects.Components.Mobs.State
+{
+    public class DeadState : SharedDeadState
+    {
+        public override void EnterState(IEntity entity)
+        {
+            if (entity.TryGetComponent(out AppearanceComponent appearance))
+            {
+                appearance.SetData(DamageStateVisuals.State, DamageState.Dead);
+            }
+
+            EntitySystem.Get<StandingStateSystem>().Down(entity);
+
+            if (entity.TryGetComponent(out CollidableComponent collidable))
+            {
+                collidable.CanCollide = false;
+            }
+        }
+
+        public override void ExitState(IEntity entity)
+        {
+            EntitySystem.Get<StandingStateSystem>().Standing(entity);
+
+            if (entity.TryGetComponent(out CollidableComponent collidable))
+            {
+                collidable.CanCollide = true;
+            }
+        }
+
+        public override void UpdateState(IEntity entity) { }
+    }
+}

Content.Client/GameObjects/Components/Mobs/State/MobStateManagerComponent.cs

@@ -0,0 +1,62 @@
+#nullable enable
+using System.Collections.Generic;
+using Content.Shared.GameObjects.Components.Damage;
+using Content.Shared.GameObjects.Components.Mobs.State;
+using Robust.Shared.GameObjects;
+
+namespace Content.Client.GameObjects.Components.Mobs.State
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(SharedMobStateManagerComponent))]
+    public class MobStateManagerComponent : SharedMobStateManagerComponent
+    {
+        private readonly Dictionary<DamageState, IMobState> _behavior = new Dictionary<DamageState, IMobState>
+        {
+            {DamageState.Alive, new NormalState()},
+            {DamageState.Critical, new CriticalState()},
+            {DamageState.Dead, new DeadState()}
+        };
+
+        private DamageState _currentDamageState;
+
+        protected override IReadOnlyDictionary<DamageState, IMobState> Behavior => _behavior;
+
+        public override DamageState CurrentDamageState
+        {
+            get => _currentDamageState;
+            protected set
+            {
+                if (_currentDamageState == value)
+                {
+                    return;
+                }
+
+                if (_currentDamageState != DamageState.Invalid)
+                {
+                    CurrentMobState.ExitState(Owner);
+                }
+
+                _currentDamageState = value;
+                CurrentMobState = Behavior[CurrentDamageState];
+                CurrentMobState.EnterState(Owner);
+
+                Dirty();
+            }
+        }
+
+        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
+        {
+            base.HandleComponentState(curState, nextState);
+
+            if (!(curState is MobStateManagerComponentState state))
+            {
+                return;
+            }
+
+            _currentDamageState = state.DamageState;
+            CurrentMobState.ExitState(Owner);
+            CurrentMobState = Behavior[CurrentDamageState];
+            CurrentMobState.EnterState(Owner);
+        }
+    }
+}

Content.Client/GameObjects/Components/Mobs/State/NormalState.cs

@@ -0,0 +1,25 @@
+using Content.Shared.GameObjects.Components.Damage;
+using Content.Shared.GameObjects.Components.Mobs;
+using Content.Shared.GameObjects.Components.Mobs.State;
+using Robust.Client.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Client.GameObjects.Components.Mobs.State
+{
+    public class NormalState : SharedNormalState
+    {
+        public override void EnterState(IEntity entity)
+        {
+            if (entity.TryGetComponent(out AppearanceComponent appearance))
+            {
+                appearance.SetData(DamageStateVisuals.State, DamageState.Alive);
+            }
+
+            UpdateState(entity);
+        }
+
+        public override void ExitState(IEntity entity) { }
+
+        public override void UpdateState(IEntity entity) { }
+    }
+}

Content.Client/GameObjects/EntitySystems/StandingStateSystem.cs

@@ -0,0 +1,50 @@
+using Content.Shared.Audio;
+using Content.Shared.GameObjects.Components.Rotation;
+using Content.Shared.GameObjects.EntitySystems;
+using Robust.Client.GameObjects;
+using Robust.Client.GameObjects.EntitySystems;
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Client.GameObjects.EntitySystems
+{
+    public class StandingStateSystem : SharedStandingStateSystem
+    {
+        protected override bool OnDown(IEntity entity, bool playSound = true, bool dropItems = true, bool force = false)
+        {
+            if (!entity.TryGetComponent(out AppearanceComponent appearance))
+            {
+                return false;
+            }
+
+            var newState = RotationState.Horizontal;
+            appearance.TryGetData<RotationState>(RotationVisuals.RotationState, out var oldState);
+
+            if (newState != oldState)
+            {
+                appearance.SetData(RotationVisuals.RotationState, newState);
+            }
+
+            if (playSound)
+            {
+                var file = AudioHelpers.GetRandomFileFromSoundCollection("bodyfall");
+                Get<AudioSystem>().Play(file, entity, AudioHelpers.WithVariation(0.25f));
+            }
+
+            return true;
+        }
+
+        protected override bool OnStand(IEntity entity)
+        {
+            if (!entity.TryGetComponent(out AppearanceComponent appearance)) return false;
+
+            appearance.TryGetData<RotationState>(RotationVisuals.RotationState, out var oldState);
+            var newState = RotationState.Vertical;
+
+            if (newState == oldState) return false;
+
+            appearance.SetData(RotationVisuals.RotationState, newState);
+
+            return true;
+        }
+    }
+}