fix reflected projectiles dealing stamina damage (#17648)

Content.Server/Projectiles/ProjectileSystem.cs

@@ -31,44 +31,42 @@ public sealed class ProjectileSystem : SharedProjectileSystem
         if (args.OurFixture.ID != ProjectileFixture || !args.OtherFixture.Hard || component.DamagedEntity)
             return;
 
-        var otherEntity = args.OtherEntity;
+        var target = args.OtherEntity;
         // it's here so this check is only done once before possible hit
         var attemptEv = new ProjectileReflectAttemptEvent(uid, component, false);
-        RaiseLocalEvent(otherEntity, ref attemptEv);
+        RaiseLocalEvent(target, ref attemptEv);
         if (attemptEv.Cancelled)
         {
-            SetShooter(component, otherEntity);
+            SetShooter(component, target);
             return;
         }
 
-        var otherName = ToPrettyString(otherEntity);
+        var ev = new ProjectileHitEvent(target);
+        RaiseLocalEvent(uid, ref ev);
+
+        var otherName = ToPrettyString(target);
         var direction = args.OurBody.LinearVelocity.Normalized();
-        var modifiedDamage = _damageableSystem.TryChangeDamage(otherEntity, component.Damage, component.IgnoreResistances, origin: component.Shooter);
+        var modifiedDamage = _damageableSystem.TryChangeDamage(target, component.Damage, component.IgnoreResistances, origin: component.Shooter);
-        var deleted = Deleted(otherEntity);
+        var deleted = Deleted(target);
 
         if (modifiedDamage is not null && EntityManager.EntityExists(component.Shooter))
         {
             if (modifiedDamage.Total > FixedPoint2.Zero && !deleted)
             {
-                RaiseNetworkEvent(new ColorFlashEffectEvent(Color.Red, new List<EntityUid> { otherEntity }), Filter.Pvs(otherEntity, entityManager: EntityManager));
+                RaiseNetworkEvent(new ColorFlashEffectEvent(Color.Red, new List<EntityUid> { target }), Filter.Pvs(target, entityManager: EntityManager));
             }
 
             _adminLogger.Add(LogType.BulletHit,
-                HasComp<ActorComponent>(otherEntity) ? LogImpact.Extreme : LogImpact.High,
+                HasComp<ActorComponent>(target) ? LogImpact.Extreme : LogImpact.High,
                 $"Projectile {ToPrettyString(uid):projectile} shot by {ToPrettyString(component.Shooter):user} hit {otherName:target} and dealt {modifiedDamage.Total:damage} damage");
         }
 
         if (!deleted)
         {
-            _guns.PlayImpactSound(otherEntity, modifiedDamage, component.SoundHit, component.ForceSound);
+            _guns.PlayImpactSound(target, modifiedDamage, component.SoundHit, component.ForceSound);
-            _sharedCameraRecoil.KickCamera(otherEntity, direction);
+            _sharedCameraRecoil.KickCamera(target, direction);
         }
 
-        var ev = new ProjectileCollideEvent(uid, false);
-        RaiseLocalEvent(args.OtherEntity, ref ev);
-
-        if (!ev.Cancelled)
-        {
         component.DamagedEntity = true;
 
         if (component.DeleteOnCollide)
@@ -82,4 +80,3 @@ public sealed class ProjectileSystem : SharedProjectileSystem
         }
     }
 }
-}

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);
     }
 
@@ -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.Target, component.Damage, source: uid);
-
-        TakeStaminaDamage(args.OtherEntity, component.Damage, source:args.OurEntity);
     }
 
     private void SetStaminaAlert(EntityUid uid, StaminaComponent? component = null)

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 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;
     }