Fix cable cutting and allow tool system to raise directed events (#6175)

Content.Server/Power/EntitySystems/CableSystem.cs

@@ -26,8 +26,8 @@ public class CableSystem : EntitySystem
         if (args.Handled)
             return;
 
-        var ev = new CuttingFinishedEvent(uid, args.User);
+        var ev = new CuttingFinishedEvent(args.User);
-        _toolSystem.UseTool(args.Used, args.User, uid, 0, cable.CuttingDelay, new[] { cable.CuttingQuality }, doAfterCompleteEvent: ev);
+        _toolSystem.UseTool(args.Used, args.User, uid, 0, cable.CuttingDelay, new[] { cable.CuttingQuality }, doAfterCompleteEvent: ev, doAfterEventTarget: uid);
         args.Handled = true;
     }
 
@@ -57,15 +57,12 @@ public class CableSystem : EntitySystem
     }
 }
 
-// TODO: if #5887 gets merged, just use a directed event instead of broadcast-with-target
 public class CuttingFinishedEvent : EntityEventArgs
 {
-    public EntityUid Target;
     public EntityUid User;
 
-    public CuttingFinishedEvent(EntityUid target, EntityUid user)
+    public CuttingFinishedEvent(EntityUid user)
     {
-        Target = target;
         User = user;
     }
 }

Content.Server/Tools/ToolSystem.cs

@@ -41,14 +41,26 @@ namespace Content.Server.Tools
         {
             // Actually finish the tool use! Depending on whether that succeeds or not, either event will be broadcast.
             if(ToolFinishUse(ev.Uid, ev.UserUid, ev.Fuel))
+            {
+                if (ev.EventTarget != null)
+                    RaiseLocalEvent(ev.EventTarget.Value, ev.CompletedEvent, false);
+                else
                     RaiseLocalEvent(ev.CompletedEvent);
+            }
             else if(ev.CancelledEvent != null)
+            {
+                if (ev.EventTarget != null)
+                    RaiseLocalEvent(ev.EventTarget.Value, ev.CancelledEvent, false);
+                else
                     RaiseLocalEvent(ev.CancelledEvent);
             }
+        }
 
         private void OnDoAfterCancelled(ToolDoAfterCancelled ev)
         {
-            // Broadcast wrapped event.
+            if (ev.EventTarget != null)
+                RaiseLocalEvent(ev.EventTarget.Value, ev.Event, false);
+            else
                 RaiseLocalEvent(ev.Event);
         }
 
@@ -77,8 +89,9 @@ namespace Content.Server.Tools
         /// <param name="fuel">An optional amount of fuel or energy to consume-</param>
         /// <param name="doAfterDelay">A doAfter delay in seconds.</param>
         /// <param name="toolQualitiesNeeded">The tool qualities needed to use the tool.</param>
-        /// <param name="doAfterCompleteEvent">An event to broadcast once the doAfter is completed successfully.</param>
+        /// <param name="doAfterCompleteEvent">An event to raise once the doAfter is completed successfully.</param>
-        /// <param name="doAfterCancelledEvent">An event to broadcast once the doAfter is cancelled.</param>
+        /// <param name="doAfterCancelledEvent">An event to raise once the doAfter is canceled.</param>
+        /// <param name="doAfterEventTarget">Where to direct the do-after events. If null, events are broadcast</param>
         /// <param name="doAfterCheck">An optional check to perform for the doAfter.</param>
         /// <param name="toolComponent">The tool component.</param>
         /// <returns>Whether initially, using the tool succeeded. If there's a doAfter delay, you'll need to listen to
@@ -87,7 +100,7 @@ namespace Content.Server.Tools
         ///          this simply returns whether using the tool succeeded or not.</returns>
         public bool UseTool(EntityUid tool, EntityUid user, EntityUid? target, float fuel,
             float doAfterDelay, IEnumerable<string> toolQualitiesNeeded,
-            object? doAfterCompleteEvent = null, object? doAfterCancelledEvent = null,
+            object? doAfterCompleteEvent = null, object? doAfterCancelledEvent = null, EntityUid? doAfterEventTarget = null,
             Func<bool>? doAfterCheck = null, ToolComponent? toolComponent = null)
         {
             // No logging here, after all that'd mean the caller would need to check if the component is there or not.
@@ -107,8 +120,8 @@ namespace Content.Server.Tools
                     BreakOnTargetMove = true,
                     BreakOnUserMove = true,
                     NeedHand = true,
-                    BroadcastFinishedEvent = doAfterCompleteEvent != null ? new ToolDoAfterComplete(doAfterCompleteEvent, doAfterCancelledEvent, tool, user, fuel) : null,
+                    BroadcastFinishedEvent = doAfterCompleteEvent != null ? new ToolDoAfterComplete(doAfterCompleteEvent, doAfterCancelledEvent, tool, user, fuel, doAfterEventTarget) : null,
-                    BroadcastCancelledEvent = doAfterCancelledEvent != null ? new ToolDoAfterCancelled(doAfterCancelledEvent) : null,
+                    BroadcastCancelledEvent = doAfterCancelledEvent != null ? new ToolDoAfterCancelled(doAfterCancelledEvent, doAfterEventTarget) : null,
                 };
 
                 _doAfterSystem.DoAfter(doAfterArgs);
@@ -121,11 +134,11 @@ namespace Content.Server.Tools
         // This is hilariously long.
         /// <inheritdoc cref="UseTool(Robust.Shared.GameObjects.EntityUid,Robust.Shared.GameObjects.EntityUid,System.Nullable{Robust.Shared.GameObjects.EntityUid},float,float,System.Collections.Generic.IEnumerable{string},Robust.Shared.GameObjects.EntityUid,object,object,System.Func{bool}?,Content.Server.Tools.Components.ToolComponent?)"/>
         public bool UseTool(EntityUid tool, EntityUid user, EntityUid? target, float fuel,
-            float doAfterDelay, string toolQualityNeeded, object doAfterCompleteEvent, object doAfterCancelledEvent,
+            float doAfterDelay, string toolQualityNeeded, object doAfterCompleteEvent, object doAfterCancelledEvent, EntityUid? doAfterEventTarget = null,
             Func<bool>? doAfterCheck = null, ToolComponent? toolComponent = null)
         {
             return UseTool(tool, user, target, fuel, doAfterDelay, new[] { toolQualityNeeded },
-                doAfterCompleteEvent, doAfterCancelledEvent, doAfterCheck, toolComponent);
+                doAfterCompleteEvent, doAfterCancelledEvent, doAfterEventTarget, doAfterCheck, toolComponent);
         }
 
         /// <summary>
@@ -239,24 +252,28 @@ namespace Content.Server.Tools
             public readonly EntityUid Uid;
             public readonly EntityUid UserUid;
             public readonly float Fuel;
+            public readonly EntityUid? EventTarget;
 
-            public ToolDoAfterComplete(object completedEvent, object? cancelledEvent, EntityUid uid, EntityUid userUid, float fuel)
+            public ToolDoAfterComplete(object completedEvent, object? cancelledEvent, EntityUid uid, EntityUid userUid, float fuel, EntityUid? eventTarget = null)
             {
                 CompletedEvent = completedEvent;
                 Uid = uid;
                 UserUid = userUid;
                 Fuel = fuel;
                 CancelledEvent = cancelledEvent;
+                EventTarget = eventTarget;
             }
         }
 
         private class ToolDoAfterCancelled : EntityEventArgs
         {
             public readonly object Event;
+            public readonly EntityUid? EventTarget;
 
-            public ToolDoAfterCancelled(object @event)
+            public ToolDoAfterCancelled(object @event, EntityUid? eventTarget = null)
             {
                 Event = @event;
+                EventTarget = eventTarget;
             }
         }
     }