Add slipping prediction (#1440)

Content.Client/GameObjects/Components/Mobs/ClientStatusEffectsComponent.cs

@@ -1,29 +1,26 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Content.Client.UserInterface;
 using Content.Client.Utility;
 using Content.Shared.GameObjects.Components.Mobs;
-using Content.Shared.Input;
 using Robust.Client.GameObjects;
 using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.Interfaces.UserInterface;
 using Robust.Client.Player;
-using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Network;
 using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Maths;
-using Robust.Shared.Players;
 
 namespace Content.Client.GameObjects.Components.Mobs
 {
     /// <inheritdoc/>
     [RegisterComponent]
+    [ComponentReference(typeof(SharedStatusEffectsComponent))]
     public sealed class ClientStatusEffectsComponent : SharedStatusEffectsComponent
     {
 #pragma warning disable 649
@@ -65,7 +62,12 @@ namespace Content.Client.GameObjects.Components.Mobs
         public override void HandleComponentState(ComponentState curState, ComponentState nextState)
         {
             base.HandleComponentState(curState, nextState);
-            if (!(curState is StatusEffectComponentState state) || _status == state.StatusEffects) return;
+
+            if (!(curState is StatusEffectComponentState state) || _status == state.StatusEffects)
+            {
+                return;
+            }
+
             _status = state.StatusEffects;
             UpdateStatusEffects();
         }
@@ -154,5 +156,16 @@ namespace Content.Client.GameObjects.Components.Mobs
                 cooldownGraphic.Visible = ratio > -1f;
             }
         }
+
+        public override void ChangeStatusEffect(StatusEffect effect, string icon, (TimeSpan, TimeSpan)? cooldown)
+        {
+            _status[effect] = new StatusEffectStatus()
+            {
+                Icon = icon,
+                Cooldown = cooldown
+            };
+
+            Dirty();
+        }
     }
 }

Content.Client/GameObjects/Components/Mobs/StunnableComponent.cs

@@ -1,7 +1,10 @@
 #nullable enable
+using Content.Shared.Audio;
 using Content.Shared.GameObjects.Components.Mobs;
 using Content.Shared.GameObjects.Components.Movement;
+using Robust.Client.GameObjects.EntitySystems;
 using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects.Systems;
 
 namespace Content.Client.GameObjects.Components.Mobs
 {
@@ -9,13 +12,11 @@ namespace Content.Client.GameObjects.Components.Mobs
     [ComponentReference(typeof(SharedStunnableComponent))]
     public class StunnableComponent : SharedStunnableComponent
     {
-        private bool _stunned;
+        protected override void OnInteractHand()
-        private bool _knockedDown;
+        {
-        private bool _slowedDown;
+            EntitySystem.Get<AudioSystem>()
-
+                .Play("/Audio/Effects/thudswoosh.ogg", Owner, AudioHelpers.WithVariation(0.25f));
-        public override bool Stunned => _stunned;
+        }
-        public override bool KnockedDown => _knockedDown;
-        public override bool SlowedDown => _slowedDown;
 
         public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
         {
@@ -26,9 +27,9 @@ namespace Content.Client.GameObjects.Components.Mobs
                 return;
             }
 
-            _stunned = state.Stunned;
+            StunnedTimer = state.StunnedTimer;
-            _knockedDown = state.KnockedDown;
+            KnockdownTimer = state.KnockdownTimer;
-            _slowedDown = state.SlowedDown;
+            SlowdownTimer = state.SlowdownTimer;
 
             WalkModifierOverride = state.WalkModifierOverride;
             RunModifierOverride = state.RunModifierOverride;

Content.Client/GameObjects/Components/Movement/SlipperyComponent.cs

@@ -0,0 +1,11 @@
+using Content.Shared.GameObjects.Components.Movement;
+using Robust.Shared.GameObjects;
+
+namespace Content.Client.GameObjects.Components.Movement
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(SharedSlipperyComponent))]
+    public class SlipperyComponent : SharedSlipperyComponent
+    {
+    }
+}

Content.Client/IgnoredComponents.cs

@@ -128,7 +128,6 @@
             "StressTestMovement",
             "Toys",
             "SurgeryTool",
-            "Slippery",
             "EmitSoundOnThrow",
             "Flash",
             "DamageOnToolInteract",

Content.Server/GameObjects/Components/Mobs/ServerStatusEffectsComponent.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using Content.Server.GameObjects.Components.Buckle;
 using Content.Shared.GameObjects.Components.Mobs;
-using JetBrains.Annotations;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Interfaces.Network;
 using Robust.Shared.Players;
@@ -47,10 +46,11 @@ namespace Content.Server.GameObjects.Components.Mobs
             Dirty();
         }
 
-        public void ChangeStatusEffect(StatusEffect effect, string icon, ValueTuple<TimeSpan, TimeSpan>? cooldown)
+        public override void ChangeStatusEffect(StatusEffect effect, string icon, ValueTuple<TimeSpan, TimeSpan>? cooldown)
         {
             _statusEffects[effect] = new StatusEffectStatus()
                 {Icon = icon, Cooldown = cooldown};
+
             Dirty();
         }
 

Content.Server/GameObjects/Components/Mobs/StunnableComponent.cs

@@ -1,248 +1,95 @@
-using System;
+using Content.Server.Mobs;
-using System.Threading;
-using Content.Server.Mobs;
-using Content.Shared.Audio;
 using Content.Shared.GameObjects.Components.Mobs;
-using Robust.Server.GameObjects.EntitySystems;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Systems;
 using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
-using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
 using Timer = Robust.Shared.Timers.Timer;
 using Content.Shared.GameObjects.Components.Movement;
-using Content.Shared.Interfaces.GameObjects.Components;
-using Math = CannyFastMath.Math;
-using MathF = CannyFastMath.MathF;
 
 namespace Content.Server.GameObjects.Components.Mobs
 {
     [RegisterComponent]
     [ComponentReference(typeof(SharedStunnableComponent))]
-    public class StunnableComponent : SharedStunnableComponent, IInteractHand
+    public class StunnableComponent : SharedStunnableComponent
     {
 #pragma warning disable 649
         [Dependency] private IGameTiming _gameTiming;
 #pragma warning restore 649
 
-        private TimeSpan? _lastStun;
+        protected override void OnKnockdown()
-
-        [ViewVariables] public TimeSpan? StunStart => _lastStun;
-
-        [ViewVariables]
-        public TimeSpan? StunEnd => _lastStun == null
-            ? (TimeSpan?) null
-            : _gameTiming.CurTime +
-              (TimeSpan.FromSeconds(Math.Max(_stunnedTimer, Math.Max(_knockdownTimer, _slowdownTimer))));
-
-        private const int StunLevels = 8;
-
-        private bool _canHelp = true;
-        private float _stunCap = 20f;
-        private float _knockdownCap = 20f;
-        private float _slowdownCap = 20f;
-        private float _helpKnockdownRemove = 1f;
-        private float _helpInterval = 1f;
-
-        private float _stunnedTimer = 0f;
-        private float _knockdownTimer = 0f;
-        private float _slowdownTimer = 0f;
-
-        private string _stunTexture;
-        private CancellationTokenSource _statusRemoveCancellation = new CancellationTokenSource();
-
-        [ViewVariables] public override bool Stunned => _stunnedTimer > 0f;
-        [ViewVariables] public override bool KnockedDown => _knockdownTimer > 0f;
-        [ViewVariables] public override bool SlowedDown => _slowdownTimer > 0f;
-        [ViewVariables] public float StunCap => _stunCap;
-        [ViewVariables] public float KnockdownCap => _knockdownCap;
-        [ViewVariables] public float SlowdownCap => _slowdownCap;
-
-        public override void ExposeData(ObjectSerializer serializer)
         {
-            base.ExposeData(serializer);
-            serializer.DataField(ref _stunCap, "stunCap", 20f);
-            serializer.DataField(ref _knockdownCap, "knockdownCap", 20f);
-            serializer.DataField(ref _slowdownCap, "slowdownCap", 20f);
-            serializer.DataField(ref _helpInterval, "helpInterval", 1f);
-            serializer.DataField(ref _helpKnockdownRemove, "helpKnockdownRemove", 1f);
-            serializer.DataField(ref _stunTexture, "stunTexture",
-                "/Textures/Objects/Weapons/Melee/stunbaton.rsi/stunbaton_off.png");
-        }
-
-        /// <summary>
-        ///     Stuns the entity, disallowing it from doing many interactions temporarily.
-        /// </summary>
-        /// <param name="seconds">How many seconds the mob will stay stunned</param>
-        public void Stun(float seconds)
-        {
-            seconds = MathF.Min(_stunnedTimer + (seconds * StunTimeModifier), _stunCap);
-
-            if (seconds <= 0f)
-                return;
-
-            StandingStateHelper.DropAllItemsInHands(Owner, false);
-
-            _stunnedTimer = seconds;
-            _lastStun = _gameTiming.CurTime;
-
-            SetStatusEffect();
-            Dirty();
-        }
-
-        /// <summary>
-        ///     Knocks down the mob, making it fall to the ground.
-        /// </summary>
-        /// <param name="seconds">How many seconds the mob will stay on the ground</param>
-        public void Knockdown(float seconds)
-        {
-            seconds = MathF.Min(_knockdownTimer + (seconds * KnockdownTimeModifier), _knockdownCap);
-
-            if (seconds <= 0f)
-            {
-                return;
-            }
-
             StandingStateHelper.Down(Owner);
-
-            _knockdownTimer = seconds;
-            _lastStun = _gameTiming.CurTime;
-
-            SetStatusEffect();
-            Dirty();
         }
 
-        /// <summary>
-        ///     Applies knockdown and stun to the mob temporarily
-        /// </summary>
-        /// <param name="seconds">How many seconds the mob will be paralyzed</param>
-        public void Paralyze(float seconds)
-        {
-            Stun(seconds);
-            Knockdown(seconds);
-        }
-
-        /// <summary>
-        ///     Slows down the mob's walking/running speed temporarily
-        /// </summary>
-        /// <param name="seconds">How many seconds the mob will be slowed down</param>
-        /// <param name="walkModifierOverride">Walk speed modifier. Set to 0 or negative for default value. (0.5f)</param>
-        /// <param name="runModifierOverride">Run speed modifier. Set to 0 or negative for default value. (0.5f)</param>
-        public void Slowdown(float seconds, float walkModifierOverride = 0f, float runModifierOverride = 0f)
-        {
-            seconds = MathF.Min(_slowdownTimer + (seconds * SlowdownTimeModifier), _slowdownCap);
-
-            if (seconds <= 0f)
-                return;
-
-            WalkModifierOverride = walkModifierOverride;
-            RunModifierOverride = runModifierOverride;
-
-            _slowdownTimer = seconds;
-            _lastStun = _gameTiming.CurTime;
-
-            if (Owner.TryGetComponent(out MovementSpeedModifierComponent movement))
-                movement.RefreshMovementSpeedModifiers();
-
-            SetStatusEffect();
-            Dirty();
-        }
-
-        /// <summary>
-        ///     Used when
-        /// </summary>
         public void CancelAll()
         {
-            _knockdownTimer = 0f;
+            KnockdownTimer = 0f;
-            _stunnedTimer = 0f;
+            StunnedTimer = 0f;
             Dirty();
         }
 
-        public bool InteractHand(InteractHandEventArgs eventArgs)
-        {
-            if (!_canHelp || !KnockedDown)
-                return false;
-
-            _canHelp = false;
-            Timer.Spawn(((int) _helpInterval * 1000), () => _canHelp = true);
-
-            EntitySystem.Get<AudioSystem>()
-                .PlayFromEntity("/Audio/Effects/thudswoosh.ogg", Owner, AudioHelpers.WithVariation(0.25f));
-
-            _knockdownTimer -= _helpKnockdownRemove;
-
-            SetStatusEffect();
-
-            Dirty();
-            return true;
-        }
-
-        private void SetStatusEffect()
-        {
-            if (!Owner.TryGetComponent(out ServerStatusEffectsComponent status))
-                return;
-
-            status.ChangeStatusEffect(StatusEffect.Stun, _stunTexture,
-                (StunStart == null || StunEnd == null) ? default : (StunStart.Value, StunEnd.Value));
-            _statusRemoveCancellation.Cancel();
-            _statusRemoveCancellation = new CancellationTokenSource();
-        }
-
         public void ResetStuns()
         {
-            _stunnedTimer = 0f;
+            StunnedTimer = 0f;
-            _slowdownTimer = 0f;
+            SlowdownTimer = 0f;
 
             if (KnockedDown)
+            {
                 StandingStateHelper.Standing(Owner);
+            }
 
-            _knockdownTimer = 0f;
+            KnockdownTimer = 0f;
         }
 
         public void Update(float delta)
         {
             if (Stunned)
             {
-                _stunnedTimer -= delta;
+                StunnedTimer -= delta;
 
-                if (_stunnedTimer <= 0)
+                if (StunnedTimer <= 0)
                 {
-                    _stunnedTimer = 0f;
+                    StunnedTimer = 0f;
                     Dirty();
                 }
             }
 
             if (KnockedDown)
             {
-                _knockdownTimer -= delta;
+                KnockdownTimer -= delta;
 
-                if (_knockdownTimer <= 0f)
+                if (KnockdownTimer <= 0f)
                 {
                     StandingStateHelper.Standing(Owner);
 
-                    _knockdownTimer = 0f;
+                    KnockdownTimer = 0f;
                     Dirty();
                 }
             }
 
             if (SlowedDown)
             {
-                _slowdownTimer -= delta;
+                SlowdownTimer -= delta;
 
-                if (_slowdownTimer <= 0f)
+                if (SlowdownTimer <= 0f)
                 {
-                    _slowdownTimer = 0f;
+                    SlowdownTimer = 0f;
 
                     if (Owner.TryGetComponent(out MovementSpeedModifierComponent movement))
+                    {
                         movement.RefreshMovementSpeedModifiers();
+                    }
+
                     Dirty();
                 }
             }
 
             if (!StunStart.HasValue || !StunEnd.HasValue ||
                 !Owner.TryGetComponent(out ServerStatusEffectsComponent status))
+            {
                 return;
+            }
 
             var start = StunStart.Value;
             var end = StunEnd.Value;
@@ -252,73 +99,15 @@ namespace Content.Server.GameObjects.Components.Mobs
 
             if (progress >= length)
             {
-                Timer.Spawn(250, () => status.RemoveStatusEffect(StatusEffect.Stun), _statusRemoveCancellation.Token);
+                Timer.Spawn(250, () => status.RemoveStatusEffect(StatusEffect.Stun), StatusRemoveCancellation.Token);
-                _lastStun = null;
+                LastStun = null;
-            }
-        }
-
-        public float StunTimeModifier
-        {
-            get
-            {
-                var modifier = 1.0f;
-                var components = Owner.GetAllComponents<IStunModifier>();
-
-                foreach (var component in components)
-                {
-                    modifier *= component.StunTimeModifier;
-                }
-
-                return modifier;
-            }
-        }
-
-        public float KnockdownTimeModifier
-        {
-            get
-            {
-                var modifier = 1.0f;
-                var components = Owner.GetAllComponents<IStunModifier>();
-
-                foreach (var component in components)
-                {
-                    modifier *= component.KnockdownTimeModifier;
-                }
-
-                return modifier;
-            }
-        }
-
-        public float SlowdownTimeModifier
-        {
-            get
-            {
-                var modifier = 1.0f;
-                var components = Owner.GetAllComponents<IStunModifier>();
-
-                foreach (var component in components)
-                {
-                    modifier *= component.SlowdownTimeModifier;
-                }
-
-                return modifier;
             }
         }
 
         public override ComponentState GetComponentState()
         {
-            return new StunnableComponentState(Stunned, KnockedDown, SlowedDown, WalkModifierOverride,
+            return new StunnableComponentState(StunnedTimer, KnockdownTimer, SlowdownTimer, WalkModifierOverride,
                 RunModifierOverride);
         }
     }
-
-    /// <summary>
-    ///     This interface allows components to multiply the time in seconds of various stuns by a number.
-    /// </summary>
-    public interface IStunModifier
-    {
-        float StunTimeModifier => 1.0f;
-        float KnockdownTimeModifier => 1.0f;
-        float SlowdownTimeModifier => 1.0f;
-    }
 }

Content.Server/GameObjects/Components/Movement/SlipperyComponent.cs

@@ -1,118 +1,36 @@
-using System.Collections.Generic;
+using Content.Shared.Audio;
-using System.Timers;
+using Content.Shared.GameObjects.Components.Movement;
-using Content.Server.GameObjects.Components.Mobs;
-using Content.Server.Throw;
-using Content.Shared.Audio;
-using Content.Shared.GameObjects.EntitySystems;
-using Content.Shared.Physics;
 using Robust.Server.GameObjects.EntitySystems;
-using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components;
 using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Log;
-using Robust.Shared.Map;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
-using Timer = Robust.Shared.Timers.Timer;
 
 namespace Content.Server.GameObjects.Components.Movement
 {
     [RegisterComponent]
-    public class SlipperyComponent : Component, ICollideBehavior
+    [ComponentReference(typeof(SharedSlipperyComponent))]
+    public class SlipperyComponent : SharedSlipperyComponent
     {
-        [Dependency] private IEntityManager _entityManager = default!;
-
-        public override string Name => "Slippery";
-
-        private List<EntityUid> _slipped = new List<EntityUid>();
-
-        /// <summary>
-        ///     How many seconds the mob will be paralyzed for.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        public float ParalyzeTime { get; set; } = 3f;
-
-        /// <summary>
-        ///     Percentage of shape intersection for a slip to occur.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        public float IntersectPercentage { get; set; } = 0.3f;
-
-        /// <summary>
-        ///     Entities will only be slipped if their speed exceeds this limit.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        public float RequiredSlipSpeed { get; set; } = 0f;
-
         /// <summary>
         ///     Path to the sound to be played when a mob slips.
         /// </summary>
         [ViewVariables]
-        public string SlipSound { get; set; } = "/Audio/Effects/slip.ogg";
+        private string SlipSound { get; set; } = "/Audio/Effects/slip.ogg";
-
-        public override void Initialize()
-        {
-            base.Initialize();
-            var collidable = Owner.GetComponent<ICollidableComponent>();
-
-            collidable.Hard = false;
-            var shape = collidable.PhysicsShapes[0];
-            shape.CollisionLayer |= (int) CollisionGroup.SmallImpassable;
-            shape.CollisionMask = (int)CollisionGroup.None;
-        }
 
         public override void ExposeData(ObjectSerializer serializer)
         {
             base.ExposeData(serializer);
-            serializer.DataField(this, x => ParalyzeTime, "paralyzeTime", 3f);
+
-            serializer.DataField(this, x  => IntersectPercentage, "intersectPercentage", 0.3f);
-            serializer.DataField(this, x => RequiredSlipSpeed, "requiredSlipSpeed", 0f);
             serializer.DataField(this, x => SlipSound, "slipSound", "/Audio/Effects/slip.ogg");
         }
 
-        public void CollideWith(IEntity collidedWith)
+        protected override void OnSlip()
         {
-            if (ContainerHelpers.IsInContainer(Owner)
+            if (!string.IsNullOrEmpty(SlipSound))
-                ||  _slipped.Contains(collidedWith.Uid)
-                ||  !collidedWith.TryGetComponent(out StunnableComponent stun)
-                ||  !collidedWith.TryGetComponent(out ICollidableComponent otherBody)
-                ||  !collidedWith.TryGetComponent(out IPhysicsComponent otherPhysics)
-                ||  !Owner.TryGetComponent(out ICollidableComponent body))
-                return;
-
-            if (otherPhysics.LinearVelocity.Length < RequiredSlipSpeed || stun.KnockedDown)
-                return;
-
-            var percentage = otherBody.WorldAABB.IntersectPercentage(body.WorldAABB);
-
-            if (percentage < IntersectPercentage)
-                return;
-
-            if(!EffectBlockerSystem.CanSlip(collidedWith))
-                return;
-
-            stun.Paralyze(5f);
-            _slipped.Add(collidedWith.Uid);
-
-            if(!string.IsNullOrEmpty(SlipSound))
-                EntitySystem.Get<AudioSystem>().PlayFromEntity(SlipSound, Owner, AudioHelpers.WithVariation(0.2f));
-        }
-
-        public void Update(float frameTime)
             {
-            foreach (var uid in _slipped.ToArray())
+                EntitySystem.Get<AudioSystem>()
-            {
+                    .PlayFromEntity(SlipSound, Owner, AudioHelpers.WithVariation(0.2f));
-                if(!uid.IsValid() || !_entityManager.EntityExists(uid)) continue;
-
-                var entity = _entityManager.GetEntity(uid);
-                var collidable = Owner.GetComponent<ICollidableComponent>();
-                var otherCollidable = entity.GetComponent<ICollidableComponent>();
-
-                if (!collidable.WorldAABB.Intersects(otherCollidable.WorldAABB))
-                    _slipped.Remove(uid);
             }
         }
     }

Content.Server/Mobs/StandingStateHelper.cs

@@ -1,4 +1,3 @@
-using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Interfaces.GameObjects;
 using Content.Shared.Audio;
 using Content.Shared.GameObjects.Components.Mobs;

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

@@ -13,6 +13,8 @@ namespace Content.Shared.GameObjects.Components.Mobs
     {
         public override string Name => "StatusEffectsUI";
         public override uint? NetID => ContentNetIDs.STATUSEFFECTS;
+
+        public abstract void ChangeStatusEffect(StatusEffect effect, string icon, ValueTuple<TimeSpan, TimeSpan>? cooldown);
     }
 
     [Serializable, NetSerializable]

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

@@ -1,23 +1,243 @@
 using System;
+using System.Threading;
 using Content.Shared.GameObjects.Components.Movement;
 using Content.Shared.GameObjects.EntitySystems;
+using Content.Shared.Interfaces.GameObjects.Components;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.IoC;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
+using Timer = Robust.Shared.Timers.Timer;
 
 namespace Content.Shared.GameObjects.Components.Mobs
 {
-    public abstract class SharedStunnableComponent : Component, IMoveSpeedModifier, IActionBlocker
+    public abstract class SharedStunnableComponent : Component, IMoveSpeedModifier, IActionBlocker, IInteractHand
     {
+#pragma warning disable 649
+        [Dependency] private IGameTiming _gameTiming;
+#pragma warning restore 649
+
         public sealed override string Name => "Stunnable";
         public override uint? NetID => ContentNetIDs.STUNNABLE;
 
+        protected TimeSpan? LastStun;
+
+        [ViewVariables] protected TimeSpan? StunStart => LastStun;
+
+        [ViewVariables]
+        protected TimeSpan? StunEnd => LastStun == null
+            ? (TimeSpan?) null
+            : _gameTiming.CurTime +
+              (TimeSpan.FromSeconds(Math.Max(StunnedTimer, Math.Max(KnockdownTimer, SlowdownTimer))));
+
+        private const int StunLevels = 8;
+
+        private bool _canHelp = true;
+        protected float _stunCap = 20f;
+        protected float _knockdownCap = 20f;
+        protected float _slowdownCap = 20f;
+        private float _helpKnockdownRemove = 1f;
+        private float _helpInterval = 1f;
+
+        protected float StunnedTimer;
+        protected float KnockdownTimer;
+        protected float SlowdownTimer;
+
+        private string _stunTexture;
+
+        protected CancellationTokenSource StatusRemoveCancellation = new CancellationTokenSource();
+
         [ViewVariables] protected float WalkModifierOverride = 0f;
         [ViewVariables] protected float RunModifierOverride = 0f;
 
-        [ViewVariables] public abstract bool Stunned { get; }
+        [ViewVariables] public bool Stunned => StunnedTimer > 0f;
-        [ViewVariables] public abstract bool KnockedDown { get; }
+        [ViewVariables] public bool KnockedDown => KnockdownTimer > 0f;
-        [ViewVariables] public abstract bool SlowedDown { get; }
+        [ViewVariables] public bool SlowedDown => SlowdownTimer > 0f;
+
+        private float StunTimeModifier
+        {
+            get
+            {
+                var modifier = 1.0f;
+                var components = Owner.GetAllComponents<IStunModifier>();
+
+                foreach (var component in components)
+                {
+                    modifier *= component.StunTimeModifier;
+                }
+
+                return modifier;
+            }
+        }
+
+        private float KnockdownTimeModifier
+        {
+            get
+            {
+                var modifier = 1.0f;
+                var components = Owner.GetAllComponents<IStunModifier>();
+
+                foreach (var component in components)
+                {
+                    modifier *= component.KnockdownTimeModifier;
+                }
+
+                return modifier;
+            }
+        }
+
+        private float SlowdownTimeModifier
+        {
+            get
+            {
+                var modifier = 1.0f;
+                var components = Owner.GetAllComponents<IStunModifier>();
+
+                foreach (var component in components)
+                {
+                    modifier *= component.SlowdownTimeModifier;
+                }
+
+                return modifier;
+            }
+        }
+
+        /// <summary>
+        ///     Stuns the entity, disallowing it from doing many interactions temporarily.
+        /// </summary>
+        /// <param name="seconds">How many seconds the mob will stay stunned.</param>
+        /// <returns>Whether or not the owner was stunned.</returns>
+        public bool Stun(float seconds)
+        {
+            seconds = MathF.Min(StunnedTimer + (seconds * StunTimeModifier), _stunCap);
+
+            if (seconds <= 0f)
+            {
+                return false;
+            }
+
+            StunnedTimer = seconds;
+            LastStun = _gameTiming.CurTime;
+
+            SetStatusEffect();
+            OnStun();
+
+            Dirty();
+
+            return true;
+        }
+
+        protected virtual void OnStun() { }
+
+        /// <summary>
+        ///     Knocks down the mob, making it fall to the ground.
+        /// </summary>
+        /// <param name="seconds">How many seconds the mob will stay on the ground.</param>
+        /// <returns>Whether or not the owner was knocked down.</returns>
+        public bool Knockdown(float seconds)
+        {
+            seconds = MathF.Min(KnockdownTimer + (seconds * KnockdownTimeModifier), _knockdownCap);
+
+            if (seconds <= 0f)
+            {
+                return false;
+            }
+
+            KnockdownTimer = seconds;
+            LastStun = _gameTiming.CurTime;
+
+            SetStatusEffect();
+            OnKnockdown();
+
+            Dirty();
+
+            return true;
+        }
+
+        protected virtual void OnKnockdown() { }
+
+        /// <summary>
+        ///     Applies knockdown and stun to the mob temporarily.
+        /// </summary>
+        /// <param name="seconds">How many seconds the mob will be paralyzed-</param>
+        /// <returns>Whether or not the owner of this component was paralyzed-</returns>
+        public bool Paralyze(float seconds)
+        {
+            return Stun(seconds) && Knockdown(seconds);
+        }
+
+        /// <summary>
+        ///     Slows down the mob's walking/running speed temporarily
+        /// </summary>
+        /// <param name="seconds">How many seconds the mob will be slowed down</param>
+        /// <param name="walkModifierOverride">Walk speed modifier. Set to 0 or negative for default value. (0.5f)</param>
+        /// <param name="runModifierOverride">Run speed modifier. Set to 0 or negative for default value. (0.5f)</param>
+        public void Slowdown(float seconds, float walkModifierOverride = 0f, float runModifierOverride = 0f)
+        {
+            seconds = MathF.Min(SlowdownTimer + (seconds * SlowdownTimeModifier), _slowdownCap);
+
+            if (seconds <= 0f)
+                return;
+
+            WalkModifierOverride = walkModifierOverride;
+            RunModifierOverride = runModifierOverride;
+
+            SlowdownTimer = seconds;
+            LastStun = _gameTiming.CurTime;
+
+            if (Owner.TryGetComponent(out MovementSpeedModifierComponent movement))
+                movement.RefreshMovementSpeedModifiers();
+
+            SetStatusEffect();
+            Dirty();
+        }
+
+        private void SetStatusEffect()
+        {
+            if (!Owner.TryGetComponent(out SharedStatusEffectsComponent status))
+            {
+                return;
+            }
+
+            status.ChangeStatusEffect(StatusEffect.Stun, _stunTexture,
+                (StunStart == null || StunEnd == null) ? default : (StunStart.Value, StunEnd.Value));
+            StatusRemoveCancellation.Cancel();
+            StatusRemoveCancellation = new CancellationTokenSource();
+        }
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref _stunCap, "stunCap", 20f);
+            serializer.DataField(ref _knockdownCap, "knockdownCap", 20f);
+            serializer.DataField(ref _slowdownCap, "slowdownCap", 20f);
+            serializer.DataField(ref _helpInterval, "helpInterval", 1f);
+            serializer.DataField(ref _helpKnockdownRemove, "helpKnockdownRemove", 1f);
+            serializer.DataField(ref _stunTexture, "stunTexture",
+                "/Textures/Objects/Weapons/Melee/stunbaton.rsi/stunbaton_off.png");
+        }
+
+        protected virtual void OnInteractHand() { }
+
+        bool IInteractHand.InteractHand(InteractHandEventArgs eventArgs)
+        {
+            if (!_canHelp || !KnockedDown)
+            {
+                return false;
+            }
+
+            _canHelp = false;
+            Timer.Spawn((int) _helpInterval * 1000, () => _canHelp = true);
+
+            KnockdownTimer -= _helpKnockdownRemove;
+
+            SetStatusEffect();
+            Dirty();
+
+            return true;
+        }
 
         #region ActionBlockers
         public bool CanMove() => (!Stunned);
@@ -52,20 +272,30 @@ namespace Content.Shared.GameObjects.Components.Mobs
         [Serializable, NetSerializable]
         protected sealed class StunnableComponentState : ComponentState
         {
-            public bool Stunned { get; }
+            public float StunnedTimer { get; }
-            public bool KnockedDown { get; }
+            public float KnockdownTimer { get; }
-            public bool SlowedDown { get; }
+            public float SlowdownTimer { get; }
             public float WalkModifierOverride { get; }
             public float RunModifierOverride { get; }
 
-            public StunnableComponentState(bool stunned, bool knockedDown, bool slowedDown, float walkModifierOverride, float runModifierOverride) : base(ContentNetIDs.STUNNABLE)
+            public StunnableComponentState(float stunnedTimer, float knockdownTimer, float slowdownTimer, float walkModifierOverride, float runModifierOverride) : base(ContentNetIDs.STUNNABLE)
             {
-                Stunned = stunned;
+                StunnedTimer = stunnedTimer;
-                KnockedDown = knockedDown;
+                KnockdownTimer = knockdownTimer;
-                SlowedDown = slowedDown;
+                SlowdownTimer = slowdownTimer;
                 WalkModifierOverride = walkModifierOverride;
                 RunModifierOverride = runModifierOverride;
             }
         }
     }
+
+    /// <summary>
+    ///     This interface allows components to multiply the time in seconds of various stuns by a number.
+    /// </summary>
+    public interface IStunModifier
+    {
+        float StunTimeModifier => 1.0f;
+        float KnockdownTimeModifier => 1.0f;
+        float SlowdownTimeModifier => 1.0f;
+    }
 }

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

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using Content.Shared.GameObjects.Components.Mobs;
+using Content.Shared.GameObjects.EntitySystems;
+using Content.Shared.Physics;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects.Components;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Shared.GameObjects.Components.Movement
+{
+    public abstract class SharedSlipperyComponent : Component, ICollideBehavior
+    {
+#pragma warning disable 649
+        [Dependency] private readonly IEntityManager _entityManager;
+#pragma warning restore 649
+
+        public sealed override string Name => "Slippery";
+
+        /// <summary>
+        ///     The list of entities that have been slipped by this component,
+        ///     and which have not stopped colliding with its owner yet.
+        /// </summary>
+        protected readonly List<EntityUid> _slipped = new List<EntityUid>();
+
+        /// <summary>
+        ///     How many seconds the mob will be paralyzed for.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        private float ParalyzeTime { get; set; } = 3f;
+
+        /// <summary>
+        ///     Percentage of shape intersection for a slip to occur.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        private float IntersectPercentage { get; set; } = 0.3f;
+
+        /// <summary>
+        ///     Entities will only be slipped if their speed exceeds this limit.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        private float RequiredSlipSpeed { get; set; } = 0f;
+
+        private bool TrySlip(IEntity entity)
+        {
+            if (ContainerHelpers.IsInContainer(Owner)
+                ||  _slipped.Contains(entity.Uid)
+                ||  !entity.TryGetComponent(out SharedStunnableComponent stun)
+                ||  !entity.TryGetComponent(out ICollidableComponent otherBody)
+                ||  !entity.TryGetComponent(out IPhysicsComponent otherPhysics)
+                ||  !Owner.TryGetComponent(out ICollidableComponent body))
+            {
+                return false;
+            }
+
+            if (otherPhysics.LinearVelocity.Length < RequiredSlipSpeed || stun.KnockedDown)
+            {
+                return false;
+            }
+
+            var percentage = otherBody.WorldAABB.IntersectPercentage(body.WorldAABB);
+
+            if (percentage < IntersectPercentage)
+            {
+                return false;
+            }
+
+            if (!EffectBlockerSystem.CanSlip(entity))
+            {
+                return false;
+            }
+
+            stun.Paralyze(5);
+            _slipped.Add(entity.Uid);
+
+            OnSlip();
+
+            return true;
+        }
+
+        protected virtual void OnSlip() { }
+
+        public void CollideWith(IEntity collidedWith)
+        {
+            TrySlip(collidedWith);
+        }
+
+        public void Update(float frameTime)
+        {
+            foreach (var uid in _slipped.ToArray())
+            {
+                if (!uid.IsValid() || !_entityManager.EntityExists(uid))
+                {
+                    continue;
+                }
+
+                var entity = _entityManager.GetEntity(uid);
+                var collidable = Owner.GetComponent<ICollidableComponent>();
+                var otherCollidable = entity.GetComponent<ICollidableComponent>();
+
+                if (!collidable.WorldAABB.Intersects(otherCollidable.WorldAABB))
+                {
+                    _slipped.Remove(uid);
+                }
+            }
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            var collidable = Owner.GetComponent<ICollidableComponent>();
+
+            collidable.Hard = false;
+            var shape = collidable.PhysicsShapes[0];
+            shape.CollisionLayer |= (int) CollisionGroup.SmallImpassable;
+            shape.CollisionMask = (int)CollisionGroup.None;
+        }
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(this, x => ParalyzeTime, "paralyzeTime", 3f);
+            serializer.DataField(this, x  => IntersectPercentage, "intersectPercentage", 0.3f);
+            serializer.DataField(this, x => RequiredSlipSpeed, "requiredSlipSpeed", 0f);
+        }
+    }
+}

Content.Shared/GameObjects/EntitySystems/SlipperySystem.cs

@@ -1,16 +1,18 @@
-using Content.Server.GameObjects.Components.Movement;
+using Content.Shared.GameObjects.Components.Movement;
+using JetBrains.Annotations;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameObjects.Systems;
 
-namespace Content.Server.GameObjects.EntitySystems
+namespace Content.Shared.GameObjects.EntitySystems
 {
+    [UsedImplicitly]
     public class SlipperySystem : EntitySystem
     {
         public override void Initialize()
         {
             base.Initialize();
 
-            EntityQuery = new TypeEntityQuery(typeof(SlipperyComponent));
+            EntityQuery = new TypeEntityQuery(typeof(SharedSlipperyComponent));
         }
 
         public override void Update(float frameTime)
@@ -19,7 +21,7 @@ namespace Content.Server.GameObjects.EntitySystems
 
             foreach (var entity in RelevantEntities)
             {
-                entity.GetComponent<SlipperyComponent>().Update(frameTime);
+                entity.GetComponent<SharedSlipperyComponent>().Update(frameTime);
             }
         }
     }