Adds grappling gun (#16662)

Content.Client/Weapons/Misc/GrapplingGunSystem.cs

@@ -0,0 +1,58 @@
+using System.Net;
+using Content.Client.Hands.Systems;
+using Content.Shared.CombatMode;
+using Content.Shared.Weapons.Misc;
+using Content.Shared.Weapons.Ranged.Components;
+using Robust.Client.GameObjects;
+using Robust.Client.Player;
+using Robust.Shared.Input;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Dynamics.Joints;
+
+namespace Content.Client.Weapons.Misc;
+
+public sealed class GrapplingGunSystem : SharedGrapplingGunSystem
+{
+    [Dependency] private readonly HandsSystem _hands = default!;
+    [Dependency] private readonly InputSystem _input = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        // Oh boy another input handler.
+        // If someone thinks of a better way to unify this please tell me.
+        if (!Timing.IsFirstTimePredicted)
+            return;
+
+        var local = _player.LocalPlayer?.ControlledEntity;
+        var handUid = _hands.GetActiveHandEntity();
+
+        if (!TryComp<GrapplingGunComponent>(handUid, out var grappling))
+            return;
+
+        if (!TryComp<JointComponent>(handUid, out var jointComp) ||
+            !jointComp.GetJoints.TryGetValue(GrapplingJoint, out var joint) ||
+            joint is not DistanceJoint distance)
+        {
+            return;
+        }
+
+        if (distance.MaxLength <= distance.MinLength)
+            return;
+
+        var reelKey = _input.CmdStates.GetState(EngineKeyFunctions.UseSecondary) == BoundKeyState.Down;
+
+        if (!TryComp<CombatModeComponent>(local, out var combatMode) ||
+            !combatMode.IsInCombatMode)
+        {
+            reelKey = false;
+        }
+
+        if (grappling.Reeling == reelKey)
+            return;
+
+        RaisePredictiveEvent(new RequestGrapplingReelMessage(reelKey));
+    }
+}

Content.Client/Weapons/Ranged/Systems/GunSystem.Ballistic.cs

@@ -1,4 +1,5 @@
 using Content.Shared.Weapons.Ranged.Components;
+using Content.Shared.Weapons.Ranged.Events;
 using Robust.Shared.Map;
 
 namespace Content.Client.Weapons.Ranged.Systems;
@@ -19,9 +20,10 @@ public sealed partial class GunSystem
         }
     }
 
-    protected override void Cycle(BallisticAmmoProviderComponent component, MapCoordinates coordinates)
+    protected override void Cycle(EntityUid uid, BallisticAmmoProviderComponent component, MapCoordinates coordinates)
     {
-        if (!Timing.IsFirstTimePredicted) return;
+        if (!Timing.IsFirstTimePredicted)
+            return;
 
         EntityUid? ent = null;
 
@@ -43,5 +45,8 @@ public sealed partial class GunSystem
 
         if (ent != null && ent.Value.IsClientSide())
             Del(ent.Value);
+
+        var cycledEvent = new GunCycledEvent();
+        RaiseLocalEvent(uid, ref cycledEvent);
     }
 }

Content.Client/Weapons/Ranged/Systems/GunSystem.cs

@@ -173,8 +173,10 @@ public sealed partial class GunSystem : SharedGunSystem
     }
 
     public override void Shoot(EntityUid gunUid, GunComponent gun, List<(EntityUid? Entity, IShootable Shootable)> ammo,
-        EntityCoordinates fromCoordinates, EntityCoordinates toCoordinates, EntityUid? user = null, bool throwItems = false)
+        EntityCoordinates fromCoordinates, EntityCoordinates toCoordinates, out bool userImpulse, EntityUid? user = null, bool throwItems = false)
     {
+        userImpulse = true;
+
         // Rather than splitting client / server for every ammo provider it's easier
         // to just delete the spawned entities. This is for programmer sanity despite the wasted perf.
         // This also means any ammo specific stuff can be grabbed as necessary.
@@ -207,6 +209,7 @@ public sealed partial class GunSystem : SharedGunSystem
                     }
                     else
                     {
+                        userImpulse = false;
                         Audio.PlayPredicted(gun.SoundEmpty, gunUid, user);
                     }