revenant refactor

Content.Client/Revenant/Components/RevenantVisualsComponent.cs

@@ -0,0 +1,19 @@
+using Robust.Client.Graphics;
+
+namespace Content.Client.Revenant.Components;
+
+[RegisterComponent]
+public sealed partial class RevenantVisualsComponent : Component
+{
+    [ViewVariables]
+    public RSI.StateId State = "idle";
+
+    [ViewVariables]
+    public RSI.StateId CorporealState = "active";
+
+    [ViewVariables]
+    public RSI.StateId StunnedState = "stunned";
+
+    [ViewVariables]
+    public RSI.StateId HarvestingState = "harvesting";
+}

Content.Client/Revenant/Systems/CorporealSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.Revenant.Systems;
+
+namespace Content.Client.Revenant.Systems;
+
+public sealed class CorporealSystem : SharedCorporealSystem;

Content.Client/Revenant/Systems/EssenceSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.Revenant.Systems;
+
+namespace Content.Client.Revenant.Systems;
+
+public sealed class EssenceSystem : SharedEssenceSystem;

Content.Client/Revenant/RevenantOverloadedLightsSystem.cs → Content.Client/Revenant/Systems/RevenantOverloadedLightsSystem.cs

@@ -1,8 +1,8 @@
 using Content.Shared.Revenant.Components;
-using Content.Shared.Revenant.EntitySystems;
+using Content.Shared.Revenant.Systems;
 using Robust.Client.GameObjects;
 
-namespace Content.Client.Revenant;
+namespace Content.Client.Revenant.Systems;
 
 public sealed class RevenantOverloadedLightsSystem : SharedRevenantOverloadedLightsSystem
 {
@@ -25,38 +25,37 @@ public override void Update(float frameTime)
         while (enumerator.MoveNext(out var uid, out var comp, out var light))
         {
             //this looks cool :HECK:
-            _lights.SetEnergy(uid, 2f * Math.Abs((float) Math.Sin(0.25 * Math.PI * comp.Accumulator)), light);
+            _lights.SetEnergy(uid, 2f * Math.Abs((float) Math.Sin(0.25 * Math.PI * comp.NextZapTime.TotalSeconds)), light);
         }
     }
 
-    private void OnStartup(EntityUid uid, RevenantOverloadedLightsComponent component, ComponentStartup args)
+    private void OnStartup(Entity<RevenantOverloadedLightsComponent> ent, ref ComponentStartup args)
     {
-        var light = _lights.EnsureLight(uid);
-        component.OriginalEnergy = light.Energy;
-        component.OriginalEnabled = light.Enabled;
+        var light = _lights.EnsureLight(ent);
+        ent.Comp.OriginalEnergy = light.Energy;
+        ent.Comp.OriginalEnabled = light.Enabled;
 
-        _lights.SetEnabled(uid, component.OriginalEnabled, light);
-        Dirty(uid, light);
+        _lights.SetEnabled(ent, ent.Comp.OriginalEnabled, light);
+        Dirty(ent, light);
     }
 
-    private void OnShutdown(EntityUid uid, RevenantOverloadedLightsComponent component, ComponentShutdown args)
+    private void OnShutdown(Entity<RevenantOverloadedLightsComponent> ent, ref ComponentShutdown args)
     {
-        if (!_lights.TryGetLight(uid, out var light))
+        if (!_lights.TryGetLight(ent, out var light))
             return;
 
-        if (component.OriginalEnergy == null)
+        if (ent.Comp.OriginalEnergy is not { } originalEnergy)
         {
-            RemComp(uid, light);
+            RemComp(ent, light);
             return;
         }
 
-        _lights.SetEnergy(uid, component.OriginalEnergy.Value, light);
-        _lights.SetEnabled(uid, component.OriginalEnabled, light);
-        Dirty(uid, light);
+        _lights.SetEnergy(ent, originalEnergy, light);
+        _lights.SetEnabled(ent, ent.Comp.OriginalEnabled, light);
+        Dirty(ent, light);
     }
 
     protected override void OnZap(Entity<RevenantOverloadedLightsComponent> component)
     {
-
     }
 }

Content.Client/Revenant/Systems/RevenantSystem.cs

@@ -0,0 +1,28 @@
+using Content.Client.Alerts;
+using Content.Shared.Revenant;
+using Content.Shared.Revenant.Components;
+using Content.Shared.Revenant.Systems;
+
+namespace Content.Client.Revenant.Systems;
+
+public sealed class RevenantSystem : SharedRevenantSystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<RevenantComponent, UpdateAlertSpriteEvent>(OnUpdateAlert);
+    }
+
+    private static void OnUpdateAlert(Entity<RevenantComponent> ent, ref UpdateAlertSpriteEvent args)
+    {
+        if (args.Alert.ID != ent.Comp.EssenceAlert)
+            return;
+
+        var sprite = args.SpriteViewEnt.Comp;
+        var essence = Math.Clamp(ent.Comp.Essence.Int(), 0, 999);
+        sprite.LayerSetState(RevenantVisualLayers.Digit1, $"{essence / 100 % 10}");
+        sprite.LayerSetState(RevenantVisualLayers.Digit2, $"{essence / 10 % 10}");
+        sprite.LayerSetState(RevenantVisualLayers.Digit3, $"{essence % 10}");
+    }
+}

Content.Client/Revenant/Systems/RevenantVisualsSystem.cs

@@ -0,0 +1,31 @@
+using Content.Client.Revenant.Components;
+using Content.Shared.Revenant;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.Revenant.Systems;
+
+public sealed class RevenantVisualsSystem : EntitySystem
+{
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<RevenantVisualsComponent, AppearanceChangeEvent>(OnAppearanceChange);
+    }
+
+    private void OnAppearanceChange(Entity<RevenantVisualsComponent> ent, ref AppearanceChangeEvent args)
+    {
+        if (args.Sprite == null)
+            return;
+
+        if (_appearance.TryGetData<bool>(ent, RevenantVisuals.Harvesting, out var harvesting, args.Component) &&
+            harvesting)
+            args.Sprite.LayerSetState(0, ent.Comp.HarvestingState);
+        else if (_appearance.TryGetData<bool>(ent, RevenantVisuals.Stunned, out var stunned, args.Component) && stunned)
+            args.Sprite.LayerSetState(0, ent.Comp.StunnedState);
+        else if (_appearance.TryGetData<bool>(ent, RevenantVisuals.Corporeal, out var corporeal, args.Component))
+            args.Sprite.LayerSetState(0, corporeal ? ent.Comp.CorporealState : ent.Comp.State);
+    }
+}