Merge branch 'starlight-dev' into how-to-cook-for-40-spacemen

Author: bynddark8

Content.Client/DoAfter/DoAfterOverlay.cs

@@ -37,6 +37,15 @@ public sealed class DoAfterOverlay : Overlay
     private const float StartX = 2;
     private const float EndX = 22f;
 
+    // Time after which the doafter will lerp to max alpha.Add a comment on  line R40Add diff commentMarkdown input:  edit mode selected.WritePreviewAdd a suggestionHeadingBoldItalicQuoteCodeLinkUnordered listNumbered listTask listMentionReferenceMore itemsSaved repliesAdd FilesPaste, drop, or click to add filesCancelCommentStart a review
+    private static readonly TimeSpan MaxAlphaTime = TimeSpan.FromSeconds(0.3f);
+
+    // After finishing, how long it takes to fade out to 0 alpha
+    private static readonly TimeSpan FadeoutAlphaTime = TimeSpan.FromSeconds(0.2f);
+
+    // Time after which the doafter will lerp to its final y offset.
+    private static readonly TimeSpan MaxYPosTime = TimeSpan.FromSeconds(0.5f);
+
     public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
 
     public DoAfterOverlay(IEntityManager entManager, IPrototypeManager protoManager, IGameTiming timing, IPlayerManager player)
@@ -110,43 +119,52 @@ protected override void Draw(in OverlayDrawArgs args)
             foreach (var doAfter in comp.DoAfters.Values)
             {
                 // Hide some DoAfters from other players for stealthy actions (ie: thieving gloves)
-                var alpha = 1f;
+                var maxAlpha = 1f;
                 if (doAfter.Args.Hidden || isInContainer)
                 {
                     if (uid != localEnt)
                         continue;
 
                     // Hints to the local player that this do-after is not visible to other players.
-                    alpha = 0.5f;
+                    maxAlpha = 0.5f;
                 }
 
+                var elapsed = time - doAfter.StartTime;
+
+                var alpha = MathHelper.Lerp(0f, maxAlpha, (float)Math.Clamp(elapsed / MaxAlphaTime, 0.0, 1.0));
+                // fade out if doafter finished
+                if (elapsed >= doAfter.Args.Delay)
+                    alpha = MathHelper.Lerp(maxAlpha, 0f, (float)Math.Clamp((elapsed - doAfter.Args.Delay) / FadeoutAlphaTime, 0.0, 1.0));
+
                 // Use the sprite itself if we know its bounds. This means short or tall sprites don't get overlapped
                 // by the bar.
-                var yOffset = _sprite.GetLocalBounds((uid, sprite)).Height / 2f + 0.05f;
+                var spriteBounds = _sprite.GetLocalBounds((uid, sprite));
+                var yFinished = spriteBounds.Height / 2f + 0.05f;
+                var yStart = yFinished / 6f;
+                var yOffset = MathHelper.Lerp(yStart, yFinished, Easings.OutSine((float)Math.Clamp(elapsed / MaxYPosTime, 0.0, 1.0)));
 
                 // Position above the entity (we've already applied the matrix transform to the entity itself)
                 // Offset by the texture size for every do_after we have.
                 var position = new Vector2(-_barTexture.Width / 2f / EyeManager.PixelsPerMeter,
                     yOffset / scale + offset / EyeManager.PixelsPerMeter * scale);
 
                 // Draw the underlying bar texture
-                handle.DrawTexture(_barTexture, position);
+                handle.DrawTexture(_barTexture, position, Color.White.WithAlpha(alpha));
 
                 Color color;
                 float elapsedRatio;
 
                 // if we're cancelled then flick red / off.
                 if (doAfter.CancelledTime != null)
                 {
-                    var elapsed = doAfter.CancelledTime.Value - doAfter.StartTime;
+                    elapsed = doAfter.CancelledTime.Value - doAfter.StartTime;
                     elapsedRatio = (float)Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
                     var cancelElapsed = (time - doAfter.CancelledTime.Value).TotalSeconds;
                     var flash = Math.Floor(cancelElapsed / FlashTime) % 2 == 0;
                     color = GetProgressColor(0, flash ? alpha : 0);
                 }
                 else
                 {
-                    var elapsed = time - doAfter.StartTime;
                     elapsedRatio = (float)Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
                     color = GetProgressColor(elapsedRatio, alpha);
                 }

Content.Client/Doors/DoorSystem.cs

@@ -18,6 +18,34 @@ public override void Initialize()
     {
         base.Initialize();
         SubscribeLocalEvent<DoorComponent, AppearanceChangeEvent>(OnAppearanceChange);
+        SubscribeLocalEvent<DoorComponent, AnimationCompletedEvent>(OnAnimationCompleted);
+    }
+
+    private void OnAnimationCompleted(Entity<DoorComponent> entity, ref AnimationCompletedEvent args)
+    {
+        if (args.Key != DoorComponent.OpenKey && args.Key != DoorComponent.CloseKey)
+            return;
+
+        if (!TryComp<SpriteComponent>(entity, out var sprite)) // Starlight
+            return;
+
+        switch (entity.Comp.State)
+        {
+            case DoorState.Open:
+                foreach (var (layer, layerState) in entity.Comp.OpenSpriteStates)
+                {
+                    _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
+                }
+
+                break;
+            case DoorState.Closed:
+                foreach (var (layer, layerState) in entity.Comp.ClosedSpriteStates)
+                {
+                    _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
+                }
+
+                break;
+        }
     }
 
     protected override void OnComponentInit(Entity<DoorComponent> ent, ref ComponentInit args)
@@ -89,8 +117,11 @@ private void OnAppearanceChange(Entity<DoorComponent> entity, ref AppearanceChan
         if (AppearanceSystem.TryGetData<string>(entity, PaintableVisuals.Prototype, out var prototype, args.Component))
             UpdateSpriteLayers((entity.Owner, args.Sprite), prototype);
 
-        if (_animationSystem.HasRunningAnimation(entity, DoorComponent.AnimationKey))
-            _animationSystem.Stop(entity.Owner, DoorComponent.AnimationKey);
+        // ES START
+        // dont stop all animations for no reason
+        //if (_animationSystem.HasRunningAnimation(entity, DoorComponent.AnimationKey))
+        //    _animationSystem.Stop(entity.Owner, DoorComponent.AnimationKey);
+        // ES END
 
         // We are checking beforehand since some doors may not have an emagging visual layer, and we don't want LayerSetVisible to throw an error.
         if (_sprite.TryGetLayer(entity.Owner, DoorVisualLayers.BaseEmagging, out var _, false))
@@ -106,13 +137,37 @@ private void UpdateAppearanceForDoorState(Entity<DoorComponent> entity, SpriteCo
         switch (state)
         {
             case DoorState.Open:
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.OpenKey))
+                    return;
+
+                // Moffstation - Start - Don't stop animations
+                /*
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.CloseKey))
+                {
+                    _animationSystem.Stop(entity, null, DoorComponent.CloseKey);
+                    _animationSystem.Play(entity, (Animation)entity.Comp.OpeningAnimation, DoorComponent.OpenKey);
+                }
+                */ // Moffstation - End
+
                 foreach (var (layer, layerState) in entity.Comp.OpenSpriteStates)
                 {
                     _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
                 }
 
                 return;
             case DoorState.Closed:
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.CloseKey))
+                    return;
+
+                // Moffstation - Start - Don't stop animations
+                /*
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.OpenKey))
+                {
+                    _animationSystem.Stop(entity, null, DoorComponent.OpenKey);
+                    _animationSystem.Play(entity, (Animation)entity.Comp.OpeningAnimation, DoorComponent.OpenKey);
+                }
+                */ // Moffstation - End
+
                 foreach (var (layer, layerState) in entity.Comp.ClosedSpriteStates)
                 {
                     _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
@@ -123,24 +178,34 @@ private void UpdateAppearanceForDoorState(Entity<DoorComponent> entity, SpriteCo
                 if (entity.Comp.OpeningAnimationTime == TimeSpan.Zero)
                     return;
 
-                _animationSystem.Play(entity, (Animation)entity.Comp.OpeningAnimation, DoorComponent.AnimationKey);
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.OpenKey))
+                    return;
+
+                _animationSystem.Play(entity, (Animation)entity.Comp.OpeningAnimation, DoorComponent.OpenKey);
 
                 return;
             case DoorState.Closing:
                 if (entity.Comp.ClosingAnimationTime == TimeSpan.Zero || entity.Comp.CurrentlyCrushing.Count != 0)
                     return;
 
-                _animationSystem.Play(entity, (Animation)entity.Comp.ClosingAnimation, DoorComponent.AnimationKey);
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.CloseKey))
+                    return;
+
+                _animationSystem.Play(entity, (Animation)entity.Comp.ClosingAnimation, DoorComponent.CloseKey);
 
                 return;
             case DoorState.Denying:
-                _animationSystem.Play(entity, (Animation)entity.Comp.DenyingAnimation, DoorComponent.AnimationKey);
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.DenyKey))
+                    return;
+
+                _animationSystem.Play(entity, (Animation)entity.Comp.DenyingAnimation, DoorComponent.DenyKey);
 
                 return;
             case DoorState.Emagging:
-                // We are checking beforehand since some doors may not have an emagging visual layer.
-                if (_sprite.TryGetLayer(entity.Owner, DoorVisualLayers.BaseEmagging, out var _, false))
-                    _animationSystem.Play(entity, (Animation)entity.Comp.EmaggingAnimation, DoorComponent.AnimationKey);
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.EmagKey))
+                    return;
+
+                _animationSystem.Play(entity, (Animation)entity.Comp.EmaggingAnimation, DoorComponent.EmagKey);
 
                 return;
         }

Content.Client/_ES/Lighting/Components/ESTimedDespawnLightFadeComponent.cs

@@ -0,0 +1,14 @@
+using Content.Shared._ES.Core.Timer.Components;
+
+namespace Content.Client._ES.Lighting.Components;
+
+/// <summary>
+/// Handles a point light that fades out while synced to a <see cref="ESTimedDespawnComponent"/>
+/// </summary>
+[RegisterComponent]
+[Access(typeof(ESTimedDespawnLightFadeSystem))]
+public sealed partial class ESTimedDespawnLightFadeComponent : Component
+{
+    [DataField]
+    public TimeSpan FadeTime = TimeSpan.FromSeconds(1);
+}

Content.Client/_ES/Lighting/ESTimedDespawnLightFadeSystem.cs

@@ -0,0 +1,52 @@
+using Content.Client._ES.Lighting.Components;
+using Content.Shared._ES.Core.Timer.Components;
+using Robust.Client.Animations;
+using Robust.Client.GameObjects;
+using Robust.Shared.Animations;
+using Robust.Shared.Timing;
+
+namespace Content.Client._ES.Lighting;
+
+public sealed partial class ESTimedDespawnLightFadeSystem : VisualizerSystem<ESTimedDespawnLightFadeComponent>
+{
+    [Dependency] private IGameTiming _timing = default!;
+    [Dependency] private AnimationPlayerSystem _animationPlayer = default!;
+
+    private const string FadeTrack = "light-fade";
+
+    protected override void OnAppearanceChange(EntityUid uid, ESTimedDespawnLightFadeComponent component, ref AppearanceChangeEvent args)
+    {
+        base.OnAppearanceChange(uid, component, ref args);
+
+        if (_animationPlayer.HasRunningAnimation(uid, FadeTrack))
+            return;
+
+        if (!AppearanceSystem.TryGetData<TimeSpan>(uid, ESTimedDespawnVisuals.DespawnTime, out var time, args.Component) ||
+            !TryComp<PointLightComponent>(uid, out var light))
+            return;
+
+        var duration = time - _timing.CurTime;
+
+        var animation = new Animation
+        {
+            Length = duration,
+            AnimationTracks =
+            {
+                new AnimationTrackComponentProperty
+                {
+                    Property = nameof(PointLightComponent.Energy),
+                    ComponentType = typeof(PointLightComponent),
+                    InterpolationMode = AnimationInterpolationMode.Linear,
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(light.Energy, 0f),
+                        new AnimationTrackProperty.KeyFrame(light.Energy, (float) (duration - component.FadeTime).TotalSeconds),
+                        new AnimationTrackProperty.KeyFrame(0f, (float) component.FadeTime.TotalSeconds, Easings.OutSine),
+                    }
+                }
+            }
+        };
+
+        _animationPlayer.Play(uid, animation, FadeTrack);
+    }
+}

Content.Client/_ES/Sprite/Components/ESTimedDespawnSpriteFadeComponent.cs

@@ -0,0 +1,14 @@
+using Content.Shared._ES.Core.Timer.Components;
+
+namespace Content.Client._ES.Sprite.Components;
+
+/// <summary>
+/// Handles a sprite that fades out while synced to a <see cref="ESTimedDespawnComponent"/>
+/// </summary>
+[RegisterComponent]
+[Access(typeof(ESTimedDespawnSpriteFadeSystem))]
+public sealed partial class ESTimedDespawnSpriteFadeComponent : Component
+{
+    [DataField]
+    public TimeSpan FadeTime = TimeSpan.FromSeconds(1);
+}

Content.Client/_ES/Sprite/ESTimedDespawnSpriteFadeSystem.cs

@@ -0,0 +1,57 @@
+using Content.Client._ES.Sprite.Components;
+using Content.Shared._ES.Core.Timer.Components;
+using Robust.Client.Animations;
+using Robust.Client.GameObjects;
+using Robust.Shared.Animations;
+using Robust.Shared.Timing;
+
+namespace Content.Client._ES.Sprite;
+
+/// <summary>
+/// This handles <see cref="ESTimedDespawnSpriteFadeComponent"/>
+/// </summary>
+public sealed partial class ESTimedDespawnSpriteFadeSystem : VisualizerSystem<ESTimedDespawnSpriteFadeComponent>
+{
+    [Dependency] private IGameTiming _timing = default!;
+    [Dependency] private AnimationPlayerSystem _animationPlayer = default!;
+
+    private const string FadeTrack = "es-sprite-fade";
+
+    protected override void OnAppearanceChange(EntityUid uid, ESTimedDespawnSpriteFadeComponent component, ref AppearanceChangeEvent args)
+    {
+        base.OnAppearanceChange(uid, component, ref args);
+
+        if (args.Sprite is not { } sprite)
+            return;
+
+        if (_animationPlayer.HasRunningAnimation(uid, FadeTrack))
+            return;
+
+        if (!AppearanceSystem.TryGetData<TimeSpan>(uid, ESTimedDespawnVisuals.DespawnTime, out var time, args.Component))
+            return;
+
+        var duration = time - _timing.CurTime;
+
+        var animation = new Animation
+        {
+            Length = duration,
+            AnimationTracks =
+            {
+                new AnimationTrackComponentProperty
+                {
+                    Property = nameof(SpriteComponent.Color),
+                    ComponentType = typeof(SpriteComponent),
+                    InterpolationMode = AnimationInterpolationMode.Linear,
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(sprite.Color, 0f),
+                        new AnimationTrackProperty.KeyFrame(sprite.Color, MathF.Max((float) (duration - component.FadeTime).TotalSeconds, 0f)),
+                        new AnimationTrackProperty.KeyFrame(sprite.Color.WithAlpha(0f), (float) component.FadeTime.TotalSeconds, Easings.OutSine),
+                    },
+                },
+            },
+        };
+
+        _animationPlayer.Play(uid, animation, FadeTrack);
+    }
+}

Content.Client/_FarHorizons/Power/Generation/FissionGenerator/ReactorPartSystem.cs

@@ -1,5 +1,6 @@
 using Content.Shared._FarHorizons.Power.Generation.FissionGenerator;
 using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
 using Robust.Shared.Prototypes;
 
 namespace Content.Client._FarHorizons.Power.Generation.FissionGenerator;
@@ -9,10 +10,15 @@ public sealed partial class ReactorPartSystem : EntitySystem
     [Dependency] private IPrototypeManager _proto = default!;
     [Dependency] private SpriteSystem _sprite = default!;
 
+    private static readonly ProtoId<ShaderPrototype> _shaderID = "HeatDistortionFH";
+    private ShaderInstance _heatShader = default!;
+
     public override void Initialize()
     {
         base.Initialize();
 
+        _heatShader = _proto.Index(_shaderID).InstanceUnique();
+
         SubscribeLocalEvent<ReactorPartComponent, AppearanceChangeEvent>(OnAppearanceChange);
         SubscribeLocalEvent<ReactorPartComponent, ComponentInit>(OnComponentInit);
     }
@@ -27,8 +33,11 @@ private void OnAppearanceChange(EntityUid uid, ReactorPartComponent component, r
         //    return;
 
         _sprite.LayerSetColor((uid, args.Sprite), 0, _proto.Index(component.Material).Color);
+
+        if (args.AppearanceData.TryGetValue(ReactorPartVisuals.HeatDistort, out var value) && value is bool enabled)
+            args.Sprite.PostShader = enabled ? _heatShader : null;
     }
 
     private void OnComponentInit(Entity<ReactorPartComponent> ent, ref ComponentInit args)
-        => _sprite.LayerSetColor((ent.Owner, EntityManager.GetComponent<SpriteComponent>(ent.Owner)), 0, _proto.Index(ent.Comp.Material).Color);
+        => _sprite.LayerSetColor((ent.Owner, Comp<SpriteComponent>(ent.Owner)), 0, _proto.Index(ent.Comp.Material).Color);
 }

Content.Client/_FarHorizons/Power/UI/NuclearReactorBoundUserInterface.cs

@@ -42,6 +42,7 @@ protected override void Open()
         _window.ItemActionButtonPressed += OnActionButtonPressed;
         _window.EjectButtonPressed += OnEjectButtonPressed;
         _window.ControlRodModify += OnControlRodModify;
+        _window.AckButtonPressed += OnAckButtonPressed;
 
         Update();
     }
@@ -74,4 +75,11 @@ private void OnControlRodModify(float amount)
 
         SendPredictedMessage(new ReactorControlRodModifyMessage(amount));
     }
+
+    private void OnAckButtonPressed()
+    {
+        if (_window is null) return;
+
+        SendPredictedMessage(new ReactorAlarmAckMessage());
+    }
 }