Upstream Merge: The Omega PR

Content.Client/Administration/UI/Tabs/ObjectsTab/ObjectsTab.xaml.cs

@@ -76,7 +76,7 @@ private void RefreshObjectList(ObjectsTabSelection selection)
         switch (selection)
         {
             case ObjectsTabSelection.Stations:
-                entities.AddRange(_entityManager.EntitySysManager.GetEntitySystem<StationSystem>().Stations);
+                entities.AddRange(_entityManager.EntitySysManager.GetEntitySystem<StationSystem>().GetStationNames());
                 break;
             case ObjectsTabSelection.Grids:
             {

Content.Client/Animals/Systems/ParrotMemorySystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.Animals.Systems;
+
+namespace Content.Client.Animals.Systems;
+
+public sealed class ParrotMemorySystem : SharedParrotMemorySystem;

Content.Client/Body/Systems/BloodStreamSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.Body.Systems;
+
+namespace Content.Client.Body.Systems;
+
+public sealed class BloodstreamSystem : SharedBloodstreamSystem;

Content.Client/Chemistry/EntitySystems/InjectorStatusControlSystem.cs

@@ -0,0 +1,20 @@
+using Content.Client.Chemistry.UI;
+using Content.Client.Items;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Chemistry.EntitySystems;
+
+public sealed class InjectorStatusControlSystem : EntitySystem
+{
+    [Dependency] private readonly SharedSolutionContainerSystem _solutionContainers = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        Subs.ItemStatus<InjectorComponent>(injector => new InjectorStatusControl(injector, _solutionContainers, _prototypeManager));
+    }
+}

Content.Client/Chemistry/UI/InjectorStatusControl.cs

@@ -2,26 +2,32 @@
 using Content.Client.Stylesheets;
 using Content.Shared.Chemistry.Components;
 using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Prototypes;
 using Content.Shared.FixedPoint;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Timing;
 
 namespace Content.Client.Chemistry.UI;
 
 public sealed class InjectorStatusControl : Control
 {
+    private readonly IPrototypeManager _prototypeManager;
+
     private readonly Entity<InjectorComponent> _parent;
     private readonly SharedSolutionContainerSystem _solutionContainers;
     private readonly RichTextLabel _label;
 
-    private FixedPoint2 PrevVolume;
-    private FixedPoint2 PrevMaxVolume;
-    private FixedPoint2 PrevTransferAmount;
-    private InjectorToggleMode PrevToggleState;
+    private FixedPoint2 _prevVolume;
+    private FixedPoint2 _prevMaxVolume;
+    private FixedPoint2? _prevTransferAmount;
+    private InjectorBehavior _prevBehavior;
 
-    public InjectorStatusControl(Entity<InjectorComponent> parent, SharedSolutionContainerSystem solutionContainers)
+    public InjectorStatusControl(Entity<InjectorComponent> parent, SharedSolutionContainerSystem solutionContainers, IPrototypeManager prototypeManager)
     {
+        _prototypeManager  = prototypeManager;
+
         _parent = parent;
         _solutionContainers = solutionContainers;
         _label = new RichTextLabel { StyleClasses = { StyleNano.StyleClassItemStatus } };
@@ -32,33 +38,38 @@ protected override void FrameUpdate(FrameEventArgs args)
     {
         base.FrameUpdate(args);
 
-        if (!_solutionContainers.TryGetSolution(_parent.Owner, _parent.Comp.SolutionName, out _, out var solution))
+        if (!_solutionContainers.TryGetSolution(_parent.Owner, _parent.Comp.SolutionName, out _, out var solution)
+            || !_prototypeManager.Resolve(_parent.Comp.ActiveModeProtoId, out var activeMode))
             return;
 
         // only updates the UI if any of the details are different than they previously were
-        if (PrevVolume == solution.Volume
-            && PrevMaxVolume == solution.MaxVolume
-            && PrevTransferAmount == _parent.Comp.TransferAmount
-            && PrevToggleState == _parent.Comp.ToggleState)
+        if (_prevVolume == solution.Volume
+            && _prevMaxVolume == solution.MaxVolume
+            && _prevTransferAmount == _parent.Comp.CurrentTransferAmount
+            && _prevBehavior == activeMode.Behavior)
             return;
 
-        PrevVolume = solution.Volume;
-        PrevMaxVolume = solution.MaxVolume;
-        PrevTransferAmount = _parent.Comp.TransferAmount;
-        PrevToggleState = _parent.Comp.ToggleState;
+        _prevVolume = solution.Volume;
+        _prevMaxVolume = solution.MaxVolume;
+        _prevTransferAmount = _parent.Comp.CurrentTransferAmount;
+        _prevBehavior = activeMode.Behavior;
 
         // Update current volume and injector state
-        var modeStringLocalized = Loc.GetString(_parent.Comp.ToggleState switch
+        // Seeing transfer volume is only important for injectors that can change it.
+        if (activeMode.TransferAmounts.Count > 1 && _parent.Comp.CurrentTransferAmount.HasValue)
         {
-            InjectorToggleMode.Draw => "injector-draw-text",
-            InjectorToggleMode.Inject => "injector-inject-text",
-            _ => "injector-invalid-injector-toggle-mode"
-        });
-
-        _label.SetMarkup(Loc.GetString("injector-volume-label",
-            ("currentVolume", solution.Volume),
-            ("totalVolume", solution.MaxVolume),
-            ("modeString", modeStringLocalized),
-            ("transferVolume", _parent.Comp.TransferAmount)));
+            _label.SetMarkup(Loc.GetString("injector-volume-transfer-label",
+                ("currentVolume", solution.Volume),
+                ("totalVolume", solution.MaxVolume),
+                ("modeString", Loc.GetString(activeMode.Name)),
+                ("transferVolume", _parent.Comp.CurrentTransferAmount.Value)));
+        }
+        else
+        {
+            _label.SetMarkup(Loc.GetString("injector-volume-label",
+                ("currentVolume", solution.Volume),
+                ("totalVolume", solution.MaxVolume),
+                ("modeString", Loc.GetString(activeMode.Name))));
+        }
     }
 }

Content.Client/Damage/Systems/StaminaSystem.cs

@@ -0,0 +1,126 @@
+using Content.Client.Stunnable;
+using Content.Shared.Damage.Components;
+using Content.Shared.Damage.Systems;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Systems;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.Damage.Systems;
+
+public sealed partial class StaminaSystem : SharedStaminaSystem
+{
+    [Dependency] private readonly AnimationPlayerSystem _animation = default!;
+    [Dependency] private readonly MobStateSystem _mobState = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+    [Dependency] private readonly StunSystem _stun = default!; // Clientside Stun System
+
+    private const string StaminaAnimationKey = "stamina";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<StaminaComponent, AnimationCompletedEvent>(OnAnimationCompleted);
+        SubscribeLocalEvent<ActiveStaminaComponent, ComponentShutdown>(OnActiveStaminaShutdown);
+        SubscribeLocalEvent<StaminaComponent, MobStateChangedEvent>(OnMobStateChanged);
+    }
+
+    protected override void OnStamHandleState(Entity<StaminaComponent> entity, ref AfterAutoHandleStateEvent args)
+    {
+        base.OnStamHandleState(entity, ref args);
+
+        TryStartAnimation(entity);
+    }
+
+    private void OnActiveStaminaShutdown(Entity<ActiveStaminaComponent> entity, ref ComponentShutdown args)
+    {
+        // If we don't have active stamina, we shouldn't have stamina damage. If the update loop can trust it we can trust it.
+        if (!TryComp<StaminaComponent>(entity, out var stamina))
+            return;
+
+        StopAnimation((entity, stamina));
+    }
+
+    protected override void OnShutdown(Entity<StaminaComponent> entity, ref ComponentShutdown args)
+    {
+        base.OnShutdown(entity, ref args);
+
+        StopAnimation(entity);
+    }
+
+    private void OnMobStateChanged(Entity<StaminaComponent> ent, ref MobStateChangedEvent args)
+    {
+        if (args.NewMobState == MobState.Dead)
+            StopAnimation(ent);
+    }
+
+    private void TryStartAnimation(Entity<StaminaComponent> entity)
+    {
+        if (!TryComp<SpriteComponent>(entity, out var sprite))
+            return;
+
+        // If the animation is running, the system should update it accordingly
+        // If we're below the threshold to animate, don't try to animate
+        // If we're in stamcrit don't override it
+        if (entity.Comp.AnimationThreshold > entity.Comp.StaminaDamage || _animation.HasRunningAnimation(entity, StaminaAnimationKey))
+            return;
+
+        // Don't animate if we're dead
+        if (_mobState.IsDead(entity))
+            return;
+
+        entity.Comp.StartOffset = sprite.Offset;
+
+        PlayAnimation((entity, entity.Comp, sprite));
+    }
+
+    private void StopAnimation(Entity<StaminaComponent, SpriteComponent?> entity)
+    {
+        if(!Resolve(entity, ref entity.Comp2))
+            return;
+
+        _animation.Stop(entity.Owner, StaminaAnimationKey);
+        entity.Comp1.StartOffset = entity.Comp2.Offset;
+    }
+
+    private void OnAnimationCompleted(Entity<StaminaComponent> entity, ref AnimationCompletedEvent args)
+    {
+        if (args.Key != StaminaAnimationKey || !args.Finished || !TryComp<SpriteComponent>(entity, out var sprite))
+            return;
+
+        // stop looping if we're below the threshold
+        if (entity.Comp.AnimationThreshold > entity.Comp.StaminaDamage)
+        {
+            _animation.Stop(entity.Owner, StaminaAnimationKey);
+            _sprite.SetOffset((entity, sprite), entity.Comp.StartOffset);
+            return;
+        }
+
+        if (!HasComp<AnimationPlayerComponent>(entity))
+            return;
+
+        PlayAnimation((entity, entity.Comp, sprite));
+    }
+
+    private void PlayAnimation(Entity<StaminaComponent, SpriteComponent> entity)
+    {
+        var step = Math.Clamp((entity.Comp1.StaminaDamage - entity.Comp1.AnimationThreshold) /
+                              (entity.Comp1.CritThreshold - entity.Comp1.AnimationThreshold),
+            0f,
+            1f); // The things I do for project 0 warnings
+        var frequency = entity.Comp1.FrequencyMin + step * entity.Comp1.FrequencyMod;
+        var jitter = entity.Comp1.JitterAmplitudeMin + step * entity.Comp1.JitterAmplitudeMod;
+        var breathing = entity.Comp1.BreathingAmplitudeMin + step * entity.Comp1.BreathingAmplitudeMod;
+
+        _animation.Play(entity.Owner,
+            _stun.GetFatigueAnimation(entity.Comp2,
+                frequency,
+                entity.Comp1.Jitters,
+                jitter * entity.Comp1.JitterMin,
+                jitter * entity.Comp1.JitterMax,
+                breathing,
+                entity.Comp1.StartOffset,
+                ref entity.Comp1.LastJitter),
+            StaminaAnimationKey);
+    }
+}