Merge branch 'DeltaV-Station:master' into Pebble-Faxes

Author: FieldCommand

Content.Client/Doors/DoorSystem.cs

@@ -18,8 +18,36 @@ public override void Initialize()
     {
         base.Initialize();
         SubscribeLocalEvent<DoorComponent, AppearanceChangeEvent>(OnAppearanceChange);
+        // ES START
+        // handle open/close state change on client after animation end, not when server says door is open
+        SubscribeLocalEvent<DoorComponent, AnimationCompletedEvent>(OnAnimationCompleted);
     }
 
+    private void OnAnimationCompleted(Entity<DoorComponent> entity, ref AnimationCompletedEvent args)
+    {
+        if (!TryComp<SpriteComponent>(entity, out var sprite) || args.Key != DoorComponent.OpenCloseKey)
+            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;
+        }
+    }
+    // ES END
+
     protected override void OnComponentInit(Entity<DoorComponent> ent, ref ComponentInit args)
     {
         var comp = ent.Comp;
@@ -87,10 +115,13 @@ private void OnAppearanceChange(Entity<DoorComponent> entity, ref AppearanceChan
             state = DoorState.Closed;
 
         if (AppearanceSystem.TryGetData<string>(entity, PaintableVisuals.Prototype, out var prototype, args.Component))
-            UpdateSpriteLayers((entity.Owner, args.Sprite), prototype);
+             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,25 @@ private void UpdateAppearanceForDoorState(Entity<DoorComponent> entity, SpriteCo
         switch (state)
         {
             case DoorState.Open:
+                // ES START
+                // If we are already animating the close just let that do its job
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.OpenCloseKey))
+                    return;
+                // ES END
+
                 foreach (var (layer, layerState) in entity.Comp.OpenSpriteStates)
                 {
                     _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
                 }
 
                 return;
             case DoorState.Closed:
+                // ES START
+                // If we are already animating the close just let that do its job
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.OpenCloseKey))
+                    return;
+                // ES END
+
                 foreach (var (layer, layerState) in entity.Comp.ClosedSpriteStates)
                 {
                     _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
@@ -123,24 +166,41 @@ private void UpdateAppearanceForDoorState(Entity<DoorComponent> entity, SpriteCo
                 if (entity.Comp.OpeningAnimationTime == TimeSpan.Zero)
                     return;
 
-                _animationSystem.Play(entity, (Animation)entity.Comp.OpeningAnimation, DoorComponent.AnimationKey);
+                // ES START
+                // since we dont stop them earlier we check here
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.OpenCloseKey))
+                    return;
+                // ES END
+
+                _animationSystem.Play(entity, (Animation)entity.Comp.OpeningAnimation, DoorComponent.OpenCloseKey);
 
                 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);
+                // ES START
+                // since we dont stop them earlier we check here
+                if (_animationSystem.HasRunningAnimation(entity, DoorComponent.OpenCloseKey))
+                    return;
+                // ES END
+
+                _animationSystem.Play(entity, (Animation)entity.Comp.ClosingAnimation, DoorComponent.OpenCloseKey);
 
                 return;
             case DoorState.Denying:
-                _animationSystem.Play(entity, (Animation)entity.Comp.DenyingAnimation, DoorComponent.AnimationKey);
+                // ES START
+                // AnimationKey -> DenyKey
+                _animationSystem.Play(entity, (Animation)entity.Comp.DenyingAnimation, DoorComponent.DenyKey);
+                // ES END
 
                 return;
             case DoorState.Emagging:
-                // We are checking beforehand since some doors may not have an emagging visual layer.
+                // ES START
+                // AnimationKey -> DenyKey
                 if (_sprite.TryGetLayer(entity.Owner, DoorVisualLayers.BaseEmagging, out var _, false))
-                    _animationSystem.Play(entity, (Animation)entity.Comp.EmaggingAnimation, DoorComponent.AnimationKey);
+                    _animationSystem.Play(entity, (Animation)entity.Comp.EmaggingAnimation, DoorComponent.EmagKey);
+                // ES END
 
                 return;
         }

Content.Client/Stunnable/StunSystem.cs

@@ -1,10 +1,12 @@
 using System.Numerics;
+using Content.Shared._DV.CCVars; // DeltaV - Enable Stars via CVar.
 using Content.Shared.CombatMode;
 using Content.Shared.Interaction;
 using Content.Shared.Stunnable;
 using Robust.Client.Animations;
 using Robust.Client.GameObjects;
 using Robust.Shared.Animations;
+using Robust.Shared.Configuration; // DeltaV - Enable Stars via CVar.
 using Robust.Shared.Input;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.Random;
@@ -13,6 +15,7 @@ namespace Content.Client.Stunnable;
 
 public sealed class StunSystem : SharedStunSystem
 {
+    [Dependency] private readonly IConfigurationManager _cfg = default!; // DeltaV - Enable Stars via CVar.
     [Dependency] private readonly SharedCombatModeSystem _combat = default!;
     [Dependency] private readonly IRobustRandom _random = default!;
     [Dependency] private readonly SpriteSystem _spriteSystem = default!;
@@ -78,6 +81,9 @@ private void UpdateAppearance(Entity<SpriteComponent?> entity, string state)
 
         var visible = Appearance.TryGetData<bool>(entity, StunVisuals.SeeingStars, out var stars) && stars;
 
+        if (visible && !_cfg.GetCVar(DCCVars.ShowStunVisuals)) // DeltaV - Enable Stars via CVar.
+            visible = false;
+
         _spriteSystem.LayerSetVisible((entity, entity.Comp), index, visible);
         _spriteSystem.LayerSetRsiState((entity, entity.Comp), index, state);
     }

Content.Client/_DV/Access/Systems/SubdermalIdCardSystem.cs

@@ -0,0 +1,8 @@
+using Content.Shared._DV.Access.Systems;
+
+namespace Content.Client._DV.Access.Systems;
+
+/// <summary>
+/// Client side handling of the subdermal ID system.
+/// </summary>
+public sealed class SubdermalIdCardSystem : SharedSubdermalIdCardSystem;

Content.Client/_DV/Options/UI/Tabs/DeltaTab.xaml

@@ -9,6 +9,7 @@
                    StyleClasses="LabelKeyText"/>
             <CheckBox Name="DisableFiltersCheckBox" Text="{Loc 'ui-options-no-filters'}" />
             <CheckBox Name="DisableGlimmerEffectCheckBox" Text="{Loc 'ui-options-disable-glimmer-effect'}" />
+            <CheckBox Name="EnableStunVisualsCheckBox" Text="{Loc 'ui-options-enable-stun-visuals'}" />
             <Label Text="{Loc 'ui-options-delta-tips'}"
                    StyleClasses="LabelKeyText"/>
             <CheckBox Name="DisableTipsCheckBox" Text="{Loc 'ui-options-delta-disable-tips'}" />

Content.Client/_DV/Options/UI/Tabs/DeltaTab.xaml.cs

@@ -18,6 +18,7 @@ public DeltaTab()
 
         Control.AddOptionCheckBox(DCCVars.NoVisionFilters, DisableFiltersCheckBox);
         Control.AddOptionCheckBox(DCCVars.DisableGlimmerShader, DisableGlimmerEffectCheckBox);
+        Control.AddOptionCheckBox(DCCVars.ShowStunVisuals, EnableStunVisualsCheckBox);
         Control.AddOptionCheckBox(DCCVars.DisableTips, DisableTipsCheckBox);
 
         ResetTipsButton.OnPressed += _ => OnResetTipsPressed();

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 class ESTimedDespawnLightFadeSystem : VisualizerSystem<ESTimedDespawnLightFadeComponent>
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly 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 class ESTimedDespawnSpriteFadeSystem : VisualizerSystem<ESTimedDespawnSpriteFadeComponent>
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly 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);
+    }
+}