Add attack delay to weapon throwing

Content.Server/Damage/Systems/DamageOtherOnHitSystem.cs

@@ -8,8 +8,12 @@
 using Content.Shared.Damage.Systems;
 using Content.Shared.Database;
 using Content.Shared.Effects;
+using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
 using Content.Shared.Mobs.Components;
 using Content.Shared.Throwing;
+using Content.Shared.Weapons.Melee;
+using Content.Shared.Weapons.Melee.Events;
 using Content.Shared.Wires;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Player;
@@ -24,12 +28,14 @@ public sealed class DamageOtherOnHitSystem : EntitySystem
         [Dependency] private readonly DamageExamineSystem _damageExamine = default!;
         [Dependency] private readonly SharedCameraRecoilSystem _sharedCameraRecoil = default!;
         [Dependency] private readonly SharedColorFlashEffectSystem _color = default!;
+        [Dependency] private readonly SharedHandsSystem _hands = default!;
 
         public override void Initialize()
         {
             SubscribeLocalEvent<DamageOtherOnHitComponent, ThrowDoHitEvent>(OnDoHit);
             SubscribeLocalEvent<DamageOtherOnHitComponent, DamageExamineEvent>(OnDamageExamine);
             SubscribeLocalEvent<DamageOtherOnHitComponent, AttemptPacifiedThrowEvent>(OnAttemptPacifiedThrow);
+            SubscribeLocalEvent<DamageOtherOnHitComponent, MeleeHitEvent>(OnMeleeCollideHit);
         }
 
         private void OnDoHit(EntityUid uid, DamageOtherOnHitComponent component, ThrowDoHitEvent args)
@@ -68,5 +74,17 @@ private void OnAttemptPacifiedThrow(Entity<DamageOtherOnHitComponent> ent, ref A
         {
             args.Cancel("pacified-cannot-throw");
         }
+
+        /// <summary>
+        /// Prevent immediately throwing this weapon after using it for a melee attack.
+        /// </summary>
+        private void OnMeleeCollideHit(Entity<DamageOtherOnHitComponent> ent, ref MeleeHitEvent args)
+        {
+            if (!TryComp<HandsComponent>(args.User, out var hands) || !TryComp<MeleeWeaponComponent>(ent.Owner, out var melee))
+                return;
+
+            if (hands.NextThrowTime < melee.NextAttack)
+                _hands.ResetThrowCooldown(args.User, hands, melee.NextAttack);
+        }
     }
 }

Content.Server/Hands/Systems/HandsSystem.cs

@@ -1,5 +1,6 @@
 using System.Numerics;
 using Content.Server.Inventory;
+using Content.Server.Popups;
 using Content.Server.Stack;
 using Content.Server.Stunnable;
 using Content.Shared.ActionBlocker;
@@ -36,6 +37,7 @@ public sealed class HandsSystem : SharedHandsSystem
         [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
         [Dependency] private readonly PullingSystem _pullingSystem = default!;
         [Dependency] private readonly ThrowingSystem _throwingSystem = default!;
+        [Dependency] private readonly PopupSystem _popup = default!;
 
         public override void Initialize()
         {
@@ -93,7 +95,7 @@ private void OnDisarmed(EntityUid uid, HandsComponent component, DisarmedEvent a
                 _pullingSystem.TryStopPull(puller.Pulling.Value, pullable);
 
             var offsetRandomCoordinates = _transformSystem.GetMoverCoordinates(args.Target).Offset(_random.NextVector2(1f, 1.5f));
-            if (!ThrowHeldItem(args.Target, offsetRandomCoordinates))
+            if (!ThrowHeldItem(args.Target, offsetRandomCoordinates, forcePlayerThrow: true))
                 return;
 
             args.PopupPrefix = "disarm-action-";
@@ -179,16 +181,24 @@ private bool HandleThrowItem(ICommonSession? playerSession, EntityCoordinates co
         /// <summary>
         /// Throw the player's currently held item.
         /// </summary>
-        public bool ThrowHeldItem(EntityUid player, EntityCoordinates coordinates, float minDistance = 0.1f)
+        /// <param name="player">The entity with hands who is doing the throwing.</param>
+        /// <param name="coordinates">Target coordinates for the throw.</param>
+        /// <param name="minDistance">Minimum distance a throw may result in.</param>
+        /// <param name="forcePlayerThrow">If the throw should bypass checks involving the player (e.g. throw cooldowns for disarming).</param>
+        /// <returns></returns>
+        public bool ThrowHeldItem(EntityUid player, EntityCoordinates coordinates, float minDistance = 0.1f, bool forcePlayerThrow = false)
         {
             if (ContainerSystem.IsEntityInContainer(player) ||
                 !TryComp(player, out HandsComponent? hands) ||
                 hands.ActiveHandEntity is not { } throwEnt ||
                 !_actionBlockerSystem.CanThrow(player, throwEnt))
                 return false;
 
-            if (_timing.CurTime < hands.NextThrowTime)
+            if (!forcePlayerThrow && _timing.CurTime < hands.NextThrowTime)
+            {
+                _popup.PopupEntity(Loc.GetString("hands-system-throwing-cooldown"), player, player);
                 return false;
+            }
             hands.NextThrowTime = _timing.CurTime + hands.ThrowCooldown;
 
             if (EntityManager.TryGetComponent(throwEnt, out StackComponent? stack) && stack.Count > 1 && stack.ThrowIndividually)

Content.Shared/Damage/Systems/StaminaSystem.cs

@@ -6,13 +6,16 @@
 using Content.Shared.Damage.Events;
 using Content.Shared.Database;
 using Content.Shared.Effects;
+using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Popups;
 using Content.Shared.Projectiles;
 using Content.Shared.Rejuvenate;
 using Content.Shared.Rounding;
 using Content.Shared.Stunnable;
 using Content.Shared.Throwing;
+using Content.Shared.Weapons.Melee;
 using Content.Shared.Weapons.Melee.Events;
 using JetBrains.Annotations;
 using Robust.Shared.Audio;
@@ -34,6 +37,7 @@ public sealed partial class StaminaSystem : EntitySystem
     [Dependency] private readonly SharedColorFlashEffectSystem _color = default!;
     [Dependency] private readonly SharedStunSystem _stunSystem = default!;
     [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedHandsSystem _hands = default!;
 
     /// <summary>
     /// How much of a buffer is there between the stun duration and when stuns can be re-applied.
@@ -56,6 +60,7 @@ public override void Initialize()
 
         SubscribeLocalEvent<StaminaDamageOnCollideComponent, ProjectileHitEvent>(OnProjectileHit);
         SubscribeLocalEvent<StaminaDamageOnCollideComponent, ThrowDoHitEvent>(OnThrowHit);
+        SubscribeLocalEvent<StaminaDamageOnCollideComponent, MeleeHitEvent>(OnMeleeCollideHit);
 
         SubscribeLocalEvent<StaminaDamageOnHitComponent, MeleeHitEvent>(OnMeleeHit);
     }
@@ -190,6 +195,18 @@ private void OnThrowHit(EntityUid uid, StaminaDamageOnCollideComponent component
         OnCollide(uid, component, args.Target);
     }
 
+    /// <summary>
+    /// Prevent immediately throwing this weapon after using it for a melee attack.
+    /// </summary>
+    private void OnMeleeCollideHit(Entity<StaminaDamageOnCollideComponent> ent, ref MeleeHitEvent args)
+    {
+        if (!TryComp<HandsComponent>(args.User, out var hands) || !TryComp<MeleeWeaponComponent>(ent.Owner, out var melee))
+            return;
+
+        if (hands.NextThrowTime < melee.NextAttack)
+            _hands.ResetThrowCooldown(args.User, hands, melee.NextAttack);
+    }
+
     private void OnCollide(EntityUid uid, StaminaDamageOnCollideComponent component, EntityUid target)
     {
         // you can't inflict stamina damage on things with no stamina component

Content.Shared/Hands/EntitySystems/SharedHandsSystem.Interactions.cs

@@ -1,11 +1,14 @@
 using System.Linq;
+using Content.Shared.Damage.Components;
 using Content.Shared.Examine;
 using Content.Shared.Hands.Components;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Input;
 using Content.Shared.Interaction;
 using Content.Shared.Inventory.VirtualItem;
 using Content.Shared.Localizations;
+using Content.Shared.Weapons.Melee;
+using Content.Shared.Weapons.Melee.Events;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.Map;
 using Robust.Shared.Player;
@@ -213,4 +216,23 @@ private void HandleExamined(EntityUid examinedUid, HandsComponent handsComp, Exa
             args.PushMarkup(Loc.GetString(locKey, locUser, locItems));
         }
     }
+
+    /// <summary>
+    /// Resets the throw cooldown to allow for throwing, and optionally sets a new throw tim if given.
+    /// </summary>
+    /// <param name="customTime">If set, this will be the new NextThrowTime.</param>
+    public void ResetThrowCooldown(EntityUid uid, HandsComponent? handsComp, TimeSpan? customTime = null)
+    {
+        if (!Resolve(uid, ref handsComp))
+            return;
+
+        if (customTime == null || _timing.CurTime > customTime)
+        {
+            handsComp.NextThrowTime = _timing.CurTime;
+            return;
+        }
+
+        handsComp.NextThrowTime = (TimeSpan)customTime;
+
+    }
 }

Content.Shared/Hands/EntitySystems/SharedHandsSystem.cs

@@ -9,6 +9,7 @@
 using Content.Shared.Storage.EntitySystems;
 using Robust.Shared.Containers;
 using Robust.Shared.Input.Binding;
+using Robust.Shared.Timing;
 
 namespace Content.Shared.Hands.EntitySystems;
 
@@ -22,6 +23,7 @@ public abstract partial class SharedHandsSystem
     [Dependency] private readonly SharedStorageSystem _storage = default!;
     [Dependency] protected readonly SharedTransformSystem TransformSystem = default!;
     [Dependency] private readonly SharedVirtualItemSystem _virtualSystem = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
 
     protected event Action<Entity<HandsComponent>?>? OnHandSetActive;
 

Content.Shared/Throwing/ThrowingSystem.cs

@@ -170,7 +170,7 @@ public void TryThrow(EntityUid uid,
 
         ThrowingAngleComponent? throwingAngle = null;
 
-        // Give it a l'il spin.
+        // Give it a li'l spin.
         if (doSpin)
         {
             if (physics.InvI > 0f && (!TryComp(uid, out throwingAngle) || throwingAngle.AngularVelocity))

Resources/Locale/en-US/hands/hands-system.ftl

@@ -4,3 +4,5 @@ comp-hands-examine-empty = { CAPITALIZE(SUBJECT($user)) } { CONJUGATE-BE($user)
 comp-hands-examine-wrapper = { INDEFINITE($item) } [color=paleturquoise]{$item}[/color]
 
 hands-system-blocked-by = Blocked by
+
+hands-system-throwing-cooldown = You are not ready to throw yet!