Move and rename damage effect to color flash effect (#18263)

* move damage effect to different package

* rename to ColorFlashEffect

* renaming some other things

Content.Client/Effects/ColorFlashEffectSystem.cs

@@ -0,0 +1,107 @@
+using Content.Shared.Effects;
+using Robust.Client.Animations;
+using Robust.Client.GameObjects;
+using Robust.Shared.Animations;
+
+namespace Content.Client.Effects;
+
+public sealed class ColorFlashEffectSystem : EntitySystem
+{
+    [Dependency] private readonly AnimationPlayerSystem _animation = default!;
+
+    /// <summary>
+    /// It's a little on the long side but given we use multiple colours denoting what happened it makes it easier to register.
+    /// </summary>
+    private const float AnimationLength = 0.30f;
+    private const string AnimationKey = "color-flash-effect";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeAllEvent<ColorFlashEffectEvent>(OnColorFlashEffect);
+        SubscribeLocalEvent<ColorFlashEffectComponent, AnimationCompletedEvent>(OnEffectAnimationCompleted);
+    }
+
+    private void OnEffectAnimationCompleted(EntityUid uid, ColorFlashEffectComponent component, AnimationCompletedEvent args)
+    {
+        if (args.Key != AnimationKey)
+            return;
+
+        if (TryComp<SpriteComponent>(uid, out var sprite))
+        {
+            sprite.Color = component.Color;
+        }
+
+        RemCompDeferred<ColorFlashEffectComponent>(uid);
+    }
+
+    private Animation? GetDamageAnimation(EntityUid uid, Color color, SpriteComponent? sprite = null)
+    {
+        if (!Resolve(uid, ref sprite, false))
+            return null;
+
+        // 90% of them are going to be this so why allocate a new class.
+        return new Animation
+        {
+            Length = TimeSpan.FromSeconds(AnimationLength),
+            AnimationTracks =
+            {
+                new AnimationTrackComponentProperty
+                {
+                    ComponentType = typeof(SpriteComponent),
+                    Property = nameof(SpriteComponent.Color),
+                    InterpolationMode = AnimationInterpolationMode.Linear,
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(color, 0f),
+                        new AnimationTrackProperty.KeyFrame(sprite.Color, AnimationLength)
+                    }
+                }
+            }
+        };
+    }
+
+    private void OnColorFlashEffect(ColorFlashEffectEvent ev)
+    {
+        var color = ev.Color;
+
+        foreach (var ent in ev.Entities)
+        {
+            if (Deleted(ent))
+            {
+                continue;
+            }
+
+            var player = EnsureComp<AnimationPlayerComponent>(ent);
+            player.NetSyncEnabled = false;
+
+            // Need to stop the existing animation first to ensure the sprite color is fixed.
+            // Otherwise we might lerp to a red colour instead.
+            if (_animation.HasRunningAnimation(ent, player, AnimationKey))
+            {
+                _animation.Stop(ent, player, AnimationKey);
+            }
+
+            if (!TryComp<SpriteComponent>(ent, out var sprite))
+            {
+                continue;
+            }
+
+            if (TryComp<ColorFlashEffectComponent>(ent, out var effect))
+            {
+                sprite.Color = effect.Color;
+            }
+
+            var animation = GetDamageAnimation(ent, color, sprite);
+
+            if (animation == null)
+                continue;
+
+            var comp = EnsureComp<ColorFlashEffectComponent>(ent);
+            comp.NetSyncEnabled = false;
+            comp.Color = sprite.Color;
+            _animation.Play(player, animation, AnimationKey);
+        }
+    }
+}