The Everlasting Promised Reagent Fire at the End of the Horizon

Content.Client/_Funkystation/Footprints/FootprintSystem.cs

@@ -0,0 +1,46 @@
+using System.Linq;
+using Content.Shared._Funkystation.Footprints;
+using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
+
+namespace Content.Client._Funkystation.Footprints;
+
+public sealed partial class FootprintSystem : EntitySystem
+{
+    [Dependency] private SpriteSystem _sprite = default!;
+
+    [SubscribeLocalEvent]
+    private void OnStartup(Entity<FootprintComponent> entity, ref ComponentStartup args)
+    {
+        UpdateVisuals(entity);
+    }
+
+    [SubscribeLocalEvent]
+    private void OnComponentState(Entity<FootprintComponent> entity, ref AfterAutoHandleStateEvent args)
+    {
+        UpdateVisuals(entity);
+    }
+
+    private void UpdateVisuals(Entity<FootprintComponent> entity)
+    {
+        if (!TryComp<SpriteComponent>(entity, out var spriteComp))
+            return;
+
+        var sprite = new Entity<SpriteComponent>(entity, spriteComp);
+        var spriteNullable = sprite.AsNullable();
+
+        var printsAndLayers = entity.Comp.Prints.Select((print, index) => (
+            print,
+            layer: _sprite.TryGetLayer(spriteNullable, index, out var l, logMissing: false)
+                ? l
+                : _sprite.AddBlankLayer(sprite, index)
+        ));
+        foreach (var (print, layer) in printsAndLayers)
+        {
+            _sprite.LayerSetOffset(layer, print.Offset);
+            _sprite.LayerSetRotation(layer, print.Rotation);
+            _sprite.LayerSetColor(layer, print.Color);
+            _sprite.LayerSetSprite(layer, new SpriteSpecifier.Rsi(entity.Comp.Sprites, print.State));
+        }
+    }
+}

Content.Client/_Funkystation/ReagentFires/Systems/ReagentPuddleFireVisualsSystem.cs

@@ -0,0 +1,134 @@
+using Content.Client._Starfall.Particles;
+using Content.Shared._Funkystation.ReagentFires;
+using Content.Shared._Starfall.Particles;
+using Robust.Client.GameObjects;
+
+namespace Content.Client._Funkystation.ReagentFires.Systems
+{
+    public sealed partial class ReagentPuddleFireVisualsSystem : EntitySystem
+    {
+        [Dependency] private AppearanceSystem _appearance = null!;
+        [Dependency] private ParticleSystem _particles = null!;
+        [Dependency] private SharedTransformSystem _transform = null!;
+
+        private readonly Dictionary<EntityUid, (ActiveEmitter? Fire, ActiveEmitter? Smoke)> _emitters = new();
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<ReagentPuddleFireEffectComponent, ComponentStartup>(OnCompStartup);
+            SubscribeLocalEvent<ReagentPuddleFireEffectComponent, AppearanceChangeEvent>(OnAppearanceChange);
+            SubscribeLocalEvent<ReagentPuddleFireEffectComponent, ComponentShutdown>(OnShutdown);
+        }
+
+        private void OnCompStartup(EntityUid uid, ReagentPuddleFireEffectComponent component, ref ComponentStartup args)
+        {
+            UpdateVisuals(uid, null);
+        }
+
+        private void OnShutdown(EntityUid uid, ReagentPuddleFireEffectComponent component, ref ComponentShutdown args)
+        {
+            if (_emitters.Remove(uid, out var pair))
+            {
+                _particles.RemoveParticle(pair.Fire);
+                _particles.RemoveParticle(pair.Smoke);
+            }
+        }
+
+        private void OnAppearanceChange(EntityUid uid, ReagentPuddleFireEffectComponent component, ref AppearanceChangeEvent args)
+        {
+            UpdateVisuals(uid, args.Sprite);
+        }
+
+        public override void FrameUpdate(float frameTime)
+        {
+            base.FrameUpdate(frameTime);
+
+            foreach (var (uid, pair) in _emitters)
+            {
+                if (Deleted(uid))
+                    continue;
+
+                var coords = _transform.GetMapCoordinates(uid);
+
+                if (pair.Fire is { Exhausted: false })
+                    pair.Fire.MapCoords = coords;
+
+                if (pair.Smoke is { Exhausted: false })
+                    pair.Smoke.MapCoords = coords;
+            }
+        }
+
+        private void UpdateVisuals(EntityUid uid, SpriteComponent? sprite)
+        {
+            if (sprite == null && !TryComp(uid, out sprite))
+                return;
+
+            if (!_emitters.TryGetValue(uid, out var pair))
+            {
+                pair = (null, null);
+            }
+
+            var coords = _transform.GetMapCoordinates(uid);
+            var updated = false;
+
+            if (pair.Fire == null || pair.Fire.Exhausted)
+            {
+                pair.Fire = _particles.SpawnEffect("ReagentFireContinuous", coords, uid);
+                updated = true;
+            }
+
+            if (pair.Smoke == null || pair.Smoke.Exhausted)
+            {
+                pair.Smoke = _particles.SpawnEffect("ReagentFireSmoke", coords, uid);
+                updated = true;
+            }
+
+            if (updated)
+            {
+                _emitters[uid] = pair;
+            }
+
+            if (!_appearance.TryGetData<int>(uid, ReagentPuddleFireVisuals.FireState, out var fireState))
+            {
+                fireState = 4;
+            }
+
+            var stateString = fireState.ToString();
+            sprite.LayerSetState(0, stateString);
+
+            var intensity = 1f;
+            var smokeSize = 0.8f;
+            if (fireState == 5)
+            {
+                intensity = 1.5f;
+                smokeSize = 1.2f;
+            }
+            else if (fireState == 6)
+            {
+                intensity = 2.0f;
+                smokeSize = 1.6f;
+            }
+
+            if (pair.Fire != null)
+                pair.Fire.Intensity = intensity;
+            if (pair.Smoke != null)
+            {
+                pair.Smoke.Intensity = intensity;
+                var smokeOverrides = new ParticleRuntimeOverrides { ParticleSize = smokeSize };
+                ParticleSystem.UpdateRuntime(pair.Smoke, smokeOverrides);
+            }
+
+            // Apply synchronized flame color dynamically to the decoupled sprite and standard particle emitters
+            if (_appearance.TryGetData<Color>(uid, ReagentPuddleFireVisuals.FireColor, out var color))
+            {
+                sprite.Color = color;
+                if (pair.Fire != null)
+                    pair.Fire.ColorOverride = color;
+                // Soften the smoke tint opacity slightly so it acts as a subtle background element
+                if (pair.Smoke != null)
+                    pair.Smoke.ColorOverride = color.WithAlpha(0.25f);
+            }
+        }
+    }
+}

Content.Client/_Funkystation/Stains/StainSystem.cs

@@ -0,0 +1,76 @@
+using Content.Client.Clothing;
+using Content.Client.Items.Systems;
+using Content.Shared._Funkystation.Stains.Components;
+using Content.Shared._Funkystation.Stains.Systems;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Clothing;
+using Content.Shared.FixedPoint;
+using Content.Shared.Hands;
+using Robust.Client.GameObjects;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._Funkystation.Stains;
+
+public sealed partial class StainSystem : SharedStainSystem
+{
+    [Dependency] private IPrototypeManager _prototypeManager = null!;
+    [Dependency] private SharedSolutionContainerSystem _solution = null!;
+    [Dependency] private SpriteSystem _sprite = null!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<StainableComponent, AppearanceChangeEvent>(OnAppearanceChanged);
+        SubscribeLocalEvent<StainableComponent, GetEquipmentVisualsEvent>(OnEquipmentVisuals, after: [typeof(ClientClothingSystem)]);
+        SubscribeLocalEvent<StainableComponent, GetInhandVisualsEvent>(OnInhandVisuals, after: [typeof(ItemSystem)]);
+    }
+
+    private void OnAppearanceChanged(Entity<StainableComponent> ent, ref AppearanceChangeEvent args)
+    {
+        if (args.Sprite == null)
+            return;
+
+        var spriteEnt = new Entity<SpriteComponent?>(ent.Owner, args.Sprite);
+
+        var layers = new List<int>(ent.Comp.RevealedLayers);
+        layers.Sort((a, b) => b.CompareTo(a));
+
+        foreach (var layer in layers)
+        {
+            _sprite.RemoveLayer(spriteEnt, layer);
+        }
+
+        ent.Comp.RevealedLayers.Clear();
+
+        foreach (var (_, layerData) in BuildVisuals(ent, ent.Comp.IconVisuals, "icon"))
+        {
+            ent.Comp.RevealedLayers.Add(_sprite.AddLayer(spriteEnt, layerData, null));
+        }
+    }
+
+    private void OnEquipmentVisuals(Entity<StainableComponent> ent, ref GetEquipmentVisualsEvent args)
+    {
+        if (ent.Comp.ClothingVisuals.TryGetValue(args.Slot, out var layers))
+            args.Layers.AddRange(BuildVisuals(ent, layers, args.Slot));
+    }
+
+    private void OnInhandVisuals(Entity<StainableComponent> ent, ref GetInhandVisualsEvent args)
+    {
+        if (ent.Comp.ItemVisuals.TryGetValue(args.Location.ToString(), out var layers))
+            args.Layers.AddRange(BuildVisuals(ent, layers, args.Location.ToString()));
+    }
+
+    private IEnumerable<(string, PrototypeLayerData)> BuildVisuals(Entity<StainableComponent> ent, List<PrototypeLayerData> templates, string prefix)
+    {
+        if (!_solution.TryGetSolution(ent.Owner, ent.Comp.SolutionName, out _, out var sol) || sol.Volume <= FixedPoint2.Zero)
+            yield break;
+
+        var color = sol.GetColor(_prototypeManager);
+        for (var i = 0; i < templates.Count; i++)
+        {
+            var layer = templates[i];
+            layer.Color = color;
+            yield return ($"stain-{prefix}-{i}", layer);
+        }
+    }
+}

Content.Client/_Funkystation/WallStains/Systems/FlammableWallFireVisualsSystem.cs

@@ -0,0 +1,121 @@
+using Content.Client._Starfall.Particles;
+using Content.Shared._Funkystation.ReagentFires;
+using Content.Shared._Funkystation.WallStains.Components;
+using Robust.Client.GameObjects;
+using Robust.Shared.Map;
+
+namespace Content.Client._Funkystation.WallStains.Systems;
+
+public sealed partial class WallStainFireVisualsSystem : EntitySystem
+{
+    [Dependency] private ParticleSystem _particles = null!;
+    [Dependency] private SharedTransformSystem _transform = null!;
+    [Dependency] private AppearanceSystem _appearance = default!;
+
+    private struct StainEmitters
+    {
+        public ActiveEmitter? Fire;
+        public ActiveEmitter? Embers;
+        public ActiveEmitter? Slag;
+        public ActiveEmitter? Sparks;
+        public ActiveEmitter? Fumes;
+    }
+
+    private readonly Dictionary<EntityUid, StainEmitters> _emitters = new();
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<WallStainFireVisualsComponent, ComponentStartup>(OnCompStartup);
+        SubscribeLocalEvent<WallStainFireVisualsComponent, AppearanceChangeEvent>(OnAppearanceChange);
+        SubscribeLocalEvent<WallStainFireVisualsComponent, ComponentShutdown>(OnShutdown);
+    }
+
+    private void OnCompStartup(EntityUid uid, WallStainFireVisualsComponent component, ref ComponentStartup args)
+    {
+        UpdateVisuals(uid);
+    }
+
+    private void OnShutdown(EntityUid uid, WallStainFireVisualsComponent component, ref ComponentShutdown args)
+    {
+        if (_emitters.Remove(uid, out var pair))
+        {
+            _particles.RemoveParticle(pair.Fire);
+            _particles.RemoveParticle(pair.Embers);
+            _particles.RemoveParticle(pair.Slag);
+            _particles.RemoveParticle(pair.Sparks);
+            _particles.RemoveParticle(pair.Fumes);
+        }
+    }
+
+    private void OnAppearanceChange(EntityUid uid, WallStainFireVisualsComponent component, ref AppearanceChangeEvent args)
+    {
+        UpdateVisuals(uid);
+    }
+
+    public override void FrameUpdate(float frameTime)
+    {
+        base.FrameUpdate(frameTime);
+        foreach (var (uid, pair) in _emitters)
+        {
+            if (Deleted(uid))
+                continue;
+            var coords = _transform.GetMapCoordinates(uid);
+            if (pair.Fire is { Exhausted: false })
+                pair.Fire.MapCoords = coords;
+            if (pair.Embers is { Exhausted: false })
+                pair.Embers.MapCoords = coords;
+            if (pair.Slag is { Exhausted: false })
+                pair.Slag.MapCoords = coords;
+            if (pair.Sparks is { Exhausted: false })
+                pair.Sparks.MapCoords = coords;
+            if (pair.Fumes is { Exhausted: false })
+                pair.Fumes.MapCoords = coords;
+        }
+    }
+
+    private void UpdateEmitter(ref ActiveEmitter? emitter, string effectId, MapCoordinates coords, EntityUid uid, float intensity, Color color)
+    {
+        if (emitter == null || emitter.Exhausted)
+            emitter = _particles.SpawnEffect(effectId, coords, uid);
+
+        if (emitter != null)
+        {
+            emitter.Intensity = intensity;
+            emitter.ColorOverride = color;
+        }
+    }
+
+    private void UpdateVisuals(EntityUid uid)
+    {
+        if (!_emitters.TryGetValue(uid, out var pair))
+            pair = new StainEmitters();
+
+        var coords = _transform.GetMapCoordinates(uid);
+
+        var fireState = 4;
+        if (_appearance.TryGetData<int>(uid, ReagentPuddleFireVisuals.FireState, out var state))
+            fireState = state;
+
+        var color = Color.White;
+        if (_appearance.TryGetData<Color>(uid, ReagentPuddleFireVisuals.FireColor, out var c))
+            color = c;
+
+        if (TryComp<SpriteComponent>(uid, out var sprite))
+        {
+            sprite.LayerSetState(0, fireState.ToString());
+            sprite.Color = color;
+        }
+
+        var baseIntensity = fireState == 6 ? 2.0f : fireState == 5 ? 1.5f : 1.0f;
+        var metalFireIntensity = fireState >= 5 ? baseIntensity : 0f;
+
+        UpdateEmitter(ref pair.Fire, "WallFire", coords, uid, baseIntensity, color);
+        UpdateEmitter(ref pair.Embers, "WallFireEmbers", coords, uid, baseIntensity, color);
+        UpdateEmitter(ref pair.Slag, "WallFireSlag", coords, uid, metalFireIntensity, color);
+        UpdateEmitter(ref pair.Sparks, "WallFireSparks", coords, uid, metalFireIntensity, color);
+        UpdateEmitter(ref pair.Fumes, "WallFireFumes", coords, uid, metalFireIntensity, color.WithAlpha(0.35f));
+
+        _emitters[uid] = pair;
+    }
+}