fix reflected projectiles dealing stamina damage (#17648)

Content.Shared/Damage/Systems/StaminaSystem.cs

@@ -7,13 +7,13 @@ using Content.Shared.Damage.Events;
 using Content.Shared.Database;
 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.Weapons.Melee.Events;
 using JetBrains.Annotations;
 using Robust.Shared.GameStates;
-using Robust.Shared.Physics.Events;
 using Robust.Shared.Player;
 using Robust.Shared.Random;
 using Robust.Shared.Serialization;
@@ -31,8 +31,6 @@ public sealed partial class StaminaSystem : EntitySystem
     [Dependency] private readonly SharedPopupSystem _popup = default!;
     [Dependency] private readonly SharedStunSystem _stunSystem = default!;
 
-    private const string CollideFixture = "projectile";
-
     /// <summary>
     /// How much of a buffer is there between the stun duration and when stuns can be re-applied.
     /// </summary>
@@ -52,7 +50,7 @@ public sealed partial class StaminaSystem : EntitySystem
         SubscribeLocalEvent<StaminaComponent, DisarmedEvent>(OnDisarmed);
         SubscribeLocalEvent<StaminaComponent, RejuvenateEvent>(OnRejuvenate);
 
-        SubscribeLocalEvent<StaminaDamageOnCollideComponent, StartCollideEvent>(OnCollide);
+        SubscribeLocalEvent<StaminaDamageOnCollideComponent, ProjectileHitEvent>(OnCollide);
         SubscribeLocalEvent<StaminaDamageOnHitComponent, MeleeHitEvent>(OnHit);
     }
 
@@ -144,7 +142,7 @@ public sealed partial class StaminaSystem : EntitySystem
             return;
 
         var damage = args.PushProbability * component.CritThreshold;
-        TakeStaminaDamage(uid, damage, component, source:args.Source);
+        TakeStaminaDamage(uid, damage, component, source: args.Source);
 
         // We need a better method of getting if the entity is going to resist stam damage, both this and the lines in the foreach at the end of OnHit() are awful
         if (!component.Critical)
@@ -204,7 +202,7 @@ public sealed partial class StaminaSystem : EntitySystem
         foreach (var (ent, comp) in toHit)
         {
             var oldDamage = comp.StaminaDamage;
-            TakeStaminaDamage(ent, damage / toHit.Count, comp, source:args.User, with:args.Weapon);
+            TakeStaminaDamage(ent, damage / toHit.Count, comp, source: args.User, with: args.Weapon);
             if (comp.StaminaDamage.Equals(oldDamage))
             {
                 _popup.PopupClient(Loc.GetString("stamina-resist"), ent, args.User);
@@ -212,11 +210,9 @@ public sealed partial class StaminaSystem : EntitySystem
         }
     }
 
-    private void OnCollide(EntityUid uid, StaminaDamageOnCollideComponent component, ref StartCollideEvent args)
+    private void OnCollide(EntityUid uid, StaminaDamageOnCollideComponent component, ref ProjectileHitEvent args)
     {
-        if (!args.OurFixture.ID.Equals(CollideFixture)) return;
-
-        TakeStaminaDamage(args.OtherEntity, component.Damage, source:args.OurEntity);
+        TakeStaminaDamage(args.Target, component.Damage, source: uid);
     }
 
     private void SetStaminaAlert(EntityUid uid, StaminaComponent? component = null)
@@ -413,4 +409,4 @@ public sealed partial class StaminaSystem : EntitySystem
 ///     Raised before stamina damage is dealt to allow other systems to cancel it.
 /// </summary>
 [ByRefEvent]
-public record struct BeforeStaminaDamageEvent(float Value, bool Cancelled=false);
+public record struct BeforeStaminaDamageEvent(float Value, bool Cancelled = false);

Content.Shared/Projectiles/ProjectileCollideEvent.cs

@@ -1,7 +0,0 @@
-namespace Content.Shared.Projectiles;
-
-/// <summary>
-/// Raised directed on what a projectile collides with. Can have its deletion cancelled.
-/// </summary>
-[ByRefEvent]
-public record struct ProjectileCollideEvent(EntityUid OtherEntity, bool Cancelled);

Content.Shared/Projectiles/SharedProjectileSystem.cs

@@ -28,7 +28,7 @@ namespace Content.Shared.Projectiles
         {
             base.Initialize();
             SubscribeLocalEvent<ProjectileComponent, PreventCollideEvent>(PreventCollision);
-            SubscribeLocalEvent<EmbeddableProjectileComponent, ProjectileCollideEvent>(OnEmbedProjectileCollide);
+            SubscribeLocalEvent<EmbeddableProjectileComponent, ProjectileHitEvent>(OnEmbedProjectileHit);
             SubscribeLocalEvent<EmbeddableProjectileComponent, ThrowDoHitEvent>(OnEmbedThrowDoHit);
             SubscribeLocalEvent<EmbeddableProjectileComponent, ActivateInWorldEvent>(OnEmbedActivate);
             SubscribeLocalEvent<EmbeddableProjectileComponent, RemoveEmbeddedProjectileEvent>(OnEmbedRemove);
@@ -80,14 +80,14 @@ namespace Content.Shared.Projectiles
             Embed(uid, args.Target, component);
         }
 
-        private void OnEmbedProjectileCollide(EntityUid uid, EmbeddableProjectileComponent component, ref ProjectileCollideEvent args)
+        private void OnEmbedProjectileHit(EntityUid uid, EmbeddableProjectileComponent component, ref ProjectileHitEvent args)
         {
-            Embed(uid, args.OtherEntity, component);
+            Embed(uid, args.Target, component);
 
             // Raise a specific event for projectiles.
             if (TryComp<ProjectileComponent>(uid, out var projectile))
             {
-                var ev = new ProjectileEmbedEvent(projectile.Shooter, projectile.Weapon, args.OtherEntity);
+                var ev = new ProjectileEmbedEvent(projectile.Shooter, projectile.Weapon, args.Target);
                 RaiseLocalEvent(uid, ref ev);
             }
         }
@@ -142,10 +142,16 @@ namespace Content.Shared.Projectiles
             Coordinates = coordinates;
         }
     }
-}
 
-/// <summary>
-/// Raised when entity is just about to be hit with projectile but can reflect it
-/// </summary>
-[ByRefEvent]
-public record struct ProjectileReflectAttemptEvent(EntityUid ProjUid, ProjectileComponent Component, bool Cancelled);
+    /// <summary>
+    /// Raised when entity is just about to be hit with projectile but can reflect it
+    /// </summary>
+    [ByRefEvent]
+    public record struct ProjectileReflectAttemptEvent(EntityUid ProjUid, ProjectileComponent Component, bool Cancelled);
+
+    /// <summary>
+    /// Raised when projectile hits other entity
+    /// </summary>
+    [ByRefEvent]
+    public readonly record struct ProjectileHitEvent(EntityUid Target);
+}

Content.Shared/Weapons/Reflect/SharedReflectSystem.cs

@@ -38,21 +38,21 @@ public abstract class SharedReflectSystem : EntitySystem
         SubscribeLocalEvent<HandsComponent, ProjectileReflectAttemptEvent>(OnHandReflectProjectile);
         SubscribeLocalEvent<HandsComponent, HitScanReflectAttemptEvent>(OnHandsReflectHitscan);
 
-        SubscribeLocalEvent<ReflectComponent, ProjectileCollideEvent>(OnReflectCollide);
+        SubscribeLocalEvent<ReflectComponent, ProjectileReflectAttemptEvent>(OnReflectCollide);
         SubscribeLocalEvent<ReflectComponent, HitScanReflectAttemptEvent>(OnReflectHitscan);
 
         SubscribeLocalEvent<ReflectComponent, GotEquippedEvent>(OnReflectEquipped);
         SubscribeLocalEvent<ReflectComponent, GotUnequippedEvent>(OnReflectUnequipped);
     }
 
-    private void OnReflectCollide(EntityUid uid, ReflectComponent component, ref ProjectileCollideEvent args)
+    private void OnReflectCollide(EntityUid uid, ReflectComponent component, ref ProjectileReflectAttemptEvent args)
     {
         if (args.Cancelled)
         {
             return;
         }
 
-        if (TryReflectProjectile(uid, args.OtherEntity, reflect: component))
+        if (TryReflectProjectile(uid, args.ProjUid, reflect: component))
             args.Cancelled = true;
     }