Create ProcessAtmosTreeSerializer.cs

* Removed Initilization For The Scream Action

* Commetet out code instead of Deleting it outright

* Commetet Out The Code Inititzilazing The Scream Action

* Update Content.Server/Speech/EntitySystems/VocalSystem.cs

* Update Content.Server/Speech/EntitySystems/VocalSystem.cs

---------

Co-authored-by: Red <96445749+TheShuEd@users.noreply.github.com>

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,17 +1,23 @@
 ## About the PR
 <!-- What did you change in this PR? -->
-<!-- Что вы изменили в своем пулл реквесте? -->
 
 ## Why / Balance
 <!-- Why was it changed? Link any discussions or issues here. Please discuss how this would affect game balance. -->
-<!-- Зачем нужно это изменение? Прикрепите любые обсуждения или проблемы здесь. Опишите, как это повлияет на текущий баланс игры. -->
 
 ## Media
 <!--
 PRs which make ingame changes (adding clothing, items, new features, etc) are required to have media attached that showcase the changes.
 Small fixes/refactors are exempt.
 -->
+
+**Changelog**
+<!-- Add a Changelog entry to make players aware of new features or changes that could affect gameplay.
+Make sure to read the guidelines and take this Changelog template out of the comment block in order for it to show up.
+Changelog must have a :cl: symbol, so the bot recognizes the changes and adds them to the game's changelog. -->
 <!--
-Пулл реквесты, которые несут за собой игровые изменения (добавления одежды, предметов и так далее) требуют чтобы вы прикрепили скриншоты или видеоролики, демонстрирующие эти изменения.
-Небольшие исправления не считаются.
+:cl:
+- add: Added fun!
+- remove: Removed fun!
+- tweak: Changed fun!
+- fix: Fixed fun!
 -->

.github/workflows/CP14Publish.yml

@@ -1,4 +1,4 @@
-name: Publish
+name: Edge Publish
 
 concurrency:
   group: publish
@@ -10,6 +10,15 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
+    
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+    
+    - name: Install Python dependencies
+      run: sudo apt-get install -y python3-paramiko python3-lxml
+      
     - name: Send POST-request
       uses: appleboy/ssh-action@master
       with:
@@ -18,3 +27,10 @@ jobs:
         password: ${{ secrets.BUILD_PASS }}
         port: 22
         script: sh update.sh &> /dev/null
+
+    - name: Publish changelog (Discord)
+      continue-on-error: true
+      run: Tools/actions_changelogs_since_last_run.py
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        DISCORD_WEBHOOK_URL: ${{ secrets.CHANGELOG_DISCORD_WEBHOOK }}

.github/workflows/check-trailing-whitespace.yml

@@ -0,0 +1,59 @@
+name: Trailing Whitespace Check
+
+on:
+  pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
+
+jobs:
+  build:
+    name: Trailing Whitespace Check
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4.2.2
+    - name: Get changed text files
+      id: changed-files
+      uses: tj-actions/changed-files@v46.0.5
+      with:
+        files: |
+          **.cs
+          **.yml
+          **.swsl
+          **.json
+          **.py
+    - name: Check for trailing whitespace and EOF newline
+      env:
+        ALL_CHANGED_FILES: ${{ steps.changed-files.outputs.all_changed_files }}
+      run: |
+        has_trailing_whitespace=0
+        has_missing_eof_newline=0
+
+        for file in ${ALL_CHANGED_FILES}; do
+          # Ignore vanilla not CrystallEdge files
+          if [[ "$file" != *CP14* ]]; then
+              continue
+            fi
+          
+          echo "Checking $file"
+
+          # Check for trailing whitespace
+          if grep -qP '[ \t]+$' "$file"; then
+            echo "::error file=$file::Trailing whitespace found"
+            has_trailing_whitespace=1
+          fi
+
+          # Check for missing EOF newline
+          if [ -f "$file" ] && [ -s "$file" ]; then
+            last_char=$(tail -c 1 "$file")
+            if [ "$last_char" != "" ] && [ "$last_char" != $'\n' ]; then
+              echo "::error file=$file::Missing newline at end of file"
+              has_missing_eof_newline=1
+            fi
+          fi
+        done
+
+        if [ "$has_trailing_whitespace" -eq 1 ] || [ "$has_missing_eof_newline" -eq 1 ]; then
+          echo "Issues found: trailing whitespace or missing EOF newline."
+          echo "We recommend using an IDE to prevent this from happening."
+          exit 1
+        fi

.github/workflows/publish-testing.yml

@@ -2,6 +2,7 @@
 
 concurrency:
   group: publish-testing
+  cancel-in-progress: true
 
 on:
   workflow_dispatch:

.github/workflows/publish.yml

@@ -2,6 +2,7 @@ name: Publish
 
 concurrency:
   group: publish
+  cancel-in-progress: true
 
 on:
   workflow_dispatch:
@@ -48,12 +49,14 @@ jobs:
         GITHUB_REPOSITORY: ${{ vars.GITHUB_REPOSITORY }}
 
     - name: Publish changelog (Discord)
+      continue-on-error: true
       run: Tools/actions_changelogs_since_last_run.py
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         DISCORD_WEBHOOK_URL: ${{ secrets.CHANGELOG_DISCORD_WEBHOOK }}
 
     - name: Publish changelog (RSS)
+      continue-on-error: true
       run: Tools/actions_changelog_rss.py
       env:
         CHANGELOG_RSS_KEY: ${{ secrets.CHANGELOG_RSS_KEY }}

BuildChecker/git_helper.py

@@ -5,6 +5,7 @@ import subprocess
 import sys
 import os
 import shutil
+import time
 from pathlib import Path
 from typing import List
 
@@ -104,7 +105,21 @@ def reset_solution():
     with SOLUTION_PATH.open("w") as f:
         f.write(content)
 
+def check_for_zip_download():
+    # Check if .git exists,
+    cur_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    if not os.path.isdir(os.path.join(cur_dir, ".git")):
+        print("It appears that you downloaded this repository directly from GitHub. (Using the .zip download option) \n"
+              "When downloading straight from GitHub, it leaves out important information that git needs to function. "
+              "Such as information to download the engine or even the ability to even be able to create contributions. \n"
+              "Please read and follow https://docs.spacestation14.com/en/general-development/setup/setting-up-a-development-environment.html \n"
+              "If you just want a Sandbox Server, you are following the wrong guide! You can download a premade server following the instructions here:"
+              "https://docs.spacestation14.com/en/general-development/setup/server-hosting-tutorial.html \n"
+              "Closing automatically in 30 seconds.")
+        time.sleep(30)
+        exit(1)
 
 if __name__ == '__main__':
+    check_for_zip_download()
     install_hooks()
     update_submodules()

Content.Benchmarks/ComponentQueryBenchmark.cs

@@ -29,7 +29,7 @@ namespace Content.Benchmarks;
 [CategoriesColumn]
 public class ComponentQueryBenchmark
 {
-    public const string Map = "Maps/atlas.yml";
+    public const string Map = "Maps/saltern.yml";
 
     private TestPair _pair = default!;
     private IEntityManager _entMan = default!;

Content.Benchmarks/Program.cs

@@ -1,15 +1,7 @@
 using System;
-using System.Linq;
-using System.Threading.Tasks;
 using BenchmarkDotNet.Running;
-using Content.IntegrationTests;
-using Content.Server.Maps;
-#if DEBUG
 using BenchmarkDotNet.Configs;
-#else
 using Robust.Benchmarks.Configs;
-#endif
-using Robust.Shared.Prototypes;
 
 namespace Content.Benchmarks
 {
@@ -22,11 +14,15 @@ namespace Content.Benchmarks
             Console.ForegroundColor = ConsoleColor.Red;
             Console.WriteLine("\nWARNING: YOU ARE RUNNING A DEBUG BUILD, USE A RELEASE BUILD FOR AN ACCURATE BENCHMARK");
             Console.WriteLine("THE DEBUG BUILD IS ONLY GOOD FOR FIXING A CRASHING BENCHMARK\n");
-            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, new DebugInProcessConfig());
+            var baseConfig = new DebugInProcessConfig();
 #else
-            var config = Environment.GetEnvironmentVariable("ROBUST_BENCHMARKS_ENABLE_SQL") != null ? DefaultSQLConfig.Instance : null;
-            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
+            var baseConfig = Environment.GetEnvironmentVariable("ROBUST_BENCHMARKS_ENABLE_SQL") != null
+                ? DefaultSQLConfig.Instance
+                : DefaultConfig.Instance;
 #endif
+            var config = ManualConfig.Create(baseConfig);
+            config.BuildTimeout = TimeSpan.FromMinutes(5);
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
         }
     }
 }

Content.Benchmarks/RaiseEventBenchmark.cs

@@ -0,0 +1,126 @@
+#nullable enable
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Content.IntegrationTests;
+using Content.IntegrationTests.Pair;
+using Robust.Shared;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+
+namespace Content.Benchmarks;
+
+[Virtual]
+public class RaiseEventBenchmark
+{
+    private TestPair _pair = default!;
+    private BenchSystem _sys = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        ProgramShared.PathOffset = "../../../../";
+        PoolManager.Startup(typeof(BenchSystem).Assembly);
+        _pair = PoolManager.GetServerClient().GetAwaiter().GetResult();
+        var entMan = _pair.Server.EntMan;
+        _sys = entMan.System<BenchSystem>();
+
+        _pair.Server.WaitPost(() =>
+        {
+            var uid = entMan.Spawn();
+            _sys.Ent = new(uid, entMan.GetComponent<TransformComponent>(uid));
+            _sys.Ent2 = new(_sys.Ent.Owner, _sys.Ent.Comp);
+        })
+            .GetAwaiter()
+            .GetResult();
+    }
+
+    [GlobalCleanup]
+    public async Task Cleanup()
+    {
+        await _pair.DisposeAsync();
+        PoolManager.Shutdown();
+    }
+
+    [Benchmark(Baseline = true)]
+    public int RaiseEvent()
+    {
+        return _sys.RaiseEvent();
+    }
+
+    [Benchmark]
+    public int RaiseCompEvent()
+    {
+        return _sys.RaiseCompEvent();
+    }
+
+    [Benchmark]
+    public int RaiseICompEvent()
+    {
+        return _sys.RaiseICompEvent();
+    }
+
+    [Benchmark]
+    public int RaiseCSharpEvent()
+    {
+        return _sys.CSharpEvent();
+    }
+
+    public sealed class BenchSystem : EntitySystem
+    {
+        public Entity<TransformComponent> Ent;
+        public Entity<IComponent> Ent2;
+
+        public delegate void EntityEventHandler(EntityUid uid, TransformComponent comp, ref BenchEv ev);
+
+        public event EntityEventHandler? OnCSharpEvent;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<TransformComponent, BenchEv>(OnEvent);
+            OnCSharpEvent += OnEvent;
+        }
+
+        public int RaiseEvent()
+        {
+            var ev = new BenchEv();
+            RaiseLocalEvent(Ent.Owner, ref ev);
+            return ev.N;
+        }
+
+        public int RaiseCompEvent()
+        {
+            var ev = new BenchEv();
+            EntityManager.EventBus.RaiseComponentEvent(Ent.Owner, Ent.Comp, ref ev);
+            return ev.N;
+        }
+
+        public int RaiseICompEvent()
+        {
+            // Raise with an IComponent instead of concrete type
+            var ev = new BenchEv();
+            EntityManager.EventBus.RaiseComponentEvent(Ent2.Owner, Ent2.Comp, ref ev);
+            return ev.N;
+        }
+
+        public int CSharpEvent()
+        {
+            var ev = new BenchEv();
+            OnCSharpEvent?.Invoke(Ent.Owner, Ent.Comp, ref ev);
+            return ev.N;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void OnEvent(EntityUid uid, TransformComponent component, ref BenchEv args)
+        {
+            args.N += uid.Id;
+        }
+
+        [ByRefEvent]
+        public struct BenchEv
+        {
+            public int N;
+        }
+    }
+}

Content.Client/Access/UI/IdCardConsoleBoundUserInterface.cs

@@ -1,8 +1,10 @@
 using Content.Shared.Access;
 using Content.Shared.Access.Components;
 using Content.Shared.Access.Systems;
+using Content.Shared.CCVar;
 using Content.Shared.Containers.ItemSlots;
 using Content.Shared.CrewManifest;
+using Robust.Shared.Configuration;
 using Robust.Shared.Prototypes;
 using static Content.Shared.Access.Components.IdCardConsoleComponent;
 
@@ -11,13 +13,21 @@ namespace Content.Client.Access.UI
     public sealed class IdCardConsoleBoundUserInterface : BoundUserInterface
     {
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly IConfigurationManager _cfgManager = default!;
         private readonly SharedIdCardConsoleSystem _idCardConsoleSystem = default!;
 
         private IdCardConsoleWindow? _window;
 
+        // CCVar.
+        private int _maxNameLength;
+        private int _maxIdJobLength;
+
         public IdCardConsoleBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
         {
             _idCardConsoleSystem = EntMan.System<SharedIdCardConsoleSystem>();
+
+            _maxNameLength =_cfgManager.GetCVar(CCVars.MaxNameLength);
+            _maxIdJobLength = _cfgManager.GetCVar(CCVars.MaxIdJobLength);
         }
 
         protected override void Open()
@@ -66,11 +76,11 @@ namespace Content.Client.Access.UI
 
         public void SubmitData(string newFullName, string newJobTitle, List<ProtoId<AccessLevelPrototype>> newAccessList, string newJobPrototype)
         {
-            if (newFullName.Length > MaxFullNameLength)
-                newFullName = newFullName[..MaxFullNameLength];
+            if (newFullName.Length > _maxNameLength)
+                newFullName = newFullName[.._maxNameLength];
 
-            if (newJobTitle.Length > MaxJobTitleLength)
-                newJobTitle = newJobTitle[..MaxJobTitleLength];
+            if (newJobTitle.Length > _maxIdJobLength)
+                newJobTitle = newJobTitle[.._maxIdJobLength];
 
             SendMessage(new WriteToTargetIdMessage(
                 newFullName,

Content.Client/Access/UI/IdCardConsoleWindow.xaml.cs

@@ -1,11 +1,13 @@
 using System.Linq;
 using Content.Shared.Access;
 using Content.Shared.Access.Systems;
+using Content.Shared.CCVar;
 using Content.Shared.Roles;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Configuration;
 using Robust.Shared.Prototypes;
 using static Content.Shared.Access.Components.IdCardConsoleComponent;
 
@@ -14,12 +16,17 @@ namespace Content.Client.Access.UI
     [GenerateTypedNameReferences]
     public sealed partial class IdCardConsoleWindow : DefaultWindow
     {
+        [Dependency] private readonly IConfigurationManager _cfgManager = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
         private readonly ISawmill _logMill = default!;
 
         private readonly IdCardConsoleBoundUserInterface _owner;
 
+        // CCVar.
+        private int _maxNameLength;
+        private int _maxIdJobLength;
+
         private AccessLevelControl _accessButtons = new();
         private readonly List<string> _jobPrototypeIds = new();
 
@@ -39,7 +46,11 @@ namespace Content.Client.Access.UI
 
             _owner = owner;
 
+            _maxNameLength = _cfgManager.GetCVar(CCVars.MaxNameLength);
+            _maxIdJobLength = _cfgManager.GetCVar(CCVars.MaxIdJobLength);
+
             FullNameLineEdit.OnTextEntered += _ => SubmitData();
+            FullNameLineEdit.IsValid = s => s.Length <= _maxNameLength;
             FullNameLineEdit.OnTextChanged += _ =>
             {
                 FullNameSaveButton.Disabled = FullNameSaveButton.Text == _lastFullName;
@@ -47,6 +58,7 @@ namespace Content.Client.Access.UI
             FullNameSaveButton.OnPressed += _ => SubmitData();
 
             JobTitleLineEdit.OnTextEntered += _ => SubmitData();
+            JobTitleLineEdit.IsValid = s => s.Length <= _maxIdJobLength;
             JobTitleLineEdit.OnTextChanged += _ =>
             {
                 JobTitleSaveButton.Disabled = JobTitleLineEdit.Text == _lastJobTitle;

Content.Client/Actions/ActionsSystem.cs

@@ -202,6 +202,7 @@ namespace Content.Client.Actions
                 return;
 
             OnActionAdded?.Invoke(actionId);
+            ActionsUpdated?.Invoke();
         }
 
         protected override void ActionRemoved(EntityUid performer, EntityUid actionId, ActionsComponent comp, BaseActionComponent action)
@@ -210,6 +211,7 @@ namespace Content.Client.Actions
                 return;
 
             OnActionRemoved?.Invoke(actionId);
+            ActionsUpdated?.Invoke();
         }
 
         public IEnumerable<(EntityUid Id, BaseActionComponent Comp)> GetClientActions()

Content.Client/Administration/Systems/KillSignSystem.cs

@@ -7,6 +7,8 @@ namespace Content.Client.Administration.Systems;
 
 public sealed class KillSignSystem : EntitySystem
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Initialize()
     {
         SubscribeLocalEvent<KillSignComponent, ComponentStartup>(KillSignAdded);
@@ -18,10 +20,10 @@ public sealed class KillSignSystem : EntitySystem
         if (!TryComp<SpriteComponent>(uid, out var sprite))
             return;
 
-        if (!sprite.LayerMapTryGet(KillSignKey.Key, out var layer))
+        if (!_sprite.LayerMapTryGet((uid, sprite), KillSignKey.Key, out var layer, false))
             return;
 
-        sprite.RemoveLayer(layer);
+        _sprite.RemoveLayer((uid, sprite), layer);
     }
 
     private void KillSignAdded(EntityUid uid, KillSignComponent component, ComponentStartup args)
@@ -29,15 +31,15 @@ public sealed class KillSignSystem : EntitySystem
         if (!TryComp<SpriteComponent>(uid, out var sprite))
             return;
 
-        if (sprite.LayerMapTryGet(KillSignKey.Key, out var _))
+        if (_sprite.LayerMapTryGet((uid, sprite), KillSignKey.Key, out var _, false))
             return;
 
-        var adj = sprite.Bounds.Height / 2 + ((1.0f/32) * 6.0f);
+        var adj = _sprite.GetLocalBounds((uid, sprite)).Height / 2 + ((1.0f / 32) * 6.0f);
 
-        var layer = sprite.AddLayer(new SpriteSpecifier.Rsi(new ResPath("Objects/Misc/killsign.rsi"), "sign"));
-        sprite.LayerMapSet(KillSignKey.Key, layer);
+        var layer = _sprite.AddLayer((uid, sprite), new SpriteSpecifier.Rsi(new ResPath("Objects/Misc/killsign.rsi"), "sign"));
+        _sprite.LayerMapSet((uid, sprite), KillSignKey.Key, layer);
 
-        sprite.LayerSetOffset(layer, new Vector2(0.0f, adj));
+        _sprite.LayerSetOffset((uid, sprite), layer, new Vector2(0.0f, adj));
         sprite.LayerSetShader(layer, "unshaded");
     }
 

Content.Client/Administration/UI/SpawnExplosion/SpawnExplosionWindow.xaml.cs

@@ -19,10 +19,10 @@ namespace Content.Client.Administration.UI.SpawnExplosion;
 public sealed partial class SpawnExplosionWindow : DefaultWindow
 {
     [Dependency] private readonly IClientConsoleHost _conHost = default!;
-    [Dependency] private readonly IMapManager _mapManager = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly IEntityManager _entMan = default!;
+    private readonly SharedMapSystem _mapSystem;
     private readonly SharedTransformSystem _transform = default!;
 
     private readonly SpawnExplosionEui _eui;
@@ -38,6 +38,7 @@ public sealed partial class SpawnExplosionWindow : DefaultWindow
     {
         RobustXamlLoader.Load(this);
         IoCManager.InjectDependencies(this);
+        _mapSystem = _entMan.System<SharedMapSystem>();
         _transform = _entMan.System<TransformSystem>();
         _eui = eui;
 
@@ -87,7 +88,7 @@ public sealed partial class SpawnExplosionWindow : DefaultWindow
     {
         _mapData.Clear();
         MapOptions.Clear();
-        foreach (var map in _mapManager.GetAllMapIds())
+        foreach (var map in _mapSystem.GetAllMapIds())
         {
             _mapData.Add(map);
             MapOptions.AddItem(map.ToString());

Content.Client/Administration/UI/Tabs/AdminbusTab/LoadBlueprintsWindow.xaml.cs

@@ -14,6 +14,9 @@ namespace Content.Client.Administration.UI.Tabs.AdminbusTab
     [UsedImplicitly]
     public sealed partial class LoadBlueprintsWindow : DefaultWindow
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+
         public LoadBlueprintsWindow()
         {
             RobustXamlLoader.Load(this);
@@ -21,9 +24,9 @@ namespace Content.Client.Administration.UI.Tabs.AdminbusTab
 
         protected override void EnteredTree()
         {
-            var mapManager = IoCManager.Resolve<IMapManager>();
+            var mapSystem = _entityManager.System<SharedMapSystem>();
 
-            foreach (var mapId in mapManager.GetAllMapIds())
+            foreach (var mapId in mapSystem.GetAllMapIds())
             {
                 MapOptions.AddItem(mapId.ToString(), (int) mapId);
             }
@@ -39,21 +42,19 @@ namespace Content.Client.Administration.UI.Tabs.AdminbusTab
 
         private void Reset()
         {
-            var entManager = IoCManager.Resolve<IEntityManager>();
-            var xformSystem = entManager.System<SharedTransformSystem>();
-            var playerManager = IoCManager.Resolve<IPlayerManager>();
-            var player = playerManager.LocalEntity;
+            var xformSystem = _entityManager.System<SharedTransformSystem>();
+            var player = _playerManager.LocalEntity;
 
             var currentMap = MapId.Nullspace;
             var position = Vector2.Zero;
             var rotation = Angle.Zero;
 
-            if (entManager.TryGetComponent<TransformComponent>(player, out var xform))
+            if (_entityManager.TryGetComponent<TransformComponent>(player, out var xform))
             {
                 currentMap = xform.MapID;
                 position = xformSystem.GetWorldPosition(xform);
 
-                if (entManager.TryGetComponent<TransformComponent>(xform.GridUid, out var gridXform))
+                if (_entityManager.TryGetComponent<TransformComponent>(xform.GridUid, out var gridXform))
                 {
                     rotation = xformSystem.GetWorldRotation(gridXform);
                 }

Content.Client/AlertLevel/AlertLevelDisplaySystem.cs

@@ -8,6 +8,8 @@ namespace Content.Client.AlertLevel;
 
 public sealed class AlertLevelDisplaySystem : EntitySystem
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -21,26 +23,26 @@ public sealed class AlertLevelDisplaySystem : EntitySystem
         {
             return;
         }
-        var layer = args.Sprite.LayerMapReserveBlank(AlertLevelDisplay.Layer);
+        var layer = _sprite.LayerMapReserve((uid, args.Sprite), AlertLevelDisplay.Layer);
 
         if (args.AppearanceData.TryGetValue(AlertLevelDisplay.Powered, out var poweredObject))
         {
-            args.Sprite.LayerSetVisible(layer, poweredObject is true);
+            _sprite.LayerSetVisible((uid, args.Sprite), layer, poweredObject is true);
         }
 
         if (!args.AppearanceData.TryGetValue(AlertLevelDisplay.CurrentLevel, out var level))
         {
-            args.Sprite.LayerSetState(layer, alertLevelDisplay.AlertVisuals.Values.First());
+            _sprite.LayerSetRsiState((uid, args.Sprite), layer, alertLevelDisplay.AlertVisuals.Values.First());
             return;
         }
 
-        if (alertLevelDisplay.AlertVisuals.TryGetValue((string) level, out var visual))
+        if (alertLevelDisplay.AlertVisuals.TryGetValue((string)level, out var visual))
         {
-            args.Sprite.LayerSetState(layer, visual);
+            _sprite.LayerSetRsiState((uid, args.Sprite), layer, visual);
         }
         else
         {
-            args.Sprite.LayerSetState(layer, alertLevelDisplay.AlertVisuals.Values.First());
+            _sprite.LayerSetRsiState((uid, args.Sprite), layer, alertLevelDisplay.AlertVisuals.Values.First());
         }
     }
 }

Content.Client/Alerts/ClientAlertsSystem.cs

@@ -2,6 +2,7 @@ using System.Linq;
 using Content.Shared.Alert;
 using JetBrains.Annotations;
 using Robust.Client.Player;
+using Robust.Client.UserInterface;
 using Robust.Shared.GameStates;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
@@ -15,6 +16,7 @@ public sealed class ClientAlertsSystem : AlertsSystem
 
     [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IUserInterfaceManager _ui = default!;
 
     public event EventHandler? ClearAlerts;
     public event EventHandler<IReadOnlyDictionary<AlertKey, AlertState>>? SyncAlerts;
@@ -27,6 +29,12 @@ public sealed class ClientAlertsSystem : AlertsSystem
         SubscribeLocalEvent<AlertsComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
         SubscribeLocalEvent<AlertsComponent, ComponentHandleState>(OnHandleState);
     }
+
+    protected override void HandledAlert()
+    {
+        _ui.ClickSound();
+    }
+
     protected override void LoadPrototypes()
     {
         base.LoadPrototypes();
@@ -52,8 +60,24 @@ public sealed class ClientAlertsSystem : AlertsSystem
         if (args.Current is not AlertComponentState cast)
             return;
 
+        // Save all client-sided alerts to later put back in
+        var clientAlerts = new Dictionary<AlertKey, AlertState>();
+        foreach (var alert in alerts.Comp.Alerts)
+        {
+            if (alert.Key.AlertType != null && TryGet(alert.Key.AlertType.Value, out var alertProto))
+            {
+                if (alertProto.ClientHandled)
+                    clientAlerts[alert.Key] = alert.Value;
+            }
+        }
+
         alerts.Comp.Alerts = new(cast.Alerts);
 
+        foreach (var alert in clientAlerts)
+        {
+            alerts.Comp.Alerts[alert.Key] = alert.Value;
+        }
+
         UpdateHud(alerts);
     }
 

Content.Client/Animations/EntityPickupAnimationSystem.cs

@@ -15,6 +15,7 @@ public sealed class EntityPickupAnimationSystem : EntitySystem
 {
     [Dependency] private readonly AnimationPlayerSystem _animations = default!;
     [Dependency] private readonly MetaDataSystem _metaData = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
     [Dependency] private readonly TransformSystem _transform = default!;
 
     public override void Initialize()
@@ -56,8 +57,8 @@ public sealed class EntityPickupAnimationSystem : EntitySystem
         }
 
         var sprite = Comp<SpriteComponent>(animatableClone);
-        sprite.CopyFrom(sprite0);
-        sprite.Visible = true;
+        _sprite.CopySprite((uid, sprite0), (animatableClone, sprite));
+        _sprite.SetVisible((animatableClone, sprite), true);
 
         var animations = Comp<AnimationPlayerComponent>(animatableClone);
 

Content.Client/Anomaly/AnomalySystem.cs

@@ -11,6 +11,7 @@ public sealed class AnomalySystem : SharedAnomalySystem
 {
     [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly FloatingVisualizerSystem _floating = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     /// <inheritdoc/>
     public override void Initialize()
@@ -49,12 +50,12 @@ public sealed class AnomalySystem : SharedAnomalySystem
         if (HasComp<AnomalySupercriticalComponent>(uid))
             pulsing = true;
 
-        if (!sprite.LayerMapTryGet(AnomalyVisualLayers.Base, out var layer) ||
-            !sprite.LayerMapTryGet(AnomalyVisualLayers.Animated, out var animatedLayer))
+        if (!_sprite.LayerMapTryGet((uid, sprite), AnomalyVisualLayers.Base, out var layer, false) ||
+            !_sprite.LayerMapTryGet((uid, sprite), AnomalyVisualLayers.Animated, out var animatedLayer, false))
             return;
 
-        sprite.LayerSetVisible(layer, !pulsing);
-        sprite.LayerSetVisible(animatedLayer, pulsing);
+        _sprite.LayerSetVisible((uid, sprite), layer, !pulsing);
+        _sprite.LayerSetVisible((uid, sprite), animatedLayer, pulsing);
     }
 
     public override void Update(float frameTime)
@@ -63,16 +64,16 @@ public sealed class AnomalySystem : SharedAnomalySystem
 
         var query = EntityQueryEnumerator<AnomalySupercriticalComponent, SpriteComponent>();
 
-        while (query.MoveNext(out var super, out var sprite))
+        while (query.MoveNext(out var uid, out var super, out var sprite))
         {
-            var completion = 1f - (float) ((super.EndTime - _timing.CurTime) / super.SupercriticalDuration);
+            var completion = 1f - (float)((super.EndTime - _timing.CurTime) / super.SupercriticalDuration);
             var scale = completion * (super.MaxScaleAmount - 1f) + 1f;
-            sprite.Scale = new Vector2(scale, scale);
+            _sprite.SetScale((uid, sprite), new Vector2(scale, scale));
 
-            var transparency = (byte) (65 * (1f - completion) + 190);
+            var transparency = (byte)(65 * (1f - completion) + 190);
             if (transparency < sprite.Color.AByte)
             {
-                sprite.Color = sprite.Color.WithAlpha(transparency);
+                _sprite.SetColor((uid, sprite), sprite.Color.WithAlpha(transparency));
             }
         }
     }
@@ -82,7 +83,7 @@ public sealed class AnomalySystem : SharedAnomalySystem
         if (!TryComp<SpriteComponent>(ent, out var sprite))
             return;
 
-        sprite.Scale = Vector2.One;
-        sprite.Color = sprite.Color.WithAlpha(1f);
+        _sprite.SetScale((ent.Owner, sprite), Vector2.One);
+        _sprite.SetColor((ent.Owner, sprite), sprite.Color.WithAlpha(1f));
     }
 }

Content.Client/Anomaly/Effects/ClientInnerBodySystem.cs

@@ -7,6 +7,8 @@ namespace Content.Client.Anomaly.Effects;
 
 public sealed class ClientInnerBodyAnomalySystem : SharedInnerBodyAnomalySystem
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Initialize()
     {
         SubscribeLocalEvent<InnerBodyAnomalyComponent, AfterAutoHandleStateEvent>(OnAfterHandleState);
@@ -21,21 +23,20 @@ public sealed class ClientInnerBodyAnomalySystem : SharedInnerBodyAnomalySystem
         if (ent.Comp.FallbackSprite is null)
             return;
 
-        if (!sprite.LayerMapTryGet(ent.Comp.LayerMap, out var index))
-            index = sprite.LayerMapReserveBlank(ent.Comp.LayerMap);
+        var index = _sprite.LayerMapReserve((ent.Owner, sprite), ent.Comp.LayerMap);
 
         if (TryComp<BodyComponent>(ent, out var body) &&
             body.Prototype is not null &&
             ent.Comp.SpeciesSprites.TryGetValue(body.Prototype.Value, out var speciesSprite))
         {
-            sprite.LayerSetSprite(index, speciesSprite);
+            _sprite.LayerSetSprite((ent.Owner, sprite), index, speciesSprite);
         }
         else
         {
-            sprite.LayerSetSprite(index, ent.Comp.FallbackSprite);
+            _sprite.LayerSetSprite((ent.Owner, sprite), index, ent.Comp.FallbackSprite);
         }
 
-        sprite.LayerSetVisible(index, true);
+        _sprite.LayerSetVisible((ent.Owner, sprite), index, true);
         sprite.LayerSetShader(index, "unshaded");
     }
 
@@ -44,7 +45,7 @@ public sealed class ClientInnerBodyAnomalySystem : SharedInnerBodyAnomalySystem
         if (!TryComp<SpriteComponent>(ent, out var sprite))
             return;
 
-        var index = sprite.LayerMapGet(ent.Comp.LayerMap);
-        sprite.LayerSetVisible(index, false);
+        var index = _sprite.LayerMapGet((ent.Owner, sprite), ent.Comp.LayerMap);
+        _sprite.LayerSetVisible((ent.Owner, sprite), index, false);
     }
 }

Content.Client/Atmos/EntitySystems/AtmosPipeAppearanceSystem.cs

@@ -11,6 +11,7 @@ namespace Content.Client.Atmos.EntitySystems;
 public sealed class AtmosPipeAppearanceSystem : EntitySystem
 {
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -25,21 +26,22 @@ public sealed class AtmosPipeAppearanceSystem : EntitySystem
         if (!TryComp(uid, out SpriteComponent? sprite))
             return;
 
-        foreach (PipeConnectionLayer layerKey in Enum.GetValues(typeof(PipeConnectionLayer)))
+        foreach (var layerKey in Enum.GetValues<PipeConnectionLayer>())
         {
-            sprite.LayerMapReserveBlank(layerKey);
-            var layer = sprite.LayerMapGet(layerKey);
-            sprite.LayerSetRSI(layer, component.Sprite.RsiPath);
-            sprite.LayerSetState(layer, component.Sprite.RsiState);
-            sprite.LayerSetDirOffset(layer, ToOffset(layerKey));
+            var layer = _sprite.LayerMapReserve((uid, sprite), layerKey);
+            _sprite.LayerSetRsi((uid, sprite), layer, component.Sprite.RsiPath);
+            _sprite.LayerSetRsiState((uid, sprite), layer, component.Sprite.RsiState);
+            _sprite.LayerSetDirOffset((uid, sprite), layer, ToOffset(layerKey));
         }
     }
 
-    private void HideAllPipeConnection(SpriteComponent sprite)
+    private void HideAllPipeConnection(Entity<SpriteComponent> entity)
     {
-        foreach (PipeConnectionLayer layerKey in Enum.GetValues(typeof(PipeConnectionLayer)))
+        var sprite = entity.Comp;
+
+        foreach (var layerKey in Enum.GetValues<PipeConnectionLayer>())
         {
-            if (!sprite.LayerMapTryGet(layerKey, out var key))
+            if (!_sprite.LayerMapTryGet(entity.AsNullable(), layerKey, out var key, false))
                 continue;
 
             var layer = sprite[key];
@@ -61,7 +63,7 @@ public sealed class AtmosPipeAppearanceSystem : EntitySystem
 
         if (!_appearance.TryGetData<PipeDirection>(uid, PipeVisuals.VisualState, out var worldConnectedDirections, args.Component))
         {
-            HideAllPipeConnection(args.Sprite);
+            HideAllPipeConnection((uid, args.Sprite));
             return;
         }
 
@@ -71,13 +73,13 @@ public sealed class AtmosPipeAppearanceSystem : EntitySystem
         // transform connected directions to local-coordinates
         var connectedDirections = worldConnectedDirections.RotatePipeDirection(-Transform(uid).LocalRotation);
 
-        foreach (PipeConnectionLayer layerKey in Enum.GetValues(typeof(PipeConnectionLayer)))
+        foreach (var layerKey in Enum.GetValues<PipeConnectionLayer>())
         {
-            if (!args.Sprite.LayerMapTryGet(layerKey, out var key))
+            if (!_sprite.LayerMapTryGet((uid, args.Sprite), layerKey, out var key, false))
                 continue;
 
             var layer = args.Sprite[key];
-            var dir = (PipeDirection) layerKey;
+            var dir = (PipeDirection)layerKey;
             var visible = connectedDirections.HasDirection(dir);
 
             layer.Visible &= visible;

Content.Client/Atmos/EntitySystems/FireVisualizerSystem.cs

@@ -2,6 +2,7 @@ using Content.Client.Atmos.Components;
 using Content.Shared.Atmos;
 using Robust.Client.GameObjects;
 using Robust.Shared.Map;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Atmos.EntitySystems;
 
@@ -10,6 +11,7 @@ namespace Content.Client.Atmos.EntitySystems;
 /// </summary>
 public sealed class FireVisualizerSystem : VisualizerSystem<FireVisualsComponent>
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
     [Dependency] private readonly PointLightSystem _lights = default!;
 
     public override void Initialize()
@@ -31,9 +33,9 @@ public sealed class FireVisualizerSystem : VisualizerSystem<FireVisualsComponent
         // Need LayerMapTryGet because Init fails if there's no existing sprite / appearancecomp
         // which means in some setups (most frequently no AppearanceComp) the layer never exists.
         if (TryComp<SpriteComponent>(uid, out var sprite) &&
-            sprite.LayerMapTryGet(FireVisualLayers.Fire, out var layer))
+            _sprite.LayerMapTryGet((uid, sprite), FireVisualLayers.Fire, out var layer, false))
         {
-            sprite.RemoveLayer(layer);
+            _sprite.RemoveLayer((uid, sprite), layer);
         }
     }
 
@@ -42,11 +44,11 @@ public sealed class FireVisualizerSystem : VisualizerSystem<FireVisualsComponent
         if (!TryComp<SpriteComponent>(uid, out var sprite) || !TryComp(uid, out AppearanceComponent? appearance))
             return;
 
-        sprite.LayerMapReserveBlank(FireVisualLayers.Fire);
-        sprite.LayerSetVisible(FireVisualLayers.Fire, false);
+        _sprite.LayerMapReserve((uid, sprite), FireVisualLayers.Fire);
+        _sprite.LayerSetVisible((uid, sprite), FireVisualLayers.Fire, false);
         sprite.LayerSetShader(FireVisualLayers.Fire, "unshaded");
         if (component.Sprite != null)
-            sprite.LayerSetRSI(FireVisualLayers.Fire, component.Sprite);
+            _sprite.LayerSetRsi((uid, sprite), FireVisualLayers.Fire, new ResPath(component.Sprite));
 
         UpdateAppearance(uid, component, sprite, appearance);
     }
@@ -59,12 +61,12 @@ public sealed class FireVisualizerSystem : VisualizerSystem<FireVisualsComponent
 
     private void UpdateAppearance(EntityUid uid, FireVisualsComponent component, SpriteComponent sprite, AppearanceComponent appearance)
     {
-        if (!sprite.LayerMapTryGet(FireVisualLayers.Fire, out var index))
+        if (!_sprite.LayerMapTryGet((uid, sprite), FireVisualLayers.Fire, out var index, false))
             return;
 
         AppearanceSystem.TryGetData<bool>(uid, FireVisuals.OnFire, out var onFire, appearance);
         AppearanceSystem.TryGetData<float>(uid, FireVisuals.FireStacks, out var fireStacks, appearance);
-        sprite.LayerSetVisible(index, onFire);
+        _sprite.LayerSetVisible((uid, sprite), index, onFire);
 
         if (!onFire)
         {
@@ -78,9 +80,9 @@ public sealed class FireVisualizerSystem : VisualizerSystem<FireVisualsComponent
         }
 
         if (fireStacks > component.FireStackAlternateState && !string.IsNullOrEmpty(component.AlternateState))
-            sprite.LayerSetState(index, component.AlternateState);
+            _sprite.LayerSetRsiState((uid, sprite), index, component.AlternateState);
         else
-            sprite.LayerSetState(index, component.NormalState);
+            _sprite.LayerSetRsiState((uid, sprite), index, component.NormalState);
 
         component.LightEntity ??= Spawn(null, new EntityCoordinates(uid, default));
         var light = EnsureComp<PointLightComponent>(component.LightEntity.Value);

Content.Client/Atmos/EntitySystems/GasTankSystem.cs

@@ -0,0 +1,29 @@
+using Content.Shared.Atmos.Components;
+using Content.Shared.Atmos.EntitySystems;
+
+namespace Content.Client.Atmos.EntitySystems;
+
+public sealed class GasTankSystem : SharedGasTankSystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<GasTankComponent, AfterAutoHandleStateEvent>(OnGasTankState);
+    }
+
+    private void OnGasTankState(Entity<GasTankComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        if (UI.TryGetOpenUi(ent.Owner, SharedGasTankUiKey.Key, out var bui))
+        {
+            bui.Update<GasTankBoundUserInterfaceState>();
+        }
+    }
+
+    public override void UpdateUserInterface(Entity<GasTankComponent> ent)
+    {
+        if (UI.TryGetOpenUi(ent.Owner, SharedGasTankUiKey.Key, out var bui))
+        {
+            bui.Update<GasTankBoundUserInterfaceState>();
+        }
+    }
+}

Content.Client/Atmos/Monitor/AtmosAlarmableVisualsSystem.cs

@@ -7,9 +7,11 @@ namespace Content.Client.Atmos.Monitor;
 
 public sealed class AtmosAlarmableVisualsSystem : VisualizerSystem<AtmosAlarmableVisualsComponent>
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     protected override void OnAppearanceChange(EntityUid uid, AtmosAlarmableVisualsComponent component, ref AppearanceChangeEvent args)
     {
-        if (args.Sprite == null || !args.Sprite.LayerMapTryGet(component.LayerMap, out var layer))
+        if (args.Sprite == null || !_sprite.LayerMapTryGet((uid, args.Sprite), component.LayerMap, out var layer, false))
             return;
 
         if (!args.AppearanceData.TryGetValue(PowerDeviceVisuals.Powered, out var poweredObject) ||
@@ -22,8 +24,8 @@ public sealed class AtmosAlarmableVisualsSystem : VisualizerSystem<AtmosAlarmabl
         {
             foreach (var visLayer in component.HideOnDepowered)
             {
-                if (args.Sprite.LayerMapTryGet(visLayer, out var powerVisibilityLayer))
-                    args.Sprite.LayerSetVisible(powerVisibilityLayer, powered);
+                if (_sprite.LayerMapTryGet((uid, args.Sprite), visLayer, out var powerVisibilityLayer, false))
+                    _sprite.LayerSetVisible((uid, args.Sprite), powerVisibilityLayer, powered);
             }
         }
 
@@ -31,8 +33,8 @@ public sealed class AtmosAlarmableVisualsSystem : VisualizerSystem<AtmosAlarmabl
         {
             foreach (var (setLayer, powerState) in component.SetOnDepowered)
             {
-                if (args.Sprite.LayerMapTryGet(setLayer, out var setStateLayer))
-                    args.Sprite.LayerSetState(setStateLayer, new RSI.StateId(powerState));
+                if (_sprite.LayerMapTryGet((uid, args.Sprite), setLayer, out var setStateLayer, false))
+                    _sprite.LayerSetRsiState((uid, args.Sprite), setStateLayer, new RSI.StateId(powerState));
             }
         }
 
@@ -41,7 +43,7 @@ public sealed class AtmosAlarmableVisualsSystem : VisualizerSystem<AtmosAlarmabl
             && powered
             && component.AlarmStates.TryGetValue(alarmType, out var state))
         {
-            args.Sprite.LayerSetState(layer, new RSI.StateId(state));
+            _sprite.LayerSetRsiState((uid, args.Sprite), layer, new RSI.StateId(state));
         }
     }
 }

Content.Client/Atmos/Monitor/UI/AirAlarmWindow.xaml

@@ -74,7 +74,13 @@
         <!-- Mode buttons -->
         <BoxContainer Orientation="Horizontal">
             <Label Text="{Loc 'air-alarm-ui-window-mode-label'}" Margin="0 0 2 0" />
-            <OptionButton Name="CModeButton" HorizontalExpand="True" />
+            <Control HorizontalExpand="True">
+                <OptionButton Name="CModeButton" />
+                <ui:StripeBack Name="CModeSelectLocked">
+                    <RichTextLabel Text="{Loc 'air-alarm-ui-window-mode-select-locked-label'}"
+                                   HorizontalAlignment="Center" />
+                </ui:StripeBack>
+            </Control>
             <CheckBox Name="AutoModeCheckBox" Text="{Loc 'air-alarm-ui-window-auto-mode-label'}" />
         </BoxContainer>
     </BoxContainer>

Content.Client/Atmos/Monitor/UI/AirAlarmWindow.xaml.cs

@@ -110,6 +110,8 @@ public sealed partial class AirAlarmWindow : FancyWindow
         {
             UpdateDeviceData(addr, dev);
         }
+        _modes.Visible = !state.PanicWireCut;
+        CModeSelectLocked.Visible = state.PanicWireCut;
     }
 
     public void UpdateModeSelector(AirAlarmMode mode)

Content.Client/Atmos/Monitor/UI/Widgets/ScrubberControl.xaml.cs

@@ -71,6 +71,7 @@ public sealed partial class ScrubberControl : BoxContainer
             _data.PumpDirection = (ScrubberPumpDirection) args.Id;
             ScrubberDataChanged?.Invoke(_address, _data);
         };
+        _pumpDirection.Disabled = data.AirAlarmPanicWireCut;
 
         _copySettings.OnPressed += _ =>
         {
@@ -109,6 +110,7 @@ public sealed partial class ScrubberControl : BoxContainer
 
         _data.PumpDirection = data.PumpDirection;
         _pumpDirection.Select((int) _data.PumpDirection);
+        _pumpDirection.Disabled = data.AirAlarmPanicWireCut;
 
         _data.VolumeRate = data.VolumeRate;
         _volumeRate.Value = _data.VolumeRate;

Content.Client/Atmos/Overlays/GasTileOverlay.cs

@@ -21,6 +21,7 @@ namespace Content.Client.Atmos.Overlays
     {
         private readonly IEntityManager _entManager;
         private readonly IMapManager _mapManager;
+        private readonly SharedMapSystem _mapSystem;
         private readonly SharedTransformSystem _xformSys;
 
         public override OverlaySpace Space => OverlaySpace.WorldSpaceEntities | OverlaySpace.WorldSpaceBelowWorld;
@@ -51,6 +52,7 @@ namespace Content.Client.Atmos.Overlays
         {
             _entManager = entManager;
             _mapManager = IoCManager.Resolve<IMapManager>();
+            _mapSystem = entManager.System<SharedMapSystem>();
             _xformSys = xformSys;
             _shader = protoMan.Index<ShaderPrototype>("unshaded").Instance();
             ZIndex = GasOverlayZIndex;
@@ -163,7 +165,7 @@ namespace Content.Client.Atmos.Overlays
                 xformQuery,
                 _xformSys);
 
-            var mapUid = _mapManager.GetMapEntityId(args.MapId);
+            var mapUid = _mapSystem.GetMapOrInvalid(args.MapId);
 
             if (_entManager.TryGetComponent<MapAtmosphereComponent>(mapUid, out var atmos))
                 DrawMapOverlay(drawHandle, args, mapUid, atmos);

Content.Client/Atmos/Piping/Binary/Systems/GasValveSystem.cs

@@ -0,0 +1,8 @@
+using Content.Shared.Atmos.Piping.Binary.Systems;
+
+namespace Content.Client.Atmos.Piping.Binary.Systems;
+
+public sealed class GasValveSystem : SharedGasValveSystem
+{
+
+}

Content.Client/Atmos/Piping/Unary/Systems/GasCanisterSystem.cs

@@ -0,0 +1,32 @@
+using Content.Client.Atmos.UI;
+using Content.Shared.Atmos.Piping.Binary.Components;
+using Content.Shared.Atmos.Piping.Unary.Components;
+using Content.Shared.Atmos.Piping.Unary.Systems;
+using Content.Shared.NodeContainer;
+
+namespace Content.Client.Atmos.Piping.Unary.Systems;
+
+public sealed class GasCanisterSystem : SharedGasCanisterSystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<GasCanisterComponent, AfterAutoHandleStateEvent>(OnGasState);
+    }
+
+    private void OnGasState(Entity<GasCanisterComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        if (UI.TryGetOpenUi<GasCanisterBoundUserInterface>(ent.Owner, GasCanisterUiKey.Key, out var bui))
+        {
+            bui.Update<GasCanisterBoundUserInterfaceState>();
+        }
+    }
+
+    protected override void DirtyUI(EntityUid uid, GasCanisterComponent? component = null, NodeContainerComponent? nodes = null)
+    {
+        if (UI.TryGetOpenUi<GasCanisterBoundUserInterface>(uid, GasCanisterUiKey.Key, out var bui))
+        {
+            bui.Update<GasCanisterBoundUserInterfaceState>();
+        }
+    }
+}

Content.Client/Atmos/Piping/Unary/Systems/GasThermoMachineSystem.cs

@@ -0,0 +1,29 @@
+using Content.Client.Atmos.UI;
+using Content.Shared.Atmos.Piping.Unary.Components;
+using Content.Shared.Atmos.Piping.Unary.Systems;
+
+namespace Content.Client.Atmos.Piping.Unary.Systems;
+
+public sealed class GasThermoMachineSystem : SharedGasThermoMachineSystem
+{
+    [Dependency] private readonly SharedUserInterfaceSystem _ui = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<GasThermoMachineComponent, AfterAutoHandleStateEvent>(OnGasAfterState);
+    }
+
+    private void OnGasAfterState(Entity<GasThermoMachineComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        DirtyUI(ent.Owner, ent.Comp);
+    }
+
+    protected override void DirtyUI(EntityUid uid, GasThermoMachineComponent? thermoMachine, UserInterfaceComponent? ui = null)
+    {
+        if (_ui.TryGetOpenUi<GasThermomachineBoundUserInterface>(uid, ThermomachineUiKey.Key, out var bui))
+        {
+            bui.Update();
+        }
+    }
+}

Content.Client/Atmos/UI/GasCanisterBoundUserInterface.cs

@@ -1,4 +1,7 @@
-using Content.Shared.Atmos.Piping.Binary.Components;
+using Content.Shared.Atmos.Components;
+using Content.Shared.Atmos.Piping.Binary.Components;
+using Content.Shared.Atmos.Piping.Unary.Components;
+using Content.Shared.IdentityManagement;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 using Robust.Client.UserInterface;
@@ -32,22 +35,22 @@ namespace Content.Client.Atmos.UI
 
         private void OnTankEjectPressed()
         {
-            SendMessage(new GasCanisterHoldingTankEjectMessage());
+            SendPredictedMessage(new GasCanisterHoldingTankEjectMessage());
         }
 
         private void OnReleasePressureSet(float value)
         {
-            SendMessage(new GasCanisterChangeReleasePressureMessage(value));
+            SendPredictedMessage(new GasCanisterChangeReleasePressureMessage(value));
         }
 
         private void OnReleaseValveOpenPressed()
         {
-            SendMessage(new GasCanisterChangeReleaseValveMessage(true));
+            SendPredictedMessage(new GasCanisterChangeReleaseValveMessage(true));
         }
 
         private void OnReleaseValveClosePressed()
         {
-            SendMessage(new GasCanisterChangeReleaseValveMessage(false));
+            SendPredictedMessage(new GasCanisterChangeReleaseValveMessage(false));
         }
 
         /// <summary>
@@ -57,17 +60,21 @@ namespace Content.Client.Atmos.UI
         protected override void UpdateState(BoundUserInterfaceState state)
         {
             base.UpdateState(state);
-            if (_window == null || state is not GasCanisterBoundUserInterfaceState cast)
+            if (_window == null || state is not GasCanisterBoundUserInterfaceState cast || !EntMan.TryGetComponent(Owner, out GasCanisterComponent? component))
                 return;
 
-            _window.SetCanisterLabel(cast.CanisterLabel);
+            var canisterLabel = Identity.Name(Owner, EntMan);
+            var tankLabel = component.GasTankSlot.Item != null ? Identity.Name(component.GasTankSlot.Item.Value, EntMan) : null;
+
+            _window.SetCanisterLabel(canisterLabel);
             _window.SetCanisterPressure(cast.CanisterPressure);
             _window.SetPortStatus(cast.PortStatus);
-            _window.SetTankLabel(cast.TankLabel);
+
+            _window.SetTankLabel(tankLabel);
             _window.SetTankPressure(cast.TankPressure);
-            _window.SetReleasePressureRange(cast.ReleasePressureMin, cast.ReleasePressureMax);
-            _window.SetReleasePressure(cast.ReleasePressure);
-            _window.SetReleaseValve(cast.ReleaseValve);
+            _window.SetReleasePressureRange(component.MinReleasePressure, component.MaxReleasePressure);
+            _window.SetReleasePressure(component.ReleasePressure);
+            _window.SetReleaseValve(component.ReleaseValve);
         }
 
         protected override void Dispose(bool disposing)

Content.Client/Atmos/UI/GasPressurePumpBoundUserInterface.cs

@@ -13,9 +13,6 @@ namespace Content.Client.Atmos.UI;
 [UsedImplicitly]
 public sealed class GasPressurePumpBoundUserInterface(EntityUid owner, Enum uiKey) : BoundUserInterface(owner, uiKey)
 {
-    [ViewVariables]
-    private const float MaxPressure = Atmospherics.MaxOutputPressure;
-
     [ViewVariables]
     private GasPressurePumpWindow? _window;
 

Content.Client/Atmos/UI/GasThermomachineBoundUserInterface.cs

@@ -1,5 +1,8 @@
-using Content.Shared.Atmos;
+using Content.Client.Power.EntitySystems;
+using Content.Shared.Atmos;
 using Content.Shared.Atmos.Piping.Unary.Components;
+using Content.Shared.Atmos.Piping.Unary.Systems;
+using Content.Shared.Power.Components;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 using Robust.Client.UserInterface;
@@ -36,6 +39,8 @@ namespace Content.Client.Atmos.UI
 
             _window.ToggleStatusButton.OnPressed += _ => OnToggleStatusButtonPressed();
             _window.TemperatureSpinbox.OnValueChanged += _ => OnTemperatureChanged(_window.TemperatureSpinbox.Value);
+            _window.Entity = Owner;
+            Update();
         }
 
         private void OnToggleStatusButtonPressed()
@@ -43,7 +48,7 @@ namespace Content.Client.Atmos.UI
             if (_window is null) return;
 
             _window.SetActive(!_window.Active);
-            SendMessage(new GasThermomachineToggleMessage());
+            SendPredictedMessage(new GasThermomachineToggleMessage());
         }
 
         private void OnTemperatureChanged(float value)
@@ -60,25 +65,32 @@ namespace Content.Client.Atmos.UI
                 return;
             }
 
-            SendMessage(new GasThermomachineChangeTemperatureMessage(actual));
+            SendPredictedMessage(new GasThermomachineChangeTemperatureMessage(actual));
         }
 
-        /// <summary>
-        /// Update the UI state based on server-sent info
-        /// </summary>
-        /// <param name="state"></param>
-        protected override void UpdateState(BoundUserInterfaceState state)
+        public override void Update()
         {
-            base.UpdateState(state);
-            if (_window == null || state is not GasThermomachineBoundUserInterfaceState cast)
+            if (_window == null || !EntMan.TryGetComponent(Owner, out GasThermoMachineComponent? thermo))
                 return;
 
-            _minTemp = cast.MinTemperature;
-            _maxTemp = cast.MaxTemperature;
-            _isHeater = cast.IsHeater;
+            var system = EntMan.System<SharedGasThermoMachineSystem>();
+            _minTemp = thermo.MinTemperature;
+            _maxTemp = thermo.MaxTemperature;
+            _isHeater = system.IsHeater(thermo);
+
+            _window.SetTemperature(thermo.TargetTemperature);
+
+            var receiverSys = EntMan.System<PowerReceiverSystem>();
+            SharedApcPowerReceiverComponent? receiver = null;
+
+            receiverSys.ResolveApc(Owner, ref receiver);
+
+            // Also set in frameupdates.
+            if (receiver != null)
+            {
+                _window.SetActive(!receiver.PowerDisabled);
+            }
 
-            _window.SetTemperature(cast.Temperature);
-            _window.SetActive(cast.Enabled);
             _window.Title = _isHeater switch
             {
                 false => Loc.GetString("comp-gas-thermomachine-ui-title-freezer"),

Content.Client/Atmos/UI/GasThermomachineWindow.xaml

@@ -1,5 +1,6 @@
-<DefaultWindow xmlns="https://spacestation14.io"
+<controls:FancyWindow xmlns="https://spacestation14.io"
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+               xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
                MinSize="300 120" Title="{Loc comp-gas-thermomachine-ui-title-freezer}">
     <BoxContainer Name="VboxContainer" Orientation="Vertical" Margin="5 5 5 5" SeparationOverride="10">
         <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
@@ -11,4 +12,4 @@
             <Label Text="{Loc comp-gas-thermomachine-ui-temperature}"/>
         </BoxContainer>
     </BoxContainer>
-</DefaultWindow>
+</controls:FancyWindow>

Content.Client/Atmos/UI/GasThermomachineWindow.xaml.cs

@@ -1,19 +1,26 @@
+using Content.Client.Power.Components;
+using Content.Client.UserInterface.Controls;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
-using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Timing;
 
 namespace Content.Client.Atmos.UI;
 
 [GenerateTypedNameReferences]
-public sealed partial class GasThermomachineWindow : DefaultWindow
+public sealed partial class GasThermomachineWindow : FancyWindow
 {
+    [Dependency] private readonly IEntityManager _entManager = default!;
+
     public bool Active = true;
 
     public FloatSpinBox TemperatureSpinbox;
 
+    public EntityUid Entity;
+
     public GasThermomachineWindow()
     {
+        IoCManager.InjectDependencies(this);
         RobustXamlLoader.Load(this);
 
         SpinboxHBox.AddChild(
@@ -27,12 +34,10 @@ public sealed partial class GasThermomachineWindow : DefaultWindow
         if (active)
         {
             ToggleStatusButton.Text = Loc.GetString("comp-gas-thermomachine-ui-status-enabled");
-            ToggleStatusButton.Pressed = true;
         }
         else
         {
             ToggleStatusButton.Text = Loc.GetString("comp-gas-thermomachine-ui-status-disabled");
-            ToggleStatusButton.Pressed = false;
         }
     }
 
@@ -40,4 +45,14 @@ public sealed partial class GasThermomachineWindow : DefaultWindow
     {
         TemperatureSpinbox.Value = temperature;
     }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        base.FrameUpdate(args);
+
+        if (_entManager.TryGetComponent(Entity, out ApcPowerReceiverComponent? receiver))
+        {
+            SetActive(!receiver.PowerDisabled);
+        }
+    }
 }

Content.Client/Atmos/Visualizers/PortableScrubberVisualsSystem.cs

@@ -2,35 +2,37 @@ using Robust.Client.GameObjects;
 using Content.Shared.Atmos.Visuals;
 using Content.Client.Power;
 
-namespace Content.Client.Atmos.Visualizers
+namespace Content.Client.Atmos.Visualizers;
+
+/// <summary>
+/// Controls client-side visuals for portable scrubbers.
+/// </summary>
+public sealed class PortableScrubberSystem : VisualizerSystem<PortableScrubberVisualsComponent>
 {
-    /// <summary>
-    /// Controls client-side visuals for portable scrubbers.
-    /// </summary>
-    public sealed class PortableScrubberSystem : VisualizerSystem<PortableScrubberVisualsComponent>
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
+    protected override void OnAppearanceChange(EntityUid uid, PortableScrubberVisualsComponent component, ref AppearanceChangeEvent args)
     {
-        protected override void OnAppearanceChange(EntityUid uid, PortableScrubberVisualsComponent component, ref AppearanceChangeEvent args)
+        if (args.Sprite == null)
+            return;
+
+        if (AppearanceSystem.TryGetData<bool>(uid, PortableScrubberVisuals.IsFull, out var isFull, args.Component)
+            && AppearanceSystem.TryGetData<bool>(uid, PortableScrubberVisuals.IsRunning, out var isRunning, args.Component))
         {
-            if (args.Sprite == null)
-                return;
+            var runningState = isRunning ? component.RunningState : component.IdleState;
+            _sprite.LayerSetRsiState((uid, args.Sprite), PortableScrubberVisualLayers.IsRunning, runningState);
 
-            if (AppearanceSystem.TryGetData<bool>(uid, PortableScrubberVisuals.IsFull, out var isFull, args.Component)
-                && AppearanceSystem.TryGetData<bool>(uid, PortableScrubberVisuals.IsRunning, out var isRunning, args.Component))
-            {
-                var runningState = isRunning ? component.RunningState : component.IdleState;
-                args.Sprite.LayerSetState(PortableScrubberVisualLayers.IsRunning, runningState);
+            var fullState = isFull ? component.FullState : component.ReadyState;
+            _sprite.LayerSetRsiState((uid, args.Sprite), PowerDeviceVisualLayers.Powered, fullState);
+        }
 
-                var fullState = isFull ? component.FullState : component.ReadyState;
-                args.Sprite.LayerSetState(PowerDeviceVisualLayers.Powered, fullState);
-            }
-
-            if (AppearanceSystem.TryGetData<bool>(uid, PortableScrubberVisuals.IsDraining, out var isDraining, args.Component))
-            {
-                args.Sprite.LayerSetVisible(PortableScrubberVisualLayers.IsDraining, isDraining);
-            }
+        if (AppearanceSystem.TryGetData<bool>(uid, PortableScrubberVisuals.IsDraining, out var isDraining, args.Component))
+        {
+            _sprite.LayerSetVisible((uid, args.Sprite), PortableScrubberVisualLayers.IsDraining, isDraining);
         }
     }
 }
+
 public enum PortableScrubberVisualLayers : byte
 {
     IsRunning,

Content.Client/Audio/Jukebox/JukeboxSystem.cs

@@ -12,6 +12,7 @@ public sealed class JukeboxSystem : SharedJukeboxSystem
     [Dependency] private readonly AnimationPlayerSystem _animationPlayer = default!;
     [Dependency] private readonly SharedAppearanceSystem _appearanceSystem = default!;
     [Dependency] private readonly SharedUserInterfaceSystem _uiSystem = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -64,7 +65,7 @@ public sealed class JukeboxSystem : SharedJukeboxSystem
             visualState = JukeboxVisualState.On;
         }
 
-        UpdateAppearance(uid, visualState, component, sprite);
+        UpdateAppearance((uid, sprite), visualState, component);
     }
 
     private void OnAppearanceChange(EntityUid uid, JukeboxComponent component, ref AppearanceChangeEvent args)
@@ -78,25 +79,25 @@ public sealed class JukeboxSystem : SharedJukeboxSystem
             visualState = JukeboxVisualState.On;
         }
 
-        UpdateAppearance(uid, visualState, component, args.Sprite);
+        UpdateAppearance((uid, args.Sprite), visualState, component);
     }
 
-    private void UpdateAppearance(EntityUid uid, JukeboxVisualState visualState, JukeboxComponent component, SpriteComponent sprite)
+    private void UpdateAppearance(Entity<SpriteComponent> entity, JukeboxVisualState visualState, JukeboxComponent component)
     {
-        SetLayerState(JukeboxVisualLayers.Base, component.OffState, sprite);
+        SetLayerState(JukeboxVisualLayers.Base, component.OffState, entity);
 
         switch (visualState)
         {
             case JukeboxVisualState.On:
-                SetLayerState(JukeboxVisualLayers.Base, component.OnState, sprite);
+                SetLayerState(JukeboxVisualLayers.Base, component.OnState, entity);
                 break;
 
             case JukeboxVisualState.Off:
-                SetLayerState(JukeboxVisualLayers.Base, component.OffState, sprite);
+                SetLayerState(JukeboxVisualLayers.Base, component.OffState, entity);
                 break;
 
             case JukeboxVisualState.Select:
-                PlayAnimation(uid, JukeboxVisualLayers.Base, component.SelectState, 1.0f, sprite);
+                PlayAnimation(entity.Owner, JukeboxVisualLayers.Base, component.SelectState, 1.0f, entity);
                 break;
         }
     }
@@ -109,7 +110,7 @@ public sealed class JukeboxSystem : SharedJukeboxSystem
         if (!_animationPlayer.HasRunningAnimation(uid, state))
         {
             var animation = GetAnimation(layer, state, animationTime);
-            sprite.LayerSetVisible(layer, true);
+            _sprite.LayerSetVisible((uid, sprite), layer, true);
             _animationPlayer.Play(uid, animation, state);
         }
     }
@@ -133,13 +134,13 @@ public sealed class JukeboxSystem : SharedJukeboxSystem
         };
     }
 
-    private void SetLayerState(JukeboxVisualLayers layer, string? state, SpriteComponent sprite)
+    private void SetLayerState(JukeboxVisualLayers layer, string? state, Entity<SpriteComponent> sprite)
     {
         if (string.IsNullOrEmpty(state))
             return;
 
-        sprite.LayerSetVisible(layer, true);
-        sprite.LayerSetAutoAnimated(layer, true);
-        sprite.LayerSetState(layer, state);
+        _sprite.LayerSetVisible(sprite.AsNullable(), layer, true);
+        _sprite.LayerSetAutoAnimated(sprite.AsNullable(), layer, true);
+        _sprite.LayerSetRsiState(sprite.AsNullable(), layer, state);
     }
 }

Content.Client/BarSign/BarSignSystem.cs

@@ -41,12 +41,12 @@ public sealed class BarSignSystem : VisualizerSystem<BarSignComponent>
             && sign.Current != null
             && _prototypeManager.TryIndex(sign.Current, out var proto))
         {
-            sprite.LayerSetSprite(0, proto.Icon);
+            SpriteSystem.LayerSetSprite((id, sprite), 0, proto.Icon);
             sprite.LayerSetShader(0, "unshaded");
         }
         else
         {
-            sprite.LayerSetState(0, "empty");
+            SpriteSystem.LayerSetRsiState((id, sprite), 0, "empty");
             sprite.LayerSetShader(0, null, null);
         }
     }

Content.Client/Beam/BeamSystem.cs

@@ -7,6 +7,8 @@ namespace Content.Client.Beam;
 
 public sealed class BeamSystem : SharedBeamSystem
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -21,11 +23,11 @@ public sealed class BeamSystem : SharedBeamSystem
 
         if (TryComp<SpriteComponent>(beam, out var sprites))
         {
-            sprites.Rotation = args.UserAngle;
+            _sprite.SetRotation((beam, sprites), args.UserAngle);
 
             if (args.BodyState != null)
             {
-                sprites.LayerSetState(0, args.BodyState);
+                _sprite.LayerSetRsiState((beam, sprites), 0, args.BodyState);
                 sprites.LayerSetShader(0, args.Shader);
             }
         }

Content.Client/Bed/BedSystem.cs

@@ -0,0 +1,8 @@
+using Content.Shared.Bed;
+
+namespace Content.Client.Bed;
+
+public sealed class BedSystem : SharedBedSystem
+{
+
+}

Content.Client/Bed/StasisBedSystem.cs

@@ -10,7 +10,7 @@ public sealed class StasisBedSystem : VisualizerSystem<StasisBedVisualsComponent
         if (args.Sprite != null
             && AppearanceSystem.TryGetData<bool>(uid, StasisBedVisuals.IsOn, out var isOn, args.Component))
         {
-            args.Sprite.LayerSetVisible(StasisBedVisualLayers.IsOn, isOn);
+            SpriteSystem.LayerSetVisible((uid, args.Sprite), StasisBedVisualLayers.IsOn, isOn);
         }
     }
 }

Content.Client/Body/Systems/InternalsSystem.cs

@@ -0,0 +1,24 @@
+using Content.Shared.Atmos.Components;
+using Content.Shared.Body.Components;
+using Content.Shared.Body.Systems;
+
+namespace Content.Client.Body.Systems;
+
+public sealed class InternalsSystem : SharedInternalsSystem
+{
+    [Dependency] private readonly SharedUserInterfaceSystem _ui = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<InternalsComponent, AfterAutoHandleStateEvent>(OnInternalsAfterState);
+    }
+
+    private void OnInternalsAfterState(Entity<InternalsComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        if (ent.Comp.GasTankEntity != null && _ui.TryGetOpenUi(ent.Comp.GasTankEntity.Value, SharedGasTankUiKey.Key, out var bui))
+        {
+            bui.Update();
+        }
+    }
+}

Content.Client/Botany/PlantHolderVisualizerSystem.cs

@@ -1,11 +1,14 @@
 using Content.Client.Botany.Components;
 using Content.Shared.Botany;
 using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Botany;
 
 public sealed class PlantHolderVisualizerSystem : VisualizerSystem<PlantHolderVisualsComponent>
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -17,8 +20,8 @@ public sealed class PlantHolderVisualizerSystem : VisualizerSystem<PlantHolderVi
         if (!TryComp<SpriteComponent>(uid, out var sprite))
             return;
 
-        sprite.LayerMapReserveBlank(PlantHolderLayers.Plant);
-        sprite.LayerSetVisible(PlantHolderLayers.Plant, false);
+        _sprite.LayerMapReserve((uid, sprite), PlantHolderLayers.Plant);
+        _sprite.LayerSetVisible((uid, sprite), PlantHolderLayers.Plant, false);
     }
 
     protected override void OnAppearanceChange(EntityUid uid, PlantHolderVisualsComponent component, ref AppearanceChangeEvent args)
@@ -31,12 +34,12 @@ public sealed class PlantHolderVisualizerSystem : VisualizerSystem<PlantHolderVi
         {
             var valid = !string.IsNullOrWhiteSpace(state);
 
-            args.Sprite.LayerSetVisible(PlantHolderLayers.Plant, valid);
+            _sprite.LayerSetVisible((uid, args.Sprite), PlantHolderLayers.Plant, valid);
 
             if (valid)
             {
-                args.Sprite.LayerSetRSI(PlantHolderLayers.Plant, rsi);
-                args.Sprite.LayerSetState(PlantHolderLayers.Plant, state);
+                _sprite.LayerSetRsi((uid, args.Sprite), PlantHolderLayers.Plant, new ResPath(rsi));
+                _sprite.LayerSetRsiState((uid, args.Sprite), PlantHolderLayers.Plant, state);
             }
         }
     }

Content.Client/Botany/PotencyVisualsSystem.cs

@@ -15,7 +15,7 @@ public sealed class PotencyVisualsSystem : VisualizerSystem<PotencyVisualsCompon
         if (AppearanceSystem.TryGetData<float>(uid, ProduceVisuals.Potency, out var potency, args.Component))
         {
             var scale = MathHelper.Lerp(component.MinimumScale, component.MaximumScale, potency / 100);
-            args.Sprite.Scale = new Vector2(scale, scale);
+            SpriteSystem.SetScale((uid, args.Sprite), new Vector2(scale, scale));
         }
     }
 }

Content.Client/Buckle/BuckleSystem.cs

@@ -13,6 +13,7 @@ internal sealed class BuckleSystem : SharedBuckleSystem
     [Dependency] private readonly RotationVisualizerSystem _rotationVisualizerSystem = default!;
     [Dependency] private readonly IEyeManager _eye = default!;
     [Dependency] private readonly SharedTransformSystem _xformSystem = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -69,11 +70,11 @@ internal sealed class BuckleSystem : SharedBuckleSystem
             {
                 // This will only assign if empty, it won't get overwritten by new depth on multiple calls, which do happen easily
                 buckle.OriginalDrawDepth ??= buckledSprite.DrawDepth;
-                buckledSprite.DrawDepth = strapSprite.DrawDepth - 1;
+                _sprite.SetDrawDepth((buckledEntity, buckledSprite), strapSprite.DrawDepth - 1);
             }
             else if (buckle.OriginalDrawDepth.HasValue)
             {
-                buckledSprite.DrawDepth = buckle.OriginalDrawDepth.Value;
+                _sprite.SetDrawDepth((buckledEntity, buckledSprite), buckle.OriginalDrawDepth.Value);
                 buckle.OriginalDrawDepth = null;
             }
         }
@@ -97,7 +98,7 @@ internal sealed class BuckleSystem : SharedBuckleSystem
             return;
 
         ent.Comp.OriginalDrawDepth ??= buckledSprite.DrawDepth;
-        buckledSprite.DrawDepth = strapSprite.DrawDepth - 1;
+        _sprite.SetDrawDepth((ent.Owner, buckledSprite), strapSprite.DrawDepth - 1);
     }
 
     /// <summary>
@@ -111,7 +112,7 @@ internal sealed class BuckleSystem : SharedBuckleSystem
         if (!ent.Comp.OriginalDrawDepth.HasValue)
             return;
 
-        buckledSprite.DrawDepth = ent.Comp.OriginalDrawDepth.Value;
+        _sprite.SetDrawDepth((ent.Owner, buckledSprite), ent.Comp.OriginalDrawDepth.Value);
         ent.Comp.OriginalDrawDepth = null;
     }
 

Content.Client/CardboardBox/CardboardBoxSystem.cs

@@ -13,6 +13,7 @@ public sealed class CardboardBoxSystem : SharedCardboardBoxSystem
     [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
     [Dependency] private readonly TransformSystem _transform = default!;
     [Dependency] private readonly ExamineSystemShared _examine = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     private EntityQuery<BodyComponent> _bodyQuery;
 
@@ -74,7 +75,7 @@ public sealed class CardboardBoxSystem : SharedCardboardBoxSystem
             if (!xformQuery.TryGetComponent(ent, out var entTransform) || !TryComp<SpriteComponent>(ent, out var sprite))
                 continue;
 
-            sprite.Offset = new Vector2(0, 1);
+            _sprite.SetOffset((ent, sprite), new Vector2(0, 1));
             _transform.SetParent(ent, entTransform, mob);
         }
 

Content.Client/Cargo/BUI/CargoOrderConsoleBoundUserInterface.cs

@@ -138,6 +138,11 @@ namespace Content.Client.Cargo.BUI
 
             AccountName = cState.Name;
 
+            if (_menu == null)
+                return;
+
+            _menu.ProductCatalogue = cState.Products;
+
             _menu?.UpdateStation(station);
             Populate(cState.Orders);
         }

Content.Client/Cargo/Systems/CargoSystem.Telepad.cs

@@ -10,6 +10,7 @@ namespace Content.Client.Cargo.Systems;
 public sealed partial class CargoSystem
 {
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     private static readonly Animation CargoTelepadBeamAnimation = new()
     {
@@ -80,12 +81,12 @@ public sealed partial class CargoSystem
                     _player.Play((uid, player), CargoTelepadBeamAnimation, TelepadBeamKey);
                 break;
             case CargoTelepadState.Unpowered:
-                sprite.LayerSetVisible(CargoTelepadLayers.Beam, false);
+                _sprite.LayerSetVisible((uid, sprite), CargoTelepadLayers.Beam, false);
                 _player.Stop(uid, player, TelepadBeamKey);
                 _player.Stop(uid, player, TelepadIdleKey);
                 break;
             default:
-                sprite.LayerSetVisible(CargoTelepadLayers.Beam, true);
+                _sprite.LayerSetVisible((uid, sprite), CargoTelepadLayers.Beam, true);
 
                 if (_player.HasRunningAnimation(uid, player, TelepadIdleKey) ||
                     _player.HasRunningAnimation(uid, player, TelepadBeamKey))

Content.Client/Cargo/UI/CargoConsoleMenu.xaml

@@ -38,9 +38,10 @@
                         <!-- Products get added here by code -->
                     </BoxContainer>
                 </ScrollContainer>
-                <Control MinHeight="5"/>
+                <Control MinHeight="5" Name="OrdersSpacer"/>
                 <PanelContainer VerticalExpand="True"
-                                SizeFlagsStretchRatio="1">
+                                SizeFlagsStretchRatio="1"
+                                Name="Orders">
                     <PanelContainer.PanelOverride>
                         <gfx:StyleBoxFlat BackgroundColor="#000000" />
                     </PanelContainer.PanelOverride>

Content.Client/Cargo/UI/CargoConsoleMenu.xaml.cs

@@ -40,6 +40,8 @@ namespace Content.Client.Cargo.UI
         private readonly List<string> _categoryStrings = new();
         private string? _category;
 
+        public List<ProtoId<CargoProductPrototype>> ProductCatalogue = new();
+
         public CargoConsoleMenu(EntityUid owner, IEntityManager entMan, IPrototypeManager protoManager, SpriteSystem spriteSystem)
         {
             RobustXamlLoader.Load(this);
@@ -113,14 +115,16 @@ namespace Content.Client.Cargo.UI
             Categories.SelectId(id);
         }
 
-        public IEnumerable<CargoProductPrototype> ProductPrototypes
+        private IEnumerable<CargoProductPrototype> ProductPrototypes
         {
             get
             {
                 var allowedGroups = _entityManager.GetComponentOrNull<CargoOrderConsoleComponent>(_owner)?.AllowedGroups;
 
-                foreach (var cargoPrototype in _protoManager.EnumeratePrototypes<CargoProductPrototype>())
+                foreach (var cargoPrototypeId in ProductCatalogue)
                 {
+                    var cargoPrototype = _protoManager.Index(cargoPrototypeId);
+
                     if (!allowedGroups?.Contains(cargoPrototype.Group) ?? false)
                         continue;
 
@@ -208,6 +212,7 @@ namespace Content.Client.Cargo.UI
 
                 var product = _protoManager.Index<EntityPrototype>(order.ProductId);
                 var productName = product.Name;
+                var account = _protoManager.Index(order.Account);
 
                 var row = new CargoOrderRow
                 {
@@ -219,7 +224,9 @@ namespace Content.Client.Cargo.UI
                             "cargo-console-menu-populate-orders-cargo-order-row-product-name-text",
                             ("productName", productName),
                             ("orderAmount", order.OrderQuantity),
-                            ("orderRequester", order.Requester))
+                            ("orderRequester", order.Requester),
+                            ("accountColor", account.Color),
+                            ("account", Loc.GetString(account.Code)))
                     },
                     Description =
                     {
@@ -282,6 +289,9 @@ namespace Content.Client.Cargo.UI
             AccountActionButton.Disabled = TransferSpinBox.Value <= 0 ||
                                            TransferSpinBox.Value > bankAccount.Accounts[orderConsole.Account] * orderConsole.TransferLimit ||
                                            _timing.CurTime < orderConsole.NextAccountActionTime;
+
+            OrdersSpacer.Visible = !orderConsole.SlipPrinter;
+            Orders.Visible = !orderConsole.SlipPrinter;
         }
     }
 }

Content.Client/Cargo/UI/CargoOrderRow.xaml

@@ -11,11 +11,10 @@
         <BoxContainer Orientation="Vertical"
                       HorizontalExpand="True"
                       VerticalExpand="True">
-            <Label Name="ProductName"
+            <RichTextLabel Name="ProductName"
                    Access="Public"
                    HorizontalExpand="True"
-                   StyleClasses="LabelSubText"
-                   ClipText="True" />
+                   StyleClasses="LabelSubText" />
             <Label Name="Description"
                    Access="Public"
                    HorizontalExpand="True"

Content.Client/Cargo/UI/CargoShuttleMenu.xaml.cs

@@ -36,6 +36,7 @@ namespace Content.Client.Cargo.UI
             {
                  var product = protoManager.Index<EntityPrototype>(order.ProductId);
                  var productName = product.Name;
+                 var account = protoManager.Index(order.Account);
 
                  var row = new CargoOrderRow
                  {
@@ -47,7 +48,9 @@ namespace Content.Client.Cargo.UI
                              "cargo-console-menu-populate-orders-cargo-order-row-product-name-text",
                              ("productName", productName),
                              ("orderAmount", order.OrderQuantity - order.NumDispatched),
-                             ("orderRequester", order.Requester))
+                             ("orderRequester", order.Requester),
+                             ("accountColor", account.Color),
+                             ("account", Loc.GetString(account.Code)))
                      },
                      Description = {Text = Loc.GetString("cargo-console-menu-order-reason-description",
                          ("reason", order.Reason))}

Content.Client/Chasm/ChasmFallingVisualsSystem.cs

@@ -11,6 +11,7 @@ namespace Content.Client.Chasm;
 public sealed class ChasmFallingVisualsSystem : EntitySystem
 {
     [Dependency] private readonly AnimationPlayerSystem _anim = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     private readonly string _chasmFallAnimationKey = "chasm_fall";
 
@@ -46,7 +47,7 @@ public sealed class ChasmFallingVisualsSystem : EntitySystem
         if (!TryComp<SpriteComponent>(uid, out var sprite))
             return;
 
-        sprite.Scale = component.OriginalScale;
+        _sprite.SetScale((uid, sprite), component.OriginalScale);
 
         if (!TryComp<AnimationPlayerComponent>(uid, out var player))
             return;

Content.Client/Chat/TypingIndicator/TypingIndicatorSystem.cs

@@ -16,6 +16,7 @@ public sealed class TypingIndicatorSystem : SharedTypingIndicatorSystem
     private readonly TimeSpan _typingTimeout = TimeSpan.FromSeconds(2);
     private TimeSpan _lastTextChange;
     private bool _isClientTyping;
+    private bool _isClientChatFocused;
 
     public override void Initialize()
     {
@@ -31,7 +32,8 @@ public sealed class TypingIndicatorSystem : SharedTypingIndicatorSystem
             return;
 
         // client typed something - show typing indicator
-        ClientUpdateTyping(true);
+        _isClientTyping = true;
+        ClientUpdateTyping();
         _lastTextChange = _time.CurTime;
     }
 
@@ -42,36 +44,53 @@ public sealed class TypingIndicatorSystem : SharedTypingIndicatorSystem
             return;
 
         // client submitted text - hide typing indicator
-        ClientUpdateTyping(false);
+        _isClientTyping = false;
+        ClientUpdateTyping();
+    }
+
+    public void ClientChangedChatFocus(bool isFocused)
+    {
+        // don't update it if player don't want to show typing
+        if (!_cfg.GetCVar(CCVars.ChatShowTypingIndicator))
+            return;
+
+        // client submitted text - hide typing indicator
+        _isClientChatFocused = isFocused;
+        ClientUpdateTyping();
     }
 
     public override void Update(float frameTime)
     {
         base.Update(frameTime);
 
+        if (!_time.IsFirstTimePredicted)
+            return;
+
         // check if client didn't changed chat text box for a long time
         if (_isClientTyping)
         {
             var dif = _time.CurTime - _lastTextChange;
             if (dif > _typingTimeout)
             {
-                // client didn't typed anything for a long time - hide indicator
-                ClientUpdateTyping(false);
+                // client didn't typed anything for a long time - change indicator
+                _isClientTyping = false;
+                ClientUpdateTyping();
             }
         }
     }
 
-    private void ClientUpdateTyping(bool isClientTyping)
+    private void ClientUpdateTyping()
     {
-        if (_isClientTyping == isClientTyping)
-            return;
-
-        // check if player controls any entity.
+        // check if player controls any pawn
         if (_playerManager.LocalEntity == null)
             return;
 
-        _isClientTyping = isClientTyping;
-        RaisePredictiveEvent(new TypingChangedEvent(isClientTyping));
+        var state = TypingIndicatorState.None;
+        if (_isClientChatFocused)
+            state = _isClientTyping ? TypingIndicatorState.Typing : TypingIndicatorState.Idle;
+
+        // send a networked event to server
+        RaisePredictiveEvent(new TypingChangedEvent(state));
     }
 
     private void OnShowTypingChanged(bool showTyping)
@@ -79,7 +98,8 @@ public sealed class TypingIndicatorSystem : SharedTypingIndicatorSystem
         // hide typing indicator immediately if player don't want to show it anymore
         if (!showTyping)
         {
-            ClientUpdateTyping(false);
+            _isClientTyping = false;
+            ClientUpdateTyping();
         }
     }
 }

Content.Client/Chat/TypingIndicator/TypingIndicatorVisualizerSystem.cs

@@ -1,6 +1,5 @@
 using Content.Shared.Chat.TypingIndicator;
 using Robust.Client.GameObjects;
-using Robust.Client.Graphics;
 using Robust.Shared.Prototypes;
 using Content.Shared.Inventory;
 
@@ -10,7 +9,7 @@ public sealed class TypingIndicatorVisualizerSystem : VisualizerSystem<TypingInd
 {
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly InventorySystem _inventory = default!;
-
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     protected override void OnAppearanceChange(EntityUid uid, TypingIndicatorComponent component, ref AppearanceChangeEvent args)
     {
@@ -35,15 +34,25 @@ public sealed class TypingIndicatorVisualizerSystem : VisualizerSystem<TypingInd
             return;
         }
 
-        AppearanceSystem.TryGetData<bool>(uid, TypingIndicatorVisuals.IsTyping, out var isTyping, args.Component);
-        var layerExists = args.Sprite.LayerMapTryGet(TypingIndicatorLayers.Base, out var layer);
+        var layerExists = _sprite.LayerMapTryGet((uid, args.Sprite), TypingIndicatorLayers.Base, out var layer, false);
         if (!layerExists)
-            layer = args.Sprite.LayerMapReserveBlank(TypingIndicatorLayers.Base);
+            layer = _sprite.LayerMapReserve((uid, args.Sprite), TypingIndicatorLayers.Base);
 
-        args.Sprite.LayerSetRSI(layer, proto.SpritePath);
-        args.Sprite.LayerSetState(layer, proto.TypingState);
+        _sprite.LayerSetRsi((uid, args.Sprite), layer, proto.SpritePath);
+        _sprite.LayerSetRsiState((uid, args.Sprite), layer, proto.TypingState);
         args.Sprite.LayerSetShader(layer, proto.Shader);
-        args.Sprite.LayerSetOffset(layer, proto.Offset);
-        args.Sprite.LayerSetVisible(layer, isTyping);
+        _sprite.LayerSetOffset((uid, args.Sprite), layer, proto.Offset);
+
+        AppearanceSystem.TryGetData<TypingIndicatorState>(uid, TypingIndicatorVisuals.State, out var state);
+        _sprite.LayerSetVisible((uid, args.Sprite), layer, state != TypingIndicatorState.None);
+        switch (state)
+        {
+            case TypingIndicatorState.Idle:
+                _sprite.LayerSetRsiState((uid, args.Sprite), layer, proto.IdleState);
+                break;
+            case TypingIndicatorState.Typing:
+                _sprite.LayerSetRsiState((uid, args.Sprite), layer, proto.TypingState);
+                break;
+        }
     }
 }

Content.Client/Chemistry/EntitySystems/PillSystem.cs

@@ -5,6 +5,8 @@ namespace Content.Client.Chemistry.EntitySystems;
 
 public sealed class PillSystem : EntitySystem
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -16,9 +18,9 @@ public sealed class PillSystem : EntitySystem
         if (!TryComp(uid, out SpriteComponent? sprite))
             return;
 
-        if (!sprite.TryGetLayer(0, out var layer))
+        if (!_sprite.TryGetLayer((uid, sprite), 0, out var layer, false))
             return;
 
-        layer.SetState($"pill{component.PillType + 1}");
+        _sprite.LayerSetRsiState(layer, $"pill{component.PillType + 1}");
     }
 }

Content.Client/Chemistry/UI/ChemMasterWindow.xaml.cs

@@ -116,7 +116,10 @@ namespace Content.Client.Chemistry.UI
                 ("1", ChemMasterReagentAmount.U1, StyleBase.ButtonOpenBoth),
                 ("5", ChemMasterReagentAmount.U5, StyleBase.ButtonOpenBoth),
                 ("10", ChemMasterReagentAmount.U10, StyleBase.ButtonOpenBoth),
+                ("15", ChemMasterReagentAmount.U15, StyleBase.ButtonOpenBoth),
+                ("20", ChemMasterReagentAmount.U20, StyleBase.ButtonOpenBoth),
                 ("25", ChemMasterReagentAmount.U25, StyleBase.ButtonOpenBoth),
+                ("30", ChemMasterReagentAmount.U30, StyleBase.ButtonOpenBoth),
                 ("50", ChemMasterReagentAmount.U50, StyleBase.ButtonOpenBoth),
                 ("100", ChemMasterReagentAmount.U100, StyleBase.ButtonOpenBoth),
                 (Loc.GetString("chem-master-window-buffer-all-amount"), ChemMasterReagentAmount.All, StyleBase.ButtonOpenLeft),

Content.Client/Chemistry/UI/HyposprayStatusControl.cs

@@ -44,7 +44,7 @@ public sealed class HyposprayStatusControl : Control
         PrevMaxVolume = solution.MaxVolume;
         PrevOnlyAffectsMobs = _parent.Comp.OnlyAffectsMobs;
 
-        var modeStringLocalized = Loc.GetString(_parent.Comp.OnlyAffectsMobs switch
+        var modeStringLocalized = Loc.GetString((_parent.Comp.OnlyAffectsMobs && _parent.Comp.CanContainerDraw) switch
         {
             false => "hypospray-all-mode-text",
             true => "hypospray-mobs-only-mode-text",

Content.Client/Chemistry/UI/ReagentCardControl.xaml.cs

@@ -1,4 +1,5 @@
 using Content.Shared.Chemistry;
+using Content.Shared.Storage;
 using Robust.Client.AutoGenerated;
 using Robust.Client.Graphics;
 using Robust.Client.UserInterface;
@@ -9,15 +10,15 @@ namespace Content.Client.Chemistry.UI;
 [GenerateTypedNameReferences]
 public sealed partial class ReagentCardControl : Control
 {
-    public string StorageSlotId { get; }
-    public Action<string>? OnPressed;
-    public Action<string>? OnEjectButtonPressed;
+    public ItemStorageLocation StorageLocation { get; }
+    public Action<ItemStorageLocation>? OnPressed;
+    public Action<ItemStorageLocation>? OnEjectButtonPressed;
 
     public ReagentCardControl(ReagentInventoryItem item)
     {
         RobustXamlLoader.Load(this);
 
-        StorageSlotId = item.StorageSlotId;
+        StorageLocation = item.StorageLocation;
         ColorPanel.PanelOverride = new StyleBoxFlat { BackgroundColor = item.ReagentColor };
         ReagentNameLabel.Text = item.ReagentLabel;
         FillLabel.Text = Loc.GetString("reagent-dispenser-window-quantity-label-text", ("quantity", item.Quantity));;
@@ -26,7 +27,7 @@ public sealed partial class ReagentCardControl : Control
         if (item.Quantity == 0.0)
             MainButton.Disabled = true;
 
-        MainButton.OnPressed += args => OnPressed?.Invoke(StorageSlotId);
-        EjectButton.OnPressed += args => OnEjectButtonPressed?.Invoke(StorageSlotId);
+        MainButton.OnPressed += args => OnPressed?.Invoke(StorageLocation);
+        EjectButton.OnPressed += args => OnEjectButtonPressed?.Invoke(StorageLocation);
     }
 }

Content.Client/Chemistry/UI/ReagentDispenserBoundUserInterface.cs

@@ -1,4 +1,5 @@
 using Content.Client.Guidebook.Components;
+using Content.Client.UserInterface.Controls;
 using Content.Shared.Chemistry;
 using Content.Shared.Containers.ItemSlots;
 using JetBrains.Annotations;
@@ -31,8 +32,7 @@ namespace Content.Client.Chemistry.UI
 
             // Setup window layout/elements
             _window = this.CreateWindow<ReagentDispenserWindow>();
-            _window.Title = EntMan.GetComponent<MetaDataComponent>(Owner).EntityName;
-            _window.HelpGuidebookIds = EntMan.GetComponent<GuideHelpComponent>(Owner).Guides;
+            _window.SetInfoFromEntity(EntMan, Owner);
 
             // Setup static button actions.
             _window.EjectButton.OnPressed += _ => SendMessage(new ItemSlotButtonPressedEvent(SharedReagentDispenser.OutputSlotName));
@@ -40,8 +40,8 @@ namespace Content.Client.Chemistry.UI
 
             _window.AmountGrid.OnButtonPressed += s => SendMessage(new ReagentDispenserSetDispenseAmountMessage(s));
 
-            _window.OnDispenseReagentButtonPressed += (id) => SendMessage(new ReagentDispenserDispenseReagentMessage(id));
-            _window.OnEjectJugButtonPressed += (id) => SendMessage(new ItemSlotButtonPressedEvent(id));
+            _window.OnDispenseReagentButtonPressed += (location) => SendMessage(new ReagentDispenserDispenseReagentMessage(location));
+            _window.OnEjectJugButtonPressed += (location) => SendMessage(new ReagentDispenserEjectContainerMessage(location));
         }
 
         /// <summary>

Content.Client/Chemistry/UI/ReagentDispenserWindow.xaml.cs

@@ -2,6 +2,7 @@ using Content.Client.Stylesheets;
 using Content.Client.UserInterface.Controls;
 using Content.Shared.Chemistry;
 using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Storage;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
@@ -18,8 +19,8 @@ namespace Content.Client.Chemistry.UI
     {
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
-        public event Action<string>? OnDispenseReagentButtonPressed;
-        public event Action<string>? OnEjectJugButtonPressed;
+        public event Action<ItemStorageLocation>? OnDispenseReagentButtonPressed;
+        public event Action<ItemStorageLocation>? OnEjectJugButtonPressed;
 
         /// <summary>
         /// Create and initialize the dispenser UI client-side. Creates the basic layout,

Content.Client/Chemistry/Visualizers/FoamVisualizerSystem.cs

@@ -11,6 +11,7 @@ namespace Content.Client.Chemistry.Visualizers;
 public sealed class FoamVisualizerSystem : VisualizerSystem<FoamVisualsComponent>
 {
     [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -71,7 +72,7 @@ public sealed class FoamVisualizerSystem : VisualizerSystem<FoamVisualsComponent
             return;
 
         if (TryComp<SpriteComponent>(uid, out var sprite))
-            sprite.Visible = false;
+            _sprite.SetVisible((uid, sprite), false);
     }
 }
 

Content.Client/Chemistry/Visualizers/SmokeVisualizerSystem.cs

@@ -15,8 +15,8 @@ public sealed class SmokeVisualizerSystem : VisualizerSystem<SmokeVisualsCompone
     {
         if (args.Sprite == null)
             return;
-        if(!AppearanceSystem.TryGetData<Color>(uid, SmokeVisuals.Color, out var color))
+        if (!AppearanceSystem.TryGetData<Color>(uid, SmokeVisuals.Color, out var color))
             return;
-        args.Sprite.Color = color;
+        SpriteSystem.SetColor((uid, args.Sprite), color);
     }
 }

Content.Client/Chemistry/Visualizers/SolutionContainerVisualsSystem.cs

@@ -16,6 +16,7 @@ public sealed class SolutionContainerVisualsSystem : VisualizerSystem<SolutionCo
 {
     [Dependency] private readonly IPrototypeManager _prototype = default!;
     [Dependency] private readonly ItemSystem _itemSystem = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -49,7 +50,7 @@ public sealed class SolutionContainerVisualsSystem : VisualizerSystem<SolutionCo
         if (args.Sprite == null)
             return;
 
-        if (!args.Sprite.LayerMapTryGet(component.Layer, out var fillLayer))
+        if (!_sprite.LayerMapTryGet((uid, args.Sprite), component.Layer, out var fillLayer, false))
             return;
 
         var maxFillLevels = component.MaxFillLevels;
@@ -67,9 +68,9 @@ public sealed class SolutionContainerVisualsSystem : VisualizerSystem<SolutionCo
         }
         if (component.Metamorphic)
         {
-            if (args.Sprite.LayerMapTryGet(component.BaseLayer, out var baseLayer))
+            if (_sprite.LayerMapTryGet((uid, args.Sprite), component.BaseLayer, out var baseLayer, false))
             {
-                var hasOverlay = args.Sprite.LayerMapTryGet(component.OverlayLayer, out var overlayLayer);
+                var hasOverlay = _sprite.LayerMapTryGet((uid, args.Sprite), component.OverlayLayer, out var overlayLayer, false);
 
                 if (AppearanceSystem.TryGetData<string>(uid, SolutionContainerVisuals.BaseOverride,
                         out var baseOverride,
@@ -79,35 +80,35 @@ public sealed class SolutionContainerVisualsSystem : VisualizerSystem<SolutionCo
 
                     if (reagentProto?.MetamorphicSprite is { } sprite)
                     {
-                        args.Sprite.LayerSetSprite(baseLayer, sprite);
+                        _sprite.LayerSetSprite((uid, args.Sprite), baseLayer, sprite);
                         if (reagentProto.MetamorphicMaxFillLevels > 0)
                         {
-                            args.Sprite.LayerSetVisible(fillLayer, true);
+                            _sprite.LayerSetVisible((uid, args.Sprite), fillLayer, true);
                             maxFillLevels = reagentProto.MetamorphicMaxFillLevels;
                             fillBaseName = reagentProto.MetamorphicFillBaseName;
                             changeColor = reagentProto.MetamorphicChangeColor;
                             fillSprite = sprite;
                         }
                         else
-                            args.Sprite.LayerSetVisible(fillLayer, false);
+                            _sprite.LayerSetVisible((uid, args.Sprite), fillLayer, false);
 
                         if (hasOverlay)
-                            args.Sprite.LayerSetVisible(overlayLayer, false);
+                            _sprite.LayerSetVisible((uid, args.Sprite), overlayLayer, false);
                     }
                     else
                     {
-                        args.Sprite.LayerSetVisible(fillLayer, true);
+                        _sprite.LayerSetVisible((uid, args.Sprite), fillLayer, true);
                         if (hasOverlay)
-                            args.Sprite.LayerSetVisible(overlayLayer, true);
+                            _sprite.LayerSetVisible((uid, args.Sprite), overlayLayer, true);
                         if (component.MetamorphicDefaultSprite != null)
-                            args.Sprite.LayerSetSprite(baseLayer, component.MetamorphicDefaultSprite);
+                            _sprite.LayerSetSprite((uid, args.Sprite), baseLayer, component.MetamorphicDefaultSprite);
                     }
                 }
             }
         }
         else
         {
-            args.Sprite.LayerSetVisible(fillLayer, true);
+            _sprite.LayerSetVisible((uid, args.Sprite), fillLayer, true);
         }
 
         var closestFillSprite = ContentHelpers.RoundToLevels(fraction, 1, maxFillLevels + 1);
@@ -119,25 +120,25 @@ public sealed class SolutionContainerVisualsSystem : VisualizerSystem<SolutionCo
 
             var stateName = fillBaseName + closestFillSprite;
             if (fillSprite != null)
-                args.Sprite.LayerSetSprite(fillLayer, fillSprite);
-            args.Sprite.LayerSetState(fillLayer, stateName);
+                _sprite.LayerSetSprite((uid, args.Sprite), fillLayer, fillSprite);
+            _sprite.LayerSetRsiState((uid, args.Sprite), fillLayer, stateName);
 
             if (changeColor && AppearanceSystem.TryGetData<Color>(uid, SolutionContainerVisuals.Color, out var color, args.Component))
-                args.Sprite.LayerSetColor(fillLayer, color);
+                _sprite.LayerSetColor((uid, args.Sprite), fillLayer, color);
             else
-                args.Sprite.LayerSetColor(fillLayer, Color.White);
+                _sprite.LayerSetColor((uid, args.Sprite), fillLayer, Color.White);
         }
         else
         {
             if (component.EmptySpriteName == null)
-                args.Sprite.LayerSetVisible(fillLayer, false);
+                _sprite.LayerSetVisible((uid, args.Sprite), fillLayer, false);
             else
             {
-                args.Sprite.LayerSetState(fillLayer, component.EmptySpriteName);
+                _sprite.LayerSetRsiState((uid, args.Sprite), fillLayer, component.EmptySpriteName);
                 if (changeColor)
-                    args.Sprite.LayerSetColor(fillLayer, component.EmptySpriteColor);
+                    _sprite.LayerSetColor((uid, args.Sprite), fillLayer, component.EmptySpriteColor);
                 else
-                    args.Sprite.LayerSetColor(fillLayer, Color.White);
+                    _sprite.LayerSetColor((uid, args.Sprite), fillLayer, Color.White);
             }
         }
 

Content.Client/Chemistry/Visualizers/VaporVisualizerSystem.cs

@@ -52,7 +52,7 @@ public sealed class VaporVisualizerSystem : VisualizerSystem<VaporVisualsCompone
     {
         if (AppearanceSystem.TryGetData<Color>(uid, VaporVisuals.Color, out var color, args.Component) && args.Sprite != null)
         {
-            args.Sprite.Color = color;
+            SpriteSystem.SetColor((uid, args.Sprite), color);
         }
     }
 }

Content.Client/Clickable/ClickableSystem.cs

@@ -77,10 +77,10 @@ public sealed class ClickableSystem : EntitySystem
         drawDepth = sprite.DrawDepth;
         renderOrder = sprite.RenderOrder;
         var (spritePos, spriteRot) = _transforms.GetWorldPositionRotation(transform);
-        var spriteBB = sprite.CalculateRotatedBoundingBox(spritePos, spriteRot, eye.Rotation);
+        var spriteBB = _sprites.CalculateBounds((entity.Owner, sprite), spritePos, spriteRot, eye.Rotation);
         bottom = Matrix3Helpers.CreateRotation(eye.Rotation).TransformBox(spriteBB).Bottom;
 
-        Matrix3x2.Invert(sprite.GetLocalMatrix(), out var invSpriteMatrix);
+        Matrix3x2.Invert(sprite.LocalMatrix, out var invSpriteMatrix);
 
         // This should have been the rotation of the sprite relative to the screen, but this is not the case with no-rot or directional sprites.
         var relativeRotation = (spriteRot + eye.Rotation).Reduced().FlipPositive();
@@ -107,7 +107,7 @@ public sealed class ClickableSystem : EntitySystem
             if (layer.Texture != null)
             {
                 // Convert to image coordinates
-                var imagePos = (Vector2i) (localPos * EyeManager.PixelsPerMeter * new Vector2(1, -1) + layer.Texture.Size / 2f);
+                var imagePos = (Vector2i)(localPos * EyeManager.PixelsPerMeter * new Vector2(1, -1) + layer.Texture.Size / 2f);
 
                 if (_clickMapManager.IsOccluding(layer.Texture, imagePos))
                     return true;
@@ -125,7 +125,7 @@ public sealed class ClickableSystem : EntitySystem
             var layerLocal = Vector2.Transform(localPos, inverseMatrix);
 
             // Convert to image coordinates
-            var layerImagePos = (Vector2i) (layerLocal * EyeManager.PixelsPerMeter * new Vector2(1, -1) + rsiState.Size / 2f);
+            var layerImagePos = (Vector2i)(layerLocal * EyeManager.PixelsPerMeter * new Vector2(1, -1) + rsiState.Size / 2f);
 
             // Next, to get the right click map we need the "direction" of this layer that is actually being used to draw the sprite on the screen.
             // This **can** differ from the dir defined before, but can also just be the same.

Content.Client/Clock/ClockSystem.cs

@@ -5,6 +5,8 @@ namespace Content.Client.Clock;
 
 public sealed class ClockSystem : SharedClockSystem
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Update(float frameTime)
     {
         base.Update(frameTime);
@@ -12,15 +14,15 @@ public sealed class ClockSystem : SharedClockSystem
         var query = EntityQueryEnumerator<ClockComponent, SpriteComponent>();
         while (query.MoveNext(out var uid, out var comp, out var sprite))
         {
-            if (!sprite.LayerMapTryGet(ClockVisualLayers.HourHand, out var hourLayer) ||
-                !sprite.LayerMapTryGet(ClockVisualLayers.MinuteHand, out var minuteLayer))
+            if (!_sprite.LayerMapTryGet((uid, sprite), ClockVisualLayers.HourHand, out var hourLayer, false) ||
+                !_sprite.LayerMapTryGet((uid, sprite), ClockVisualLayers.MinuteHand, out var minuteLayer, false))
                 continue;
 
             var time = GetClockTime((uid, comp));
             var hourState = $"{comp.HoursBase}{time.Hours % 12}";
             var minuteState = $"{comp.MinutesBase}{time.Minutes / 5}";
-            sprite.LayerSetState(hourLayer, hourState);
-            sprite.LayerSetState(minuteLayer, minuteState);
+            _sprite.LayerSetRsiState((uid, sprite), hourLayer, hourState);
+            _sprite.LayerSetRsiState((uid, sprite), minuteLayer, minuteState);
         }
     }
 }

Content.Client/Clothing/ClientClothingSystem.cs

@@ -40,7 +40,7 @@ public sealed class ClientClothingSystem : ClothingSystem
         {Jumpsuit, "INNERCLOTHING"},
         {"neck", "NECK"},
         {"back", "BACKPACK"},
-        {"belt1", "BELT1"},
+        {"belt", "BELT"},
         {"belt2", "BELT2"},
         {"gloves", "HAND"},
         {"shoes", "FEET"},
@@ -48,8 +48,6 @@ public sealed class ClientClothingSystem : ClothingSystem
         {"pocket1", "POCKET1"},
         {"pocket2", "POCKET2"},
         {"suitstorage", "SUITSTORAGE"},
-        {"ring1", "RING1"},
-        {"ring2", "RING2"},
         {"pants", "PANTS"},
         {"shirt", "SHIRT"},
         {"cloak", "CLOAK"},
@@ -59,6 +57,7 @@ public sealed class ClientClothingSystem : ClothingSystem
     [Dependency] private readonly IResourceCache _cache = default!;
     [Dependency] private readonly InventorySystem _inventorySystem = default!;
     [Dependency] private readonly DisplacementMapSystem _displacement = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -81,10 +80,10 @@ public sealed class ClientClothingSystem : ClothingSystem
         UpdateAllSlots(uid, component);
 
         // No clothing equipped -> make sure the layer is hidden, though this should already be handled by on-unequip.
-        if (args.Sprite.LayerMapTryGet(HumanoidVisualLayers.StencilMask, out var layer))
+        if (_sprite.LayerMapTryGet((uid, args.Sprite), HumanoidVisualLayers.StencilMask, out var layer, false))
         {
             DebugTools.Assert(!args.Sprite[layer].Visible);
-            args.Sprite.LayerSetVisible(layer, false);
+            _sprite.LayerSetVisible((uid, args.Sprite), layer, false);
         }
     }
 
@@ -199,9 +198,9 @@ public sealed class ClientClothingSystem : ClothingSystem
         RenderEquipment(uid, item, clothing.InSlot, component, null, clothing);
     }
 
-    private void OnDidUnequip(EntityUid uid, SpriteComponent component, DidUnequipEvent args)
+    private void OnDidUnequip(Entity<SpriteComponent> entity, ref DidUnequipEvent args)
     {
-        if (!TryComp(uid, out InventorySlotsComponent? inventorySlots))
+        if (!TryComp(entity, out InventorySlotsComponent? inventorySlots))
             return;
 
         if (!inventorySlots.VisualLayerKeys.TryGetValue(args.Slot, out var revealedLayers))
@@ -211,7 +210,7 @@ public sealed class ClientClothingSystem : ClothingSystem
         // may eventually bloat the player with lots of invisible layers.
         foreach (var layer in revealedLayers)
         {
-            component.RemoveLayer(layer);
+            _sprite.RemoveLayer(entity.AsNullable(), layer);
         }
         revealedLayers.Clear();
     }
@@ -254,7 +253,7 @@ public sealed class ClientClothingSystem : ClothingSystem
         {
             foreach (var key in revealedLayers)
             {
-                sprite.RemoveLayer(key);
+                _sprite.RemoveLayer((equipee, sprite), key);
             }
             revealedLayers.Clear();
         }
@@ -275,7 +274,7 @@ public sealed class ClientClothingSystem : ClothingSystem
 
         // temporary, until layer draw depths get added. Basically: a layer with the key "slot" is being used as a
         // bookmark to determine where in the list of layers we should insert the clothing layers.
-        bool slotLayerExists = sprite.LayerMapTryGet(slot, out var index);
+        var slotLayerExists = _sprite.LayerMapTryGet((equipee, sprite), slot, out var index, false);
 
         // Select displacement maps
         var displacementData = inventory.Displacements.GetValueOrDefault(slot); //Default unsexed map
@@ -309,16 +308,16 @@ public sealed class ClientClothingSystem : ClothingSystem
             {
                 index++;
                 // note that every insertion requires reshuffling & remapping all the existing layers.
-                sprite.AddBlankLayer(index);
-                sprite.LayerMapSet(key, index);
+                _sprite.AddBlankLayer((equipee, sprite), index);
+                _sprite.LayerMapSet((equipee, sprite), key, index);
 
                 if (layerData.Color != null)
-                    sprite.LayerSetColor(key, layerData.Color.Value);
+                    _sprite.LayerSetColor((equipee, sprite), key, layerData.Color.Value);
                 if (layerData.Scale != null)
-                    sprite.LayerSetScale(key, layerData.Scale.Value);
+                    _sprite.LayerSetScale((equipee, sprite), key, layerData.Scale.Value);
             }
             else
-                index = sprite.LayerMapReserveBlank(key);
+                index = _sprite.LayerMapReserve((equipee, sprite), key);
 
             if (sprite[index] is not Layer layer)
                 continue;
@@ -329,11 +328,11 @@ public sealed class ClientClothingSystem : ClothingSystem
                 && layer.RSI == null
                 && TryComp(equipment, out SpriteComponent? clothingSprite))
             {
-                layer.SetRsi(clothingSprite.BaseRSI);
+                _sprite.LayerSetRsi(layer, clothingSprite.BaseRSI);
             }
 
-            sprite.LayerSetData(index, layerData);
-            layer.Offset += slotDef.Offset;
+            _sprite.LayerSetData((equipee, sprite), index, layerData);
+            _sprite.LayerSetOffset(layer, layer.Offset + slotDef.Offset);
 
             if (displacementData is not null)
             {
@@ -341,7 +340,7 @@ public sealed class ClientClothingSystem : ClothingSystem
                 if (layerData.State is not null && inventory.SpeciesId is not null && layerData.State.EndsWith(inventory.SpeciesId))
                     continue;
 
-                if (_displacement.TryAddDisplacement(displacementData, sprite, index, key, out var displacementKey))
+                if (_displacement.TryAddDisplacement(displacementData, (equipee, sprite), index, key, out var displacementKey))
                 {
                     revealedLayers.Add(displacementKey);
                     index++;

Content.Client/Clothing/FlippableClothingVisualizerSystem.cs

@@ -32,7 +32,7 @@ public sealed class FlippableClothingVisualizerSystem : VisualizerSystem<Flippab
 
         if (clothing.MappedLayer == null ||
             !AppearanceSystem.TryGetData<bool>(ent, FoldableSystem.FoldedVisuals.State, out var folding) ||
-            !sprite.LayerMapTryGet(folding ? ent.Comp.FoldingLayer : ent.Comp.UnfoldingLayer, out var idx))
+            !SpriteSystem.LayerMapTryGet((ent.Owner, sprite), folding ? ent.Comp.FoldingLayer : ent.Comp.UnfoldingLayer, out var idx, false))
             return;
 
         // add each layer to the visuals

Content.Client/Clothing/Systems/ChameleonClothingSystem.cs

@@ -12,7 +12,6 @@ namespace Content.Client.Clothing.Systems;
 public sealed class ChameleonClothingSystem : SharedChameleonClothingSystem
 {
     [Dependency] private readonly IPrototypeManager _proto = default!;
-    [Dependency] private readonly IComponentFactory _factory = default!;
 
     private static readonly SlotFlags[] IgnoredSlots =
     {
@@ -48,14 +47,14 @@ public sealed class ChameleonClothingSystem : SharedChameleonClothingSystem
     {
         base.UpdateSprite(uid, proto);
         if (TryComp(uid, out SpriteComponent? sprite)
-            && proto.TryGetComponent(out SpriteComponent? otherSprite, _factory))
+            && proto.TryGetComponent(out SpriteComponent? otherSprite, Factory))
         {
             sprite.CopyFrom(otherSprite);
         }
 
         // Edgecase for PDAs to include visuals when UI is open
         if (TryComp(uid, out PdaBorderColorComponent? borderColor)
-            && proto.TryGetComponent(out PdaBorderColorComponent? otherBorderColor, _factory))
+            && proto.TryGetComponent(out PdaBorderColorComponent? otherBorderColor, Factory))
         {
             borderColor.BorderColor = otherBorderColor.BorderColor;
             borderColor.AccentHColor = otherBorderColor.AccentHColor;
@@ -89,7 +88,7 @@ public sealed class ChameleonClothingSystem : SharedChameleonClothingSystem
             // check if this is valid clothing
             if (!IsValidTarget(proto))
                 continue;
-            if (!proto.TryGetComponent(out ClothingComponent? item, _factory))
+            if (!proto.TryGetComponent(out ClothingComponent? item, Factory))
                 continue;
 
             // sort item by their slot flags

Content.Client/Clothing/UI/ChameleonBoundUserInterface.cs

@@ -12,7 +12,6 @@ namespace Content.Client.Clothing.UI;
 [UsedImplicitly]
 public sealed class ChameleonBoundUserInterface : BoundUserInterface
 {
-    [Dependency] private readonly IComponentFactory _factory = default!;
     [Dependency] private readonly IPrototypeManager _proto = default!;
     private readonly ChameleonClothingSystem _chameleon;
     private readonly TagSystem _tag;
@@ -49,7 +48,7 @@ public sealed class ChameleonBoundUserInterface : BoundUserInterface
                 if (string.IsNullOrEmpty(target) || !_proto.TryIndex(target, out EntityPrototype? proto))
                     continue;
 
-                if (!proto.TryGetComponent(out TagComponent? tag, _factory) || !_tag.HasTag(tag, st.RequiredTag))
+                if (!proto.TryGetComponent(out TagComponent? tag, EntMan.ComponentFactory) || !_tag.HasTag(tag, st.RequiredTag))
                     continue;
 
                 newTargets.Add(target);

Content.Client/Commands/HideMechanismsCommand.cs

@@ -18,23 +18,19 @@ public sealed class HideMechanismsCommand : LocalizedCommands
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
         var containerSys = _entityManager.System<SharedContainerSystem>();
-        var query = _entityManager.AllEntityQueryEnumerator<OrganComponent>();
+        var spriteSys = _entityManager.System<SpriteSystem>();
+        var query = _entityManager.AllEntityQueryEnumerator<OrganComponent, SpriteComponent>();
 
-        while (query.MoveNext(out var uid, out _))
+        while (query.MoveNext(out var uid, out _, out var sprite))
         {
-            if (!_entityManager.TryGetComponent(uid, out SpriteComponent? sprite))
-            {
-                continue;
-            }
-
-            sprite.ContainerOccluded = false;
+            spriteSys.SetContainerOccluded((uid, sprite), false);
 
             var tempParent = uid;
             while (containerSys.TryGetContainingContainer((tempParent, null, null), out var container))
             {
                 if (!container.ShowContents)
                 {
-                    sprite.ContainerOccluded = true;
+                    spriteSys.SetContainerOccluded((uid, sprite), true);
                     break;
                 }
 

Content.Client/Commands/ShowMechanismsCommand.cs

@@ -16,11 +16,12 @@ public sealed class ShowMechanismsCommand : LocalizedCommands
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
+        var spriteSys = _entManager.System<SpriteSystem>();
         var query = _entManager.AllEntityQueryEnumerator<OrganComponent, SpriteComponent>();
 
-        while (query.MoveNext(out _, out var sprite))
+        while (query.MoveNext(out var uid, out _, out var sprite))
         {
-            sprite.ContainerOccluded = false;
+            spriteSys.SetContainerOccluded((uid, sprite), false);
         }
     }
 }

Content.Client/Construction/ConstructionPlacementHijack.cs

@@ -1,8 +1,10 @@
 using System.Linq;
 using Content.Shared.Construction.Prototypes;
+using Robust.Client.GameObjects;
 using Robust.Client.Placement;
-using Robust.Client.Utility;
+using Robust.Client.ResourceManagement;
 using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
 
 namespace Content.Client.Construction
 {
@@ -45,7 +47,14 @@ namespace Content.Client.Construction
         public override void StartHijack(PlacementManager manager)
         {
             base.StartHijack(manager);
-            manager.CurrentTextures = _prototype?.Layers.Select(sprite => sprite.DirFrame0()).ToList();
+
+            if (_prototype is null || !_constructionSystem.TryGetRecipePrototype(_prototype.ID, out var targetProtoId))
+                return;
+
+            if (!IoCManager.Resolve<IPrototypeManager>().TryIndex(targetProtoId, out EntityPrototype? proto))
+                return;
+
+            manager.CurrentTextures = SpriteComponent.GetPrototypeTextures(proto, IoCManager.Resolve<IResourceCache>()).ToList();
         }
     }
 }

Content.Client/Construction/ConstructionSystem.cs

@@ -1,11 +1,10 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Content.Client.Popups;
 using Content.Shared.Construction;
 using Content.Shared.Construction.Prototypes;
-using Content.Shared.Construction.Steps;
 using Content.Shared.Examine;
 using Content.Shared.Input;
-using Content.Shared.Interaction;
 using Content.Shared.Wall;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
@@ -15,6 +14,7 @@ using Robust.Shared.Input.Binding;
 using Robust.Shared.Map;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Construction
 {
@@ -25,14 +25,16 @@ namespace Content.Client.Construction
     public sealed class ConstructionSystem : SharedConstructionSystem
     {
         [Dependency] private readonly IPlayerManager _playerManager = default!;
-        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly ExamineSystemShared _examineSystem = default!;
         [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
+        [Dependency] private readonly SpriteSystem _sprite = default!;
         [Dependency] private readonly PopupSystem _popupSystem = default!;
 
         private readonly Dictionary<int, EntityUid> _ghosts = new();
         private readonly Dictionary<string, ConstructionGuide> _guideCache = new();
 
+        private readonly Dictionary<string, string> _recipesMetadataCache = [];
+
         public bool CraftingEnabled { get; private set; }
 
         /// <inheritdoc />
@@ -40,6 +42,8 @@ namespace Content.Client.Construction
         {
             base.Initialize();
 
+            WarmupRecipesCache();
+
             UpdatesOutsidePrediction = true;
             SubscribeLocalEvent<LocalPlayerAttachedEvent>(HandlePlayerAttached);
             SubscribeNetworkEvent<AckStructureConstructionMessage>(HandleAckStructure);
@@ -63,6 +67,77 @@ namespace Content.Client.Construction
             ClearGhost(component.GhostId);
         }
 
+        public bool TryGetRecipePrototype(string constructionProtoId, [NotNullWhen(true)] out string? targetProtoId)
+        {
+            if (_recipesMetadataCache.TryGetValue(constructionProtoId, out targetProtoId))
+                return true;
+
+            targetProtoId = null;
+            return false;
+        }
+
+        private void WarmupRecipesCache()
+        {
+            foreach (var constructionProto in PrototypeManager.EnumeratePrototypes<ConstructionPrototype>())
+            {
+                if (!PrototypeManager.TryIndex(constructionProto.Graph, out var graphProto))
+                    continue;
+
+                if (constructionProto.TargetNode is not { } targetNodeId)
+                    continue;
+
+                if (!graphProto.Nodes.TryGetValue(targetNodeId, out var targetNode))
+                    continue;
+
+                // Recursion is for wimps.
+                var stack = new Stack<ConstructionGraphNode>();
+                stack.Push(targetNode);
+
+                do
+                {
+                    var node = stack.Pop();
+
+                    // I never realized if this uid affects anything...
+                    // EntityUid? userUid = args.SenderSession.State.ControlledEntity.HasValue
+                    //     ? GetEntity(args.SenderSession.State.ControlledEntity.Value)
+                    //     : null;
+
+                    // We try to get the id of the target prototype, if it fails, we try going through the edges.
+                    if (node.Entity.GetId(null, null, new(EntityManager)) is not { } entityId)
+                    {
+                        // If the stack is not empty, there is a high probability that the loop will go to infinity.
+                        if (stack.Count == 0)
+                        {
+                            foreach (var edge in node.Edges)
+                            {
+                                if (graphProto.Nodes.TryGetValue(edge.Target, out var graphNode))
+                                    stack.Push(graphNode);
+                            }
+                        }
+
+                        continue;
+                    }
+
+                    // If we got the id of the prototype, we exit the “recursion” by clearing the stack.
+                    stack.Clear();
+
+                    if (!PrototypeManager.TryIndex(constructionProto.ID, out ConstructionPrototype? recipe))
+                        continue;
+
+                    if (!PrototypeManager.TryIndex(entityId, out var proto))
+                        continue;
+
+                    var name = recipe.SetName.HasValue ? Loc.GetString(recipe.SetName) : proto.Name;
+                    var desc = recipe.SetDescription.HasValue ? Loc.GetString(recipe.SetDescription) : proto.Description;
+
+                    recipe.Name = name;
+                    recipe.Description = desc;
+
+                    _recipesMetadataCache.Add(constructionProto.ID, entityId);
+                } while (stack.Count > 0);
+            }
+        }
+
         private void OnConstructionGuideReceived(ResponseConstructionGuide ev)
         {
             _guideCache[ev.ConstructionId] = ev.Guide;
@@ -88,7 +163,7 @@ namespace Content.Client.Construction
 
         private void HandleConstructionGhostExamined(EntityUid uid, ConstructionGhostComponent component, ExaminedEvent args)
         {
-            if (component.Prototype == null)
+            if (component.Prototype?.Name is null)
                 return;
 
             using (args.PushGroup(nameof(ConstructionGhostComponent)))
@@ -97,7 +172,7 @@ namespace Content.Client.Construction
                     "construction-ghost-examine-message",
                     ("name", component.Prototype.Name)));
 
-                if (!_prototypeManager.TryIndex(component.Prototype.Graph, out ConstructionGraphPrototype? graph))
+                if (!PrototypeManager.TryIndex(component.Prototype.Graph, out var graph))
                     return;
 
                 var startNode = graph.Nodes[component.Prototype.StartNode];
@@ -198,6 +273,9 @@ namespace Content.Client.Construction
                 return false;
             }
 
+            if (!TryGetRecipePrototype(prototype.ID, out var targetProtoId) || !PrototypeManager.TryIndex(targetProtoId, out EntityPrototype? targetProto))
+                return false;
+
             if (GhostPresent(loc))
                 return false;
 
@@ -214,16 +292,43 @@ namespace Content.Client.Construction
             comp.GhostId = ghost.GetHashCode();
             EntityManager.GetComponent<TransformComponent>(ghost.Value).LocalRotation = dir.ToAngle();
             _ghosts.Add(comp.GhostId, ghost.Value);
-            var sprite = EntityManager.GetComponent<SpriteComponent>(ghost.Value);
-            sprite.Color = new Color(48, 255, 48, 128);
 
-            for (int i = 0; i < prototype.Layers.Count; i++)
+            var sprite = EntityManager.GetComponent<SpriteComponent>(ghost.Value);
+            _sprite.SetColor((ghost.Value, sprite), new Color(48, 255, 48, 128));
+
+            if (targetProto.TryGetComponent(out IconComponent? icon, EntityManager.ComponentFactory))
             {
-                sprite.AddBlankLayer(i); // There is no way to actually check if this already exists, so we blindly insert a new one
-                sprite.LayerSetSprite(i, prototype.Layers[i]);
-                sprite.LayerSetShader(i, "unshaded");
-                sprite.LayerSetVisible(i, true);
+                _sprite.AddBlankLayer((ghost.Value, sprite), 0);
+                _sprite.LayerSetSprite((ghost.Value, sprite), 0, icon.Icon);
+                sprite.LayerSetShader(0, "unshaded");
+                _sprite.LayerSetVisible((ghost.Value, sprite), 0, true);
             }
+            else if (targetProto.Components.TryGetValue("Sprite", out _))
+            {
+                var dummy = EntityManager.SpawnEntity(targetProtoId, MapCoordinates.Nullspace);
+                var targetSprite = EntityManager.EnsureComponent<SpriteComponent>(dummy);
+                EntityManager.System<AppearanceSystem>().OnChangeData(dummy, targetSprite);
+
+                for (var i = 0; i < targetSprite.AllLayers.Count(); i++)
+                {
+                    if (!targetSprite[i].Visible || !targetSprite[i].RsiState.IsValid)
+                        continue;
+
+                    var rsi = targetSprite[i].Rsi ?? targetSprite.BaseRSI;
+                    if (rsi is null || !rsi.TryGetState(targetSprite[i].RsiState, out var state) ||
+                        state.StateId.Name is null)
+                        continue;
+
+                    _sprite.AddBlankLayer((ghost.Value, sprite), i);
+                    _sprite.LayerSetSprite((ghost.Value, sprite), i, new SpriteSpecifier.Rsi(rsi.Path, state.StateId.Name));
+                    sprite.LayerSetShader(i, "unshaded");
+                    _sprite.LayerSetVisible((ghost.Value, sprite), i, true);
+                }
+
+                EntityManager.DeleteEntity(dummy);
+            }
+            else
+                return false;
 
             if (prototype.CanBuildInImpassable)
                 EnsureComp<WallMountComponent>(ghost.Value).Arc = new(Math.Tau);

Content.Client/Construction/FlatpackSystem.cs

@@ -9,6 +9,7 @@ namespace Content.Client.Construction;
 public sealed class FlatpackSystem : SharedFlatpackSystem
 {
     [Dependency] private readonly AppearanceSystem _appearance = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     /// <inheritdoc/>
     public override void Initialize()
@@ -43,6 +44,6 @@ public sealed class FlatpackSystem : SharedFlatpackSystem
         }
 
         if (color != null)
-            args.Sprite.LayerSetColor(FlatpackVisualLayers.Overlay, color.Value);
+            _sprite.LayerSetColor((ent.Owner, args.Sprite), FlatpackVisualLayers.Overlay, color.Value);
     }
 }

Content.Client/Construction/UI/ConstructionMenu.xaml

@@ -1,11 +1,12 @@
-<DefaultWindow xmlns="https://spacestation14.io">
+<DefaultWindow xmlns="https://spacestation14.io"
+               xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls">
     <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
         <BoxContainer Orientation="Vertical" MinWidth="243" Margin="0 0 5 0">
             <BoxContainer Orientation="Horizontal" HorizontalExpand="True" Margin="0 0 0 5">
-                <LineEdit Name="SearchBar" PlaceHolder="Search" HorizontalExpand="True"/>
+                <LineEdit Name="SearchBar" PlaceHolder="{Loc 'construction-menu-search'}" HorizontalExpand="True"/>
                 <OptionButton Name="OptionCategories" Access="Public" MinSize="130 0"/>
             </BoxContainer>
-            <ItemList Name="Recipes" Access="Public" SelectMode="Single" VerticalExpand="True"/>
+            <controls:ListContainer Name="Recipes" Access="Public" Group="True" Toggle="True" VerticalExpand="True" />
             <ScrollContainer Name="RecipesGridScrollContainer" VerticalExpand="True" Access="Public" Visible="False">
                 <GridContainer Name="RecipesGrid" Columns="5" Access="Public"/>
             </ScrollContainer>
@@ -18,7 +19,7 @@
             <Control>
                 <BoxContainer Orientation="Vertical" HorizontalExpand="True" Margin="0 0 0 5">
                     <BoxContainer Orientation="Horizontal" Align="Center">
-                        <TextureRect Name="TargetTexture" HorizontalAlignment="Right" Stretch="Keep" Margin="0 0 10 0"/>
+                        <EntityPrototypeView Name="TargetTexture" HorizontalAlignment="Right" Stretch="Fill" Margin="0 0 10 0"/>
                         <BoxContainer Orientation="Vertical">
                             <RichTextLabel Name="TargetName"/>
                             <RichTextLabel Name="TargetDesc"/>

Content.Client/Construction/UI/ConstructionMenu.xaml.cs

@@ -1,14 +1,11 @@
-using System;
 using System.Numerics;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Construction.Prototypes;
 using Robust.Client.AutoGenerated;
-using Robust.Client.Graphics;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
-using Robust.Shared.Graphics;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-
+using Robust.Shared.Prototypes;
 
 namespace Content.Client.Construction.UI
 {
@@ -28,7 +25,7 @@ namespace Content.Client.Construction.UI
         bool GridViewButtonPressed { get; set; }
         bool BuildButtonPressed { get; set; }
 
-        ItemList Recipes { get; }
+        ListContainer Recipes { get; }
         ItemList RecipeStepList { get; }
 
 
@@ -36,14 +33,14 @@ namespace Content.Client.Construction.UI
         GridContainer RecipesGrid { get; }
 
         event EventHandler<(string search, string catagory)> PopulateRecipes;
-        event EventHandler<ItemList.Item?> RecipeSelected;
+        event EventHandler<ConstructionMenu.ConstructionMenuListData?> RecipeSelected;
         event EventHandler RecipeFavorited;
         event EventHandler<bool> BuildButtonToggled;
         event EventHandler<bool> EraseButtonToggled;
         event EventHandler ClearAllGhosts;
 
         void ClearRecipeInfo();
-        void SetRecipeInfo(string name, string description, Texture iconTexture, bool isItem, bool isFavorite);
+        void SetRecipeInfo(string name, string description, EntityPrototype? targetPrototype, bool isItem, bool isFavorite);
         void ResetPlacement();
 
         #region Window Control
@@ -94,8 +91,36 @@ namespace Content.Client.Construction.UI
             Title = Loc.GetString("construction-menu-title");
 
             BuildButton.Text = Loc.GetString("construction-menu-place-ghost");
-            Recipes.OnItemSelected += obj => RecipeSelected?.Invoke(this, obj.ItemList[obj.ItemIndex]);
-            Recipes.OnItemDeselected += _ => RecipeSelected?.Invoke(this, null);
+            Recipes.ItemPressed += (_, data) => RecipeSelected?.Invoke(this, data as ConstructionMenuListData);
+            Recipes.NoItemSelected += () => RecipeSelected?.Invoke(this, null);
+            Recipes.GenerateItem += (data, button) =>
+            {
+                if (data is not ConstructionMenuListData (var prototype, var targetPrototype))
+                    return;
+
+                var entProtoView = new EntityPrototypeView()
+                {
+                    SetSize = new(32f),
+                    Stretch = SpriteView.StretchMode.Fill,
+                    Scale = new(2),
+                    Margin = new(0, 2),
+                };
+                entProtoView.SetPrototype(targetPrototype);
+
+                var label = new Label()
+                {
+                    Text = prototype.Name,
+                    Margin = new(5, 0),
+                };
+
+                var box = new BoxContainer();
+                box.AddChild(entProtoView);
+                box.AddChild(label);
+
+                button.AddChild(box);
+                button.ToolTip = prototype.Description;
+                button.AddStyleClass(ListContainer.StyleClassListContainerButton);
+            };
 
             SearchBar.OnTextChanged += _ =>
                 PopulateRecipes?.Invoke(this, (SearchBar.Text, Categories[OptionCategories.SelectedId]));
@@ -121,7 +146,7 @@ namespace Content.Client.Construction.UI
 
         public event EventHandler? ClearAllGhosts;
         public event EventHandler<(string search, string catagory)>? PopulateRecipes;
-        public event EventHandler<ItemList.Item?>? RecipeSelected;
+        public event EventHandler<ConstructionMenuListData?>? RecipeSelected;
         public event EventHandler? RecipeFavorited;
         public event EventHandler<bool>? BuildButtonToggled;
         public event EventHandler<bool>? EraseButtonToggled;
@@ -133,13 +158,17 @@ namespace Content.Client.Construction.UI
         }
 
         public void SetRecipeInfo(
-            string name, string description, Texture iconTexture, bool isItem, bool isFavorite)
+            string name,
+            string description,
+            EntityPrototype? targetPrototype,
+            bool isItem,
+            bool isFavorite)
         {
             BuildButton.Disabled = false;
             BuildButton.Text = Loc.GetString(isItem ? "construction-menu-place-ghost" : "construction-menu-craft");
             TargetName.SetMessage(name);
             TargetDesc.SetMessage(description);
-            TargetTexture.Texture = iconTexture;
+            TargetTexture.SetPrototype(targetPrototype?.ID);
             FavoriteButton.Visible = true;
             FavoriteButton.Text = Loc.GetString(
                             isFavorite ? "construction-add-favorite-button" : "construction-remove-from-favorite-button");
@@ -150,9 +179,11 @@ namespace Content.Client.Construction.UI
             BuildButton.Disabled = true;
             TargetName.SetMessage(string.Empty);
             TargetDesc.SetMessage(string.Empty);
-            TargetTexture.Texture = null;
+            TargetTexture.SetPrototype(null);
             FavoriteButton.Visible = false;
             RecipeStepList.Clear();
         }
+
+        public sealed record ConstructionMenuListData(ConstructionPrototype Prototype, EntityPrototype TargetPrototype) : ListData;
     }
 }

Content.Client/Construction/UI/ConstructionMenuPresenter.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using System.Numerics;
+using Content.Client.Lobby;
 using Content.Client.Stylesheets;
 using Content.Client.UserInterface.Systems.MenuBar.Widgets;
 using Content.Shared.Construction.Prototypes;
@@ -10,10 +11,8 @@ using Robust.Client.Placement;
 using Robust.Client.Player;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
-using Robust.Client.Utility;
 using Robust.Shared.Enums;
 using Robust.Shared.Prototypes;
-using static Robust.Client.UserInterface.Controls.BaseButton;
 
 namespace Content.Client.Construction.UI
 {
@@ -30,18 +29,21 @@ namespace Content.Client.Construction.UI
         [Dependency] private readonly IPlacementManager _placementManager = default!;
         [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly IClientPreferencesManager _preferencesManager = default!;
+        private readonly SpriteSystem _spriteSystem;
 
         private readonly IConstructionMenuView _constructionView;
         private readonly EntityWhitelistSystem _whitelistSystem;
-        private readonly SpriteSystem _spriteSystem;
 
         private ConstructionSystem? _constructionSystem;
         private ConstructionPrototype? _selected;
         private List<ConstructionPrototype> _favoritedRecipes = [];
-        private Dictionary<string, TextureButton> _recipeButtons = new();
+        private Dictionary<string, ContainerButton> _recipeButtons = new();
         private string _selectedCategory = string.Empty;
-        private string _favoriteCatName = "construction-category-favorites";
-        private string _forAllCategoryName = "construction-category-all";
+
+        private const string FavoriteCatName = "construction-category-favorites";
+        private const string ForAllCategoryName = "construction-category-all";
+
         private bool CraftingAvailable
         {
             get => _uiManager.GetActiveUIWidget<GameTopMenuBar>().CraftingButton.Visible;
@@ -98,26 +100,29 @@ namespace Content.Client.Construction.UI
 
             _placementManager.PlacementChanged += OnPlacementChanged;
 
-            _constructionView.OnClose += () => _uiManager.GetActiveUIWidget<GameTopMenuBar>().CraftingButton.Pressed = false;
+            _constructionView.OnClose +=
+                () => _uiManager.GetActiveUIWidget<GameTopMenuBar>().CraftingButton.Pressed = false;
             _constructionView.ClearAllGhosts += (_, _) => _constructionSystem?.ClearAllGhosts();
             _constructionView.PopulateRecipes += OnViewPopulateRecipes;
             _constructionView.RecipeSelected += OnViewRecipeSelected;
             _constructionView.BuildButtonToggled += (_, b) => BuildButtonToggled(b);
             _constructionView.EraseButtonToggled += (_, b) =>
             {
-                if (_constructionSystem is null) return;
-                if (b) _placementManager.Clear();
+                if (_constructionSystem is null)
+                    return;
+                if (b)
+                    _placementManager.Clear();
                 _placementManager.ToggleEraserHijacked(new ConstructionPlacementHijack(_constructionSystem, null));
                 _constructionView.EraseButtonPressed = b;
             };
 
             _constructionView.RecipeFavorited += (_, _) => OnViewFavoriteRecipe();
 
-            PopulateCategories();
+            SetFavorites(_preferencesManager.Preferences?.ConstructionFavorites ?? []);
             OnViewPopulateRecipes(_constructionView, (string.Empty, string.Empty));
         }
 
-        public void OnHudCraftingButtonToggled(ButtonToggledEventArgs args)
+        public void OnHudCraftingButtonToggled(BaseButton.ButtonToggledEventArgs args)
         {
             WindowOpen = args.Pressed;
         }
@@ -139,7 +144,7 @@ namespace Content.Client.Construction.UI
             _constructionView.ResetPlacement();
         }
 
-        private void OnViewRecipeSelected(object? sender, ItemList.Item? item)
+        private void OnViewRecipeSelected(object? sender, ConstructionMenu.ConstructionMenuListData? item)
         {
             if (item is null)
             {
@@ -148,12 +153,15 @@ namespace Content.Client.Construction.UI
                 return;
             }
 
-            _selected = (ConstructionPrototype) item.Metadata!;
-            if (_placementManager.IsActive && !_placementManager.Eraser) UpdateGhostPlacement();
+            _selected = item.Prototype;
+
+            if (_placementManager is { IsActive: true, Eraser: false })
+                UpdateGhostPlacement();
+
             PopulateInfo(_selected);
         }
 
-        private void OnGridViewRecipeSelected(object? sender, ConstructionPrototype? recipe)
+        private void OnGridViewRecipeSelected(object? _, ConstructionPrototype? recipe)
         {
             if (recipe is null)
             {
@@ -163,65 +171,21 @@ namespace Content.Client.Construction.UI
             }
 
             _selected = recipe;
-            if (_placementManager.IsActive && !_placementManager.Eraser) UpdateGhostPlacement();
+
+            if (_placementManager is { IsActive: true, Eraser: false })
+                UpdateGhostPlacement();
+
             PopulateInfo(_selected);
         }
 
         private void OnViewPopulateRecipes(object? sender, (string search, string catagory) args)
         {
-            var (search, category) = args;
+            if (_constructionSystem is null)
+                return;
 
-            var recipes = new List<ConstructionPrototype>();
-
-            var isEmptyCategory = string.IsNullOrEmpty(category) || category == _forAllCategoryName;
-
-            if (isEmptyCategory)
-                _selectedCategory = string.Empty;
-            else
-                _selectedCategory = category;
-
-            foreach (var recipe in _prototypeManager.EnumeratePrototypes<ConstructionPrototype>())
-            {
-                if (recipe.Hide)
-                    continue;
-
-                if (!recipe.CrystallPunkAllowed) //CrystallEdge clearing recipes
-                    continue;
-
-                if (_playerManager.LocalSession == null
-                || _playerManager.LocalEntity == null
-                || _whitelistSystem.IsWhitelistFail(recipe.EntityWhitelist, _playerManager.LocalEntity.Value))
-                    continue;
-
-                if (!string.IsNullOrEmpty(search))
-                {
-                    if (!recipe.Name.ToLowerInvariant().Contains(search.Trim().ToLowerInvariant()))
-                        continue;
-                }
-
-                if (!isEmptyCategory)
-                {
-                    if (category == _favoriteCatName)
-                    {
-                        if (!_favoritedRecipes.Contains(recipe))
-                        {
-                            continue;
-                        }
-                    }
-                    else if (recipe.Category != category)
-                    {
-                        continue;
-                    }
-                }
-
-                recipes.Add(recipe);
-            }
-
-            recipes.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.InvariantCulture));
+            var actualRecipes = GetAndSortRecipes(args);
 
             var recipesList = _constructionView.Recipes;
-            recipesList.Clear();
-
             var recipesGrid = _constructionView.RecipesGrid;
             recipesGrid.RemoveAllChildren();
 
@@ -230,60 +194,123 @@ namespace Content.Client.Construction.UI
 
             if (_constructionView.GridViewButtonPressed)
             {
-                foreach (var recipe in recipes)
-                {
-                    var itemButton = new TextureButton
-                    {
-                        TextureNormal = _spriteSystem.Frame0(recipe.Icon),
-                        VerticalAlignment = Control.VAlignment.Center,
-                        Name = recipe.Name,
-                        ToolTip = recipe.Name,
-                        Scale = new Vector2(1.35f),
-                        ToggleMode = true,
-                    };
-                    var itemButtonPanelContainer = new PanelContainer
-                    {
-                        PanelOverride = new StyleBoxFlat { BackgroundColor = StyleNano.ButtonColorDefault },
-                        Children = { itemButton },
-                    };
-
-                    itemButton.OnToggled += buttonToggledEventArgs =>
-                    {
-                        SelectGridButton(itemButton, buttonToggledEventArgs.Pressed);
-
-                        if (buttonToggledEventArgs.Pressed &&
-                            _selected != null &&
-                            _recipeButtons.TryGetValue(_selected.Name, out var oldButton))
-                        {
-                            oldButton.Pressed = false;
-                            SelectGridButton(oldButton, false);
-                        }
-
-                        OnGridViewRecipeSelected(this, buttonToggledEventArgs.Pressed ? recipe : null);
-                    };
-
-                    recipesGrid.AddChild(itemButtonPanelContainer);
-                    _recipeButtons[recipe.Name] = itemButton;
-                    var isCurrentButtonSelected = _selected == recipe;
-                    itemButton.Pressed = isCurrentButtonSelected;
-                    SelectGridButton(itemButton, isCurrentButtonSelected);
-                }
+                recipesList.PopulateList([]);
+                PopulateGrid(recipesGrid, actualRecipes);
             }
             else
             {
-                foreach (var recipe in recipes)
-                {
-                    recipesList.Add(GetItem(recipe, recipesList));
-                }
+                recipesList.PopulateList(actualRecipes);
             }
         }
 
-        private void SelectGridButton(TextureButton button, bool select)
+        private void PopulateGrid(GridContainer recipesGrid,
+            IEnumerable<ConstructionMenu.ConstructionMenuListData> actualRecipes)
+        {
+            foreach (var recipe in actualRecipes)
+            {
+                var protoView = new EntityPrototypeView()
+                {
+                    Scale = new Vector2(1.2f),
+                };
+                protoView.SetPrototype(recipe.TargetPrototype);
+
+                var itemButton = new ContainerButton()
+                {
+                    VerticalAlignment = Control.VAlignment.Center,
+                    Name = recipe.TargetPrototype.Name,
+                    ToolTip = recipe.TargetPrototype.Name,
+                    ToggleMode = true,
+                    Children = { protoView },
+                };
+
+                var itemButtonPanelContainer = new PanelContainer
+                {
+                    PanelOverride = new StyleBoxFlat { BackgroundColor = StyleNano.ButtonColorDefault },
+                    Children = { itemButton },
+                };
+
+                itemButton.OnToggled += buttonToggledEventArgs =>
+                {
+                    SelectGridButton(itemButton, buttonToggledEventArgs.Pressed);
+
+                    if (buttonToggledEventArgs.Pressed &&
+                        _selected != null &&
+                        _recipeButtons.TryGetValue(_selected.Name!, out var oldButton))
+                    {
+                        oldButton.Pressed = false;
+                        SelectGridButton(oldButton, false);
+                    }
+
+                    OnGridViewRecipeSelected(this, buttonToggledEventArgs.Pressed ? recipe.Prototype : null);
+                };
+
+                recipesGrid.AddChild(itemButtonPanelContainer);
+                _recipeButtons[recipe.Prototype.Name!] = itemButton;
+                var isCurrentButtonSelected = _selected == recipe.Prototype;
+                itemButton.Pressed = isCurrentButtonSelected;
+                SelectGridButton(itemButton, isCurrentButtonSelected);
+            }
+        }
+
+        private List<ConstructionMenu.ConstructionMenuListData> GetAndSortRecipes((string, string) args)
+        {
+            var recipes = new List<ConstructionMenu.ConstructionMenuListData>();
+
+            var (search, category) = args;
+            var isEmptyCategory = string.IsNullOrEmpty(category) || category == ForAllCategoryName;
+            _selectedCategory = isEmptyCategory ? string.Empty : category;
+
+            foreach (var recipe in _prototypeManager.EnumeratePrototypes<ConstructionPrototype>())
+            {
+                if (!recipe.CrystallPunkAllowed) //CrystallEdge filter vanilla recipes
+                    continue;
+
+                if (recipe.Hide)
+                    continue;
+
+                if (_playerManager.LocalSession == null
+                    || _playerManager.LocalEntity == null
+                    || _whitelistSystem.IsWhitelistFail(recipe.EntityWhitelist, _playerManager.LocalEntity.Value))
+                    continue;
+
+                if (!string.IsNullOrEmpty(search) && (recipe.Name is { } name &&
+                                                      !name.Contains(search.Trim(),
+                                                          StringComparison.InvariantCultureIgnoreCase)))
+                    continue;
+
+                if (!isEmptyCategory)
+                {
+                    if ((category != FavoriteCatName || !_favoritedRecipes.Contains(recipe)) &&
+                        recipe.Category != category)
+                        continue;
+                }
+
+                if (!_constructionSystem!.TryGetRecipePrototype(recipe.ID, out var targetProtoId))
+                {
+                    Logger.Error("Cannot find the target prototype in the recipe cache with the id \"{0}\" of {1}.",
+                        recipe.ID,
+                        nameof(ConstructionPrototype));
+                    continue;
+                }
+
+                if (!_prototypeManager.TryIndex(targetProtoId, out EntityPrototype? proto))
+                    continue;
+
+                recipes.Add(new(recipe, proto));
+            }
+
+            recipes.Sort(
+                (a, b) => string.Compare(a.Prototype.Name, b.Prototype.Name, StringComparison.InvariantCulture));
+
+            return recipes;
+        }
+
+        private void SelectGridButton(BaseButton button, bool select)
         {
             if (button.Parent is not PanelContainer buttonPanel)
                 return;
 
-            button.Modulate = select ? Color.Green : Color.White;
+            button.Modulate = select ? Color.Green : Color.Transparent;
             var buttonColor = select ? StyleNano.ButtonColorDefault : Color.Transparent;
             buttonPanel.PanelOverride = new StyleBoxFlat { BackgroundColor = buttonColor };
         }
@@ -305,12 +332,12 @@ namespace Content.Client.Construction.UI
 
             // hard-coded to show all recipes
             var idx = 0;
-            categoriesArray[idx++] = _forAllCategoryName;
+            categoriesArray[idx++] = ForAllCategoryName;
 
             // hard-coded to show favorites if it need
             if (isFavorites)
             {
-                categoriesArray[idx++] = _favoriteCatName;
+                categoriesArray[idx++] = FavoriteCatName;
             }
 
             var sortedProtoCategories = uniqueCategories.OrderBy(Loc.GetString);
@@ -328,18 +355,31 @@ namespace Content.Client.Construction.UI
 
                 if (!string.IsNullOrEmpty(selectCategory) && selectCategory == categoriesArray[i])
                     _constructionView.OptionCategories.SelectId(i);
-
             }
 
             _constructionView.Categories = categoriesArray;
         }
 
-        private void PopulateInfo(ConstructionPrototype prototype)
+        private void PopulateInfo(ConstructionPrototype? prototype)
         {
+            if (_constructionSystem is null)
+                return;
+
             _constructionView.ClearRecipeInfo();
 
+            if (prototype is null)
+                return;
+
+            if (!_constructionSystem.TryGetRecipePrototype(prototype.ID, out var targetProtoId))
+                return;
+
+            if (!_prototypeManager.TryIndex(targetProtoId, out EntityPrototype? proto))
+                return;
+
             _constructionView.SetRecipeInfo(
-                prototype.Name, prototype.Description, _spriteSystem.Frame0(prototype.Icon),
+                prototype.Name!,
+                prototype.Description!,
+                proto,
                 prototype.Type != ConstructionType.Item,
                 !_favoritedRecipes.Contains(prototype));
 
@@ -352,16 +392,17 @@ namespace Content.Client.Construction.UI
             if (_constructionSystem?.GetGuide(prototype) is not { } guide)
                 return;
 
-
             foreach (var entry in guide.Entries)
             {
                 var text = entry.Arguments != null
-                    ? Loc.GetString(entry.Localization, entry.Arguments) : Loc.GetString(entry.Localization);
+                    ? Loc.GetString(entry.Localization, entry.Arguments)
+                    : Loc.GetString(entry.Localization);
 
                 if (entry.EntryNumber is { } number)
                 {
                     text = Loc.GetString("construction-presenter-step-wrapper",
-                        ("step-number", number), ("text", text));
+                        ("step-number", number),
+                        ("text", text));
                 }
 
                 // The padding needs to be applied regardless of text length... (See PadLeft documentation)
@@ -372,23 +413,12 @@ namespace Content.Client.Construction.UI
             }
         }
 
-        private ItemList.Item GetItem(ConstructionPrototype recipe, ItemList itemList)
-        {
-            return new(itemList)
-            {
-                Metadata = recipe,
-                Text = recipe.Name,
-                Icon = _spriteSystem.Frame0(recipe.Icon),
-                TooltipEnabled = true,
-                TooltipText = recipe.Description,
-            };
-        }
-
         private void BuildButtonToggled(bool pressed)
         {
             if (pressed)
             {
-                if (_selected == null) return;
+                if (_selected == null)
+                    return;
 
                 // not bound to a construction system
                 if (_constructionSystem is null)
@@ -405,10 +435,11 @@ namespace Content.Client.Construction.UI
                 }
 
                 _placementManager.BeginPlacing(new PlacementInformation
-                {
-                    IsTile = false,
-                    PlacementOption = _selected.PlacementMode
-                }, new ConstructionPlacementHijack(_constructionSystem, _selected));
+                    {
+                        IsTile = false,
+                        PlacementOption = _selected.PlacementMode
+                    },
+                    new ConstructionPlacementHijack(_constructionSystem, _selected));
 
                 UpdateGhostPlacement();
             }
@@ -432,44 +463,69 @@ namespace Content.Client.Construction.UI
             var constructSystem = _systemManager.GetEntitySystem<ConstructionSystem>();
 
             _placementManager.BeginPlacing(new PlacementInformation()
-            {
-                IsTile = false,
-                PlacementOption = _selected.PlacementMode,
-            }, new ConstructionPlacementHijack(constructSystem, _selected));
+                {
+                    IsTile = false,
+                    PlacementOption = _selected.PlacementMode,
+                },
+                new ConstructionPlacementHijack(constructSystem, _selected));
 
             _constructionView.BuildButtonPressed = true;
         }
 
         private void OnSystemLoaded(object? sender, SystemChangedArgs args)
         {
-            if (args.System is ConstructionSystem system) SystemBindingChanged(system);
+            if (args.System is ConstructionSystem system)
+                SystemBindingChanged(system);
         }
 
         private void OnSystemUnloaded(object? sender, SystemChangedArgs args)
         {
-            if (args.System is ConstructionSystem) SystemBindingChanged(null);
+            if (args.System is ConstructionSystem)
+                SystemBindingChanged(null);
         }
 
         private void OnViewFavoriteRecipe()
         {
-            if (_selected is not ConstructionPrototype recipe)
+            if (_selected is null)
                 return;
 
             if (!_favoritedRecipes.Remove(_selected))
                 _favoritedRecipes.Add(_selected);
 
-            if (_selectedCategory == _favoriteCatName)
+            if (_selectedCategory == FavoriteCatName)
             {
-                if (_favoritedRecipes.Count > 0)
-                    OnViewPopulateRecipes(_constructionView, (string.Empty, _favoriteCatName));
-                else
-                    OnViewPopulateRecipes(_constructionView, (string.Empty, string.Empty));
+                OnViewPopulateRecipes(_constructionView,
+                    _favoritedRecipes.Count > 0 ? (string.Empty, FavoriteCatName) : (string.Empty, string.Empty));
             }
 
+            var newFavorites = new List<ProtoId<ConstructionPrototype>>(_favoritedRecipes.Count);
+            foreach (var recipe in _favoritedRecipes)
+                newFavorites.Add(recipe.ID);
+
+            _preferencesManager.UpdateConstructionFavorites(newFavorites);
             PopulateInfo(_selected);
             PopulateCategories(_selectedCategory);
         }
 
+        public void SetFavorites(IReadOnlyList<ProtoId<ConstructionPrototype>> favorites)
+        {
+            _favoritedRecipes.Clear();
+
+            foreach (var id in favorites)
+            {
+                if (_prototypeManager.TryIndex(id, out ConstructionPrototype? recipe, logError: false))
+                    _favoritedRecipes.Add(recipe);
+            }
+
+            if (_selectedCategory == FavoriteCatName)
+            {
+                OnViewPopulateRecipes(_constructionView,
+                    _favoritedRecipes.Count > 0 ? (string.Empty, FavoriteCatName) : (string.Empty, string.Empty));
+            }
+
+            PopulateCategories(_selectedCategory);
+        }
+
         private void SystemBindingChanged(ConstructionSystem? newSystem)
         {
             if (newSystem is null)
@@ -495,6 +551,9 @@ namespace Content.Client.Construction.UI
         private void BindToSystem(ConstructionSystem system)
         {
             _constructionSystem = system;
+
+            OnViewPopulateRecipes(_constructionView, (string.Empty, string.Empty));
+
             system.ToggleCraftingWindow += SystemOnToggleMenu;
             system.FlipConstructionPrototype += SystemFlipConstructionPrototype;
             system.CraftingAvailabilityChanged += SystemCraftingAvailabilityChanged;
@@ -536,7 +595,8 @@ namespace Content.Client.Construction.UI
                 if (IsAtFront)
                 {
                     WindowOpen = false;
-                    _uiManager.GetActiveUIWidget<GameTopMenuBar>().CraftingButton.SetClickPressed(false); // This does not call CraftingButtonToggled
+                    _uiManager.GetActiveUIWidget<GameTopMenuBar>()
+                        .CraftingButton.SetClickPressed(false); // This does not call CraftingButtonToggled
                 }
                 else
                     _constructionView.MoveToFront();
@@ -544,7 +604,8 @@ namespace Content.Client.Construction.UI
             else
             {
                 WindowOpen = true;
-                _uiManager.GetActiveUIWidget<GameTopMenuBar>().CraftingButton.SetClickPressed(true); // This does not call CraftingButtonToggled
+                _uiManager.GetActiveUIWidget<GameTopMenuBar>()
+                    .CraftingButton.SetClickPressed(true); // This does not call CraftingButtonToggled
             }
         }
 

Content.Client/Cuffs/CuffableSystem.cs

@@ -4,12 +4,14 @@ using Content.Shared.Cuffs.Components;
 using Content.Shared.Humanoid;
 using Robust.Client.GameObjects;
 using Robust.Shared.GameStates;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Cuffs;
 
 public sealed class CuffableSystem : SharedCuffableSystem
 {
     [Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -22,7 +24,7 @@ public sealed class CuffableSystem : SharedCuffableSystem
     private void OnCuffableShutdown(EntityUid uid, CuffableComponent component, ComponentShutdown args)
     {
         if (TryComp<SpriteComponent>(uid, out var sprite))
-            sprite.LayerSetVisible(HumanoidVisualLayers.Handcuffs, false);
+            _sprite.LayerSetVisible((uid, sprite), HumanoidVisualLayers.Handcuffs, false);
     }
 
     private void OnCuffableHandleState(EntityUid uid, CuffableComponent component, ref ComponentHandleState args)
@@ -39,22 +41,22 @@ public sealed class CuffableSystem : SharedCuffableSystem
         if (!TryComp<SpriteComponent>(uid, out var sprite))
             return;
         var cuffed = cuffState.NumHandsCuffed > 0;
-        sprite.LayerSetVisible(HumanoidVisualLayers.Handcuffs, cuffed);
+        _sprite.LayerSetVisible((uid, sprite), HumanoidVisualLayers.Handcuffs, cuffed);
 
         // if they are not cuffed, that means that we didn't get a valid color,
         // iconstate, or RSI. that also means we don't need to update the sprites.
         if (!cuffed)
             return;
-        sprite.LayerSetColor(HumanoidVisualLayers.Handcuffs, cuffState.Color!.Value);
+        _sprite.LayerSetColor((uid, sprite), HumanoidVisualLayers.Handcuffs, cuffState.Color!.Value);
 
         if (!Equals(component.CurrentRSI, cuffState.RSI) && cuffState.RSI != null) // we don't want to keep loading the same RSI
         {
             component.CurrentRSI = cuffState.RSI;
-            sprite.LayerSetState(HumanoidVisualLayers.Handcuffs, cuffState.IconState, component.CurrentRSI);
+            _sprite.LayerSetRsi((uid, sprite), _sprite.LayerMapGet((uid, sprite), HumanoidVisualLayers.Handcuffs), new ResPath(component.CurrentRSI), cuffState.IconState);
         }
         else
         {
-            sprite.LayerSetState(HumanoidVisualLayers.Handcuffs, cuffState.IconState);
+            _sprite.LayerSetRsiState((uid, sprite), HumanoidVisualLayers.Handcuffs, cuffState.IconState);
         }
     }
 }

Content.Client/Damage/DamageVisualsSystem.cs

@@ -27,6 +27,7 @@ namespace Content.Client.Damage;
 public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponent>
 {
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -228,7 +229,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             // the layer key just doesn't exist, we skip it.
             foreach (var key in damageVisComp.TargetLayers)
             {
-                if (!spriteComponent.LayerMapTryGet(key, out var index))
+                if (!_sprite.LayerMapTryGet((entity, spriteComponent), key, out var index, false))
                 {
                     Log.Warning($"Layer at key {key} was invalid for entity {entity}.");
                     continue;
@@ -253,7 +254,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             foreach (var layer in damageVisComp.TargetLayerMapKeys)
             {
                 var layerCount = spriteComponent.AllLayers.Count();
-                var index = spriteComponent.LayerMapGet(layer);
+                var index = _sprite.LayerMapGet((entity, spriteComponent), layer);
                 // var layerState = spriteComponent.LayerGetState(index).ToString()!;
 
                 if (index + 1 != layerCount)
@@ -269,7 +270,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
                 {
                     foreach (var (group, sprite) in damageVisComp.DamageOverlayGroups)
                     {
-                        AddDamageLayerToSprite(spriteComponent,
+                        AddDamageLayerToSprite((entity, spriteComponent),
                             sprite,
                             $"{layer}_{group}_{damageVisComp.Thresholds[1]}",
                             $"{layer}{group}",
@@ -283,7 +284,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
                 // was taken.
                 else if (damageVisComp.DamageOverlay != null)
                 {
-                    AddDamageLayerToSprite(spriteComponent,
+                    AddDamageLayerToSprite((entity, spriteComponent),
                         damageVisComp.DamageOverlay,
                         $"{layer}_{damageVisComp.Thresholds[1]}",
                         $"{layer}trackDamage",
@@ -301,7 +302,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             {
                 foreach (var (group, sprite) in damageVisComp.DamageOverlayGroups)
                 {
-                    AddDamageLayerToSprite(spriteComponent,
+                    AddDamageLayerToSprite((entity, spriteComponent),
                         sprite,
                         $"DamageOverlay_{group}_{damageVisComp.Thresholds[1]}",
                         $"DamageOverlay{group}");
@@ -310,7 +311,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             }
             else if (damageVisComp.DamageOverlay != null)
             {
-                AddDamageLayerToSprite(spriteComponent,
+                AddDamageLayerToSprite((entity, spriteComponent),
                     damageVisComp.DamageOverlay,
                     $"DamageOverlay_{damageVisComp.Thresholds[1]}",
                     "DamageOverlay");
@@ -322,16 +323,19 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     /// <summary>
     ///     Adds a damage tracking layer to a given sprite component.
     /// </summary>
-    private void AddDamageLayerToSprite(SpriteComponent spriteComponent, DamageVisualizerSprite sprite, string state, string mapKey, int? index = null)
+    private void AddDamageLayerToSprite(Entity<SpriteComponent?> spriteEnt, DamageVisualizerSprite sprite, string state, string mapKey, int? index = null)
     {
-        var newLayer = spriteComponent.AddLayer(
+        var newLayer = _sprite.AddLayer(
+            spriteEnt,
             new SpriteSpecifier.Rsi(
-                new (sprite.Sprite), state
-            ), index);
-        spriteComponent.LayerMapSet(mapKey, newLayer);
+                new(sprite.Sprite), state
+            ),
+            index
+        );
+        _sprite.LayerMapSet(spriteEnt, mapKey, newLayer);
         if (sprite.Color != null)
-            spriteComponent.LayerSetColor(newLayer, Color.FromHex(sprite.Color));
-        spriteComponent.LayerSetVisible(newLayer, false);
+            _sprite.LayerSetColor(spriteEnt, newLayer, Color.FromHex(sprite.Color));
+        _sprite.LayerSetVisible(spriteEnt, newLayer, false);
     }
 
     protected override void OnAppearanceChange(EntityUid uid, DamageVisualsComponent damageVisComp, ref AppearanceChangeEvent args)
@@ -362,18 +366,18 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             UpdateDisabledLayers(uid, spriteComponent, component, damageVisComp);
 
         if (damageVisComp.Overlay && damageVisComp.DamageOverlayGroups != null && damageVisComp.TargetLayers == null)
-            CheckOverlayOrdering(spriteComponent, damageVisComp);
+            CheckOverlayOrdering((uid, spriteComponent), damageVisComp);
 
         if (AppearanceSystem.TryGetData<bool>(uid, DamageVisualizerKeys.ForceUpdate, out var update, component)
             && update)
         {
-            ForceUpdateLayers(damageComponent, spriteComponent, damageVisComp);
+            ForceUpdateLayers((uid, damageComponent, spriteComponent, damageVisComp));
             return;
         }
 
         if (damageVisComp.TrackAllDamage)
         {
-            UpdateDamageVisuals(damageComponent, spriteComponent, damageVisComp);
+            UpdateDamageVisuals((uid, damageComponent, spriteComponent, damageVisComp));
             return;
         }
 
@@ -383,7 +387,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             data = new DamageVisualizerGroupData(Comp<DamageableComponent>(uid).DamagePerGroup.Keys.ToList());
         }
 
-        UpdateDamageVisuals(data.GroupList, damageComponent, spriteComponent, damageVisComp);
+        UpdateDamageVisuals(data.GroupList, (uid, damageComponent, spriteComponent, damageVisComp));
     }
 
     /// <summary>
@@ -406,7 +410,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             damageVisComp.DisabledLayers[layer] = disabled;
             if (damageVisComp.TrackAllDamage)
             {
-                spriteComponent.LayerSetVisible($"{layer}trackDamage", !disabled);
+                _sprite.LayerSetVisible((uid, spriteComponent), $"{layer}trackDamage", !disabled);
                 continue;
             }
 
@@ -415,7 +419,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
 
             foreach (var damageGroup in damageVisComp.DamageOverlayGroups.Keys)
             {
-                spriteComponent.LayerSetVisible($"{layer}{damageGroup}", !disabled);
+                _sprite.LayerSetVisible((uid, spriteComponent), $"{layer}{damageGroup}", !disabled);
             }
         }
     }
@@ -427,16 +431,16 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     ///     most layer doesn't match, the sprite
     ///     layers are recreated and placed on top.
     /// </summary>
-    private void CheckOverlayOrdering(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
+    private void CheckOverlayOrdering(Entity<SpriteComponent> spriteEnt, DamageVisualsComponent damageVisComp)
     {
-        if (spriteComponent[damageVisComp.TopMostLayerKey] != spriteComponent[spriteComponent.AllLayers.Count() - 1])
+        if (spriteEnt.Comp[damageVisComp.TopMostLayerKey] != spriteEnt.Comp[spriteEnt.Comp.AllLayers.Count() - 1])
         {
             if (!damageVisComp.TrackAllDamage && damageVisComp.DamageOverlayGroups != null)
             {
                 foreach (var (damageGroup, sprite) in damageVisComp.DamageOverlayGroups)
                 {
                     var threshold = damageVisComp.LastThresholdPerGroup[damageGroup];
-                    ReorderOverlaySprite(spriteComponent,
+                    ReorderOverlaySprite(spriteEnt,
                         damageVisComp,
                         sprite,
                         $"DamageOverlay{damageGroup}",
@@ -446,7 +450,7 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             }
             else if (damageVisComp.TrackAllDamage && damageVisComp.DamageOverlay != null)
             {
-                ReorderOverlaySprite(spriteComponent,
+                ReorderOverlaySprite(spriteEnt,
                     damageVisComp,
                     damageVisComp.DamageOverlay,
                     $"DamageOverlay",
@@ -456,21 +460,22 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
         }
     }
 
-    private void ReorderOverlaySprite(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, DamageVisualizerSprite sprite, string key, string statePrefix, FixedPoint2 threshold)
+    private void ReorderOverlaySprite(Entity<SpriteComponent> spriteEnt, DamageVisualsComponent damageVisComp, DamageVisualizerSprite sprite, string key, string statePrefix, FixedPoint2 threshold)
     {
-        spriteComponent.LayerMapTryGet(key, out var spriteLayer);
-        var visibility = spriteComponent[spriteLayer].Visible;
-        spriteComponent.RemoveLayer(spriteLayer);
+        _sprite.LayerMapTryGet(spriteEnt.AsNullable(), key, out var spriteLayer, false);
+        var visibility = spriteEnt.Comp[spriteLayer].Visible;
+        _sprite.RemoveLayer(spriteEnt.AsNullable(), spriteLayer);
         if (threshold == FixedPoint2.Zero) // these should automatically be invisible
             threshold = damageVisComp.Thresholds[1];
-        spriteLayer = spriteComponent.AddLayer(
+        spriteLayer = _sprite.AddLayer(
+            spriteEnt.AsNullable(),
             new SpriteSpecifier.Rsi(
-                new (sprite.Sprite),
+                new(sprite.Sprite),
                 $"{statePrefix}_{threshold}"
             ),
             spriteLayer);
-        spriteComponent.LayerMapSet(key, spriteLayer);
-        spriteComponent.LayerSetVisible(spriteLayer, visibility);
+        _sprite.LayerMapSet(spriteEnt.AsNullable(), key, spriteLayer);
+        _sprite.LayerSetVisible(spriteEnt.AsNullable(), spriteLayer, visibility);
         // this is somewhat iffy since it constantly reallocates
         damageVisComp.TopMostLayerKey = key;
     }
@@ -479,8 +484,12 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     ///     Updates damage visuals without tracking
     ///     any damage groups.
     /// </summary>
-    private void UpdateDamageVisuals(DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
+    private void UpdateDamageVisuals(Entity<DamageableComponent, SpriteComponent, DamageVisualsComponent> entity)
     {
+        var damageComponent = entity.Comp1;
+        var spriteComponent = entity.Comp2;
+        var damageVisComp = entity.Comp3;
+
         if (!CheckThresholdBoundary(damageComponent.TotalDamage, damageVisComp.LastDamageThreshold, damageVisComp, out var threshold))
             return;
 
@@ -490,12 +499,12 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
         {
             foreach (var layerMapKey in damageVisComp.TargetLayerMapKeys)
             {
-                UpdateTargetLayer(spriteComponent, damageVisComp, layerMapKey, threshold);
+                UpdateTargetLayer((entity, spriteComponent), damageVisComp, layerMapKey, threshold);
             }
         }
         else
         {
-            UpdateOverlay(spriteComponent, threshold);
+            UpdateOverlay((entity, spriteComponent), threshold);
         }
     }
 
@@ -504,8 +513,12 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     ///     according to the list of damage groups
     ///     passed into it.
     /// </summary>
-    private void UpdateDamageVisuals(List<string> delta, DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
+    private void UpdateDamageVisuals(List<string> delta, Entity<DamageableComponent, SpriteComponent, DamageVisualsComponent> entity)
     {
+        var damageComponent = entity.Comp1;
+        var spriteComponent = entity.Comp2;
+        var damageVisComp = entity.Comp3;
+
         foreach (var damageGroup in delta)
         {
             if (!damageVisComp.Overlay && damageGroup != damageVisComp.DamageGroup)
@@ -525,12 +538,12 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
             {
                 foreach (var layerMapKey in damageVisComp.TargetLayerMapKeys)
                 {
-                    UpdateTargetLayer(spriteComponent, damageVisComp, layerMapKey, damageGroup, threshold);
+                    UpdateTargetLayer((entity, spriteComponent, damageVisComp), layerMapKey, damageGroup, threshold);
                 }
             }
             else
             {
-                UpdateOverlay(spriteComponent, damageVisComp, damageGroup, threshold);
+                UpdateOverlay((entity, spriteComponent, damageVisComp), damageGroup, threshold);
             }
         }
 
@@ -567,19 +580,21 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     ///     Does different things depending on
     ///     the configuration of the visualizer.
     /// </summary>
-    private void ForceUpdateLayers(DamageableComponent damageComponent, SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp)
+    private void ForceUpdateLayers(Entity<DamageableComponent, SpriteComponent, DamageVisualsComponent> entity)
     {
+        var damageVisComp = entity.Comp3;
+
         if (damageVisComp.DamageOverlayGroups != null)
         {
-            UpdateDamageVisuals(damageVisComp.DamageOverlayGroups.Keys.ToList(), damageComponent, spriteComponent, damageVisComp);
+            UpdateDamageVisuals(damageVisComp.DamageOverlayGroups.Keys.ToList(), entity);
         }
         else if (damageVisComp.DamageGroup != null)
         {
-            UpdateDamageVisuals(new List<string>(){ damageVisComp.DamageGroup }, damageComponent, spriteComponent, damageVisComp);
+            UpdateDamageVisuals(new List<string>() { damageVisComp.DamageGroup }, entity);
         }
         else if (damageVisComp.DamageOverlay != null)
         {
-            UpdateDamageVisuals(damageComponent, spriteComponent, damageVisComp);
+            UpdateDamageVisuals(entity);
         }
     }
 
@@ -588,16 +603,16 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     ///     it assumes you're updating a layer that is tracking all
     ///     damage.
     /// </summary>
-    private void UpdateTargetLayer(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, object layerMapKey, FixedPoint2 threshold)
+    private void UpdateTargetLayer(Entity<SpriteComponent> spriteEnt, DamageVisualsComponent damageVisComp, object layerMapKey, FixedPoint2 threshold)
     {
         if (damageVisComp.Overlay && damageVisComp.DamageOverlayGroups != null)
         {
             if (!damageVisComp.DisabledLayers[layerMapKey])
             {
                 var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
-                spriteComponent.LayerMapTryGet($"{layerMapKey}trackDamage", out var spriteLayer);
+                _sprite.LayerMapTryGet(spriteEnt.AsNullable(), $"{layerMapKey}trackDamage", out var spriteLayer, false);
 
-                UpdateDamageLayerState(spriteComponent,
+                UpdateDamageLayerState(spriteEnt,
                     spriteLayer,
                     $"{layerState}",
                     threshold);
@@ -606,9 +621,9 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
         else if (!damageVisComp.Overlay)
         {
             var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
-            spriteComponent.LayerMapTryGet(layerMapKey, out var spriteLayer);
+            _sprite.LayerMapTryGet(spriteEnt.AsNullable(), $"{layerMapKey}", out var spriteLayer, false);
 
-            UpdateDamageLayerState(spriteComponent,
+            UpdateDamageLayerState(spriteEnt,
                 spriteLayer,
                 $"{layerState}",
                 threshold);
@@ -618,16 +633,20 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     /// <summary>
     ///     Updates a target layer by damage group.
     /// </summary>
-    private void UpdateTargetLayer(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, object layerMapKey, string damageGroup, FixedPoint2 threshold)
+    private void UpdateTargetLayer(Entity<SpriteComponent, DamageVisualsComponent> entity, object layerMapKey, string damageGroup, FixedPoint2 threshold)
     {
+        var spriteComponent = entity.Comp1;
+        var damageVisComp = entity.Comp2;
+
         if (damageVisComp.Overlay && damageVisComp.DamageOverlayGroups != null)
         {
             if (damageVisComp.DamageOverlayGroups.ContainsKey(damageGroup) && !damageVisComp.DisabledLayers[layerMapKey])
             {
                 var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
-                spriteComponent.LayerMapTryGet($"{layerMapKey}{damageGroup}", out var spriteLayer);
+                _sprite.LayerMapTryGet((entity, spriteComponent), $"{layerMapKey}{damageGroup}", out var spriteLayer, false);
 
-                UpdateDamageLayerState(spriteComponent,
+                UpdateDamageLayerState(
+                    (entity, spriteComponent),
                     spriteLayer,
                     $"{layerState}_{damageGroup}",
                     threshold);
@@ -636,9 +655,10 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
         else if (!damageVisComp.Overlay)
         {
             var layerState = damageVisComp.LayerMapKeyStates[layerMapKey];
-            spriteComponent.LayerMapTryGet(layerMapKey, out var spriteLayer);
+            _sprite.LayerMapTryGet((entity, spriteComponent), $"{layerMapKey}", out var spriteLayer, false);
 
-            UpdateDamageLayerState(spriteComponent,
+            UpdateDamageLayerState(
+                (entity, spriteComponent),
                 spriteLayer,
                 $"{layerState}_{damageGroup}",
                 threshold);
@@ -648,11 +668,11 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     /// <summary>
     ///     Updates an overlay that is tracking all damage.
     /// </summary>
-    private void UpdateOverlay(SpriteComponent spriteComponent, FixedPoint2 threshold)
+    private void UpdateOverlay(Entity<SpriteComponent> spriteEnt, FixedPoint2 threshold)
     {
-        spriteComponent.LayerMapTryGet($"DamageOverlay", out var spriteLayer);
+        _sprite.LayerMapTryGet(spriteEnt.AsNullable(), $"DamageOverlay", out var spriteLayer, false);
 
-        UpdateDamageLayerState(spriteComponent,
+        UpdateDamageLayerState(spriteEnt,
             spriteLayer,
             $"DamageOverlay",
             threshold);
@@ -661,15 +681,19 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     /// <summary>
     ///     Updates an overlay based on damage group.
     /// </summary>
-    private void UpdateOverlay(SpriteComponent spriteComponent, DamageVisualsComponent damageVisComp, string damageGroup, FixedPoint2 threshold)
+    private void UpdateOverlay(Entity<SpriteComponent, DamageVisualsComponent> entity, string damageGroup, FixedPoint2 threshold)
     {
+        var spriteComponent = entity.Comp1;
+        var damageVisComp = entity.Comp2;
+
         if (damageVisComp.DamageOverlayGroups != null)
         {
             if (damageVisComp.DamageOverlayGroups.ContainsKey(damageGroup))
             {
-                spriteComponent.LayerMapTryGet($"DamageOverlay{damageGroup}", out var spriteLayer);
+                _sprite.LayerMapTryGet((entity, spriteComponent), $"DamageOverlay{damageGroup}", out var spriteLayer, false);
 
-                UpdateDamageLayerState(spriteComponent,
+                UpdateDamageLayerState(
+                    (entity, spriteComponent),
                     spriteLayer,
                     $"DamageOverlay_{damageGroup}",
                     threshold);
@@ -683,19 +707,19 @@ public sealed class DamageVisualsSystem : VisualizerSystem<DamageVisualsComponen
     ///     function calls it), and what threshold
     ///     was passed into it.
     /// </summary>
-    private void UpdateDamageLayerState(SpriteComponent spriteComponent, int spriteLayer, string statePrefix, FixedPoint2 threshold)
+    private void UpdateDamageLayerState(Entity<SpriteComponent> spriteEnt, int spriteLayer, string statePrefix, FixedPoint2 threshold)
     {
         if (threshold == 0)
         {
-            spriteComponent.LayerSetVisible(spriteLayer, false);
+            _sprite.LayerSetVisible(spriteEnt.AsNullable(), spriteLayer, false);
         }
         else
         {
-            if (!spriteComponent[spriteLayer].Visible)
+            if (!spriteEnt.Comp[spriteLayer].Visible)
             {
-                spriteComponent.LayerSetVisible(spriteLayer, true);
+                _sprite.LayerSetVisible(spriteEnt.AsNullable(), spriteLayer, true);
             }
-            spriteComponent.LayerSetState(spriteLayer, $"{statePrefix}_{threshold}");
+            _sprite.LayerSetRsiState(spriteEnt.AsNullable(), spriteLayer, $"{statePrefix}_{threshold}");
         }
     }
 }

Content.Client/Damage/Systems/StaminaSystem.cs

@@ -0,0 +1,7 @@
+using Content.Shared.Damage.Systems;
+
+namespace Content.Client.Damage.Systems;
+
+public sealed partial class StaminaSystem : SharedStaminaSystem
+{
+}

Content.Client/DamageState/DamageStateVisualizerSystem.cs

@@ -6,6 +6,8 @@ namespace Content.Client.DamageState;
 
 public sealed class DamageStateVisualizerSystem : VisualizerSystem<DamageStateVisualsComponent>
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     protected override void OnAppearanceChange(EntityUid uid, DamageStateVisualsComponent component, ref AppearanceChangeEvent args)
     {
         var sprite = args.Sprite;
@@ -21,34 +23,34 @@ public sealed class DamageStateVisualizerSystem : VisualizerSystem<DamageStateVi
         }
 
         // Brain no worky rn so this was just easier.
-        foreach (var key in new []{ DamageStateVisualLayers.Base, DamageStateVisualLayers.BaseUnshaded })
+        foreach (var key in new[] { DamageStateVisualLayers.Base, DamageStateVisualLayers.BaseUnshaded })
         {
-            if (!sprite.LayerMapTryGet(key, out _)) continue;
+            if (!_sprite.LayerMapTryGet((uid, sprite), key, out _, false)) continue;
 
-            sprite.LayerSetVisible(key, false);
+            _sprite.LayerSetVisible((uid, sprite), key, false);
         }
 
         foreach (var (key, state) in layers)
         {
             // Inheritance moment.
-            if (!sprite.LayerMapTryGet(key, out _)) continue;
+            if (!_sprite.LayerMapTryGet((uid, sprite), key, out _, false)) continue;
 
-            sprite.LayerSetVisible(key, true);
-            sprite.LayerSetState(key, state);
+            _sprite.LayerSetVisible((uid, sprite), key, true);
+            _sprite.LayerSetRsiState((uid, sprite), key, state);
         }
 
         // So they don't draw over mobs anymore
         if (data == MobState.Dead)
         {
-            if (sprite.DrawDepth > (int) DrawDepth.DeadMobs)
+            if (sprite.DrawDepth > (int)DrawDepth.DeadMobs)
             {
                 component.OriginalDrawDepth = sprite.DrawDepth;
-                sprite.DrawDepth = (int) DrawDepth.DeadMobs;
+                _sprite.SetDrawDepth((uid, sprite), (int)DrawDepth.DeadMobs);
             }
         }
         else if (component.OriginalDrawDepth != null)
         {
-            sprite.DrawDepth = component.OriginalDrawDepth.Value;
+            _sprite.SetDrawDepth((uid, sprite), component.OriginalDrawDepth.Value);
             component.OriginalDrawDepth = null;
         }
     }

Content.Client/Delivery/DeliveryVisualizerSystem.cs

@@ -9,7 +9,6 @@ public sealed class DeliveryVisualizerSystem : VisualizerSystem<DeliveryComponen
 {
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
     [Dependency] private readonly IPrototypeManager _prototype = default!;
-    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     private static readonly ProtoId<JobIconPrototype> UnknownIcon = "JobIconUnknown";
 
@@ -25,11 +24,11 @@ public sealed class DeliveryVisualizerSystem : VisualizerSystem<DeliveryComponen
 
         if (!_prototype.TryIndex<JobIconPrototype>(job, out var icon))
         {
-            args.Sprite.LayerSetTexture(DeliveryVisualLayers.JobStamp, _sprite.Frame0(_prototype.Index("JobIconUnknown")));
+            SpriteSystem.LayerSetTexture((uid, args.Sprite), DeliveryVisualLayers.JobStamp, SpriteSystem.Frame0(_prototype.Index("JobIconUnknown")));
             return;
         }
 
-        args.Sprite.LayerSetTexture(DeliveryVisualLayers.JobStamp, _sprite.Frame0(icon.Icon));
+        SpriteSystem.LayerSetTexture((uid, args.Sprite), DeliveryVisualLayers.JobStamp, SpriteSystem.Frame0(icon.Icon));
     }
 }
 
@@ -42,6 +41,8 @@ public enum DeliveryVisualLayers : byte
     PriorityTape,
     Breakage,
     Trash,
+    Bomb,
+    BombPrimed,
 }
 
 public enum DeliverySpawnerVisualLayers : byte

Content.Client/Dice/DiceSystem.cs

@@ -5,6 +5,8 @@ namespace Content.Client.Dice;
 
 public sealed class DiceSystem : SharedDiceSystem
 {
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -18,11 +20,11 @@ public sealed class DiceSystem : SharedDiceSystem
             return;
 
         // TODO maybe just move each die to its own RSI?
-        var state = sprite.LayerGetState(0).Name;
+        var state = _sprite.LayerGetRsiState((entity.Owner, sprite), 0).Name;
         if (state == null)
             return;
 
         var prefix = state.Substring(0, state.IndexOf('_'));
-        sprite.LayerSetState(0, $"{prefix}_{entity.Comp.CurrentValue}");
+        _sprite.LayerSetRsiState((entity.Owner, sprite), 0, $"{prefix}_{entity.Comp.CurrentValue}");
     }
 }

Content.Client/DisplacementMap/DisplacementMapSystem.cs

@@ -8,18 +8,19 @@ namespace Content.Client.DisplacementMap;
 public sealed class DisplacementMapSystem : EntitySystem
 {
     [Dependency] private readonly ISerializationManager _serialization = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     /// <summary>
     /// Attempting to apply a displacement map to a specific layer of SpriteComponent
     /// </summary>
     /// <param name="data">Information package for applying the displacement map</param>
-    /// <param name="sprite">SpriteComponent</param>
+    /// <param name="sprite">Entity with SpriteComponent</param>
     /// <param name="index">Index of the layer where the new map layer will be added</param>
     /// <param name="key">Unique layer key, which will determine which layer to apply displacement map to</param>
     /// <param name="displacementKey">The key of the new displacement map layer added by this function.</param>
     /// <returns></returns>
     public bool TryAddDisplacement(DisplacementData data,
-        SpriteComponent sprite,
+        Entity<SpriteComponent> sprite,
         int index,
         object key,
         out string displacementKey)
@@ -30,10 +31,9 @@ public sealed class DisplacementMapSystem : EntitySystem
             return false;
 
         if (data.ShaderOverride != null)
-            sprite.LayerSetShader(index, data.ShaderOverride);
+            sprite.Comp.LayerSetShader(index, data.ShaderOverride);
 
-        if (sprite.LayerMapTryGet(displacementKey, out var oldIndex))
-            sprite.RemoveLayer(oldIndex);
+        _sprite.RemoveLayer(sprite.AsNullable(), displacementKey, false);
 
         //allows you not to write it every time in the YML
         foreach (var pair in data.SizeMaps)
@@ -55,7 +55,7 @@ public sealed class DisplacementMapSystem : EntitySystem
         // We choose a displacement map from the possible ones, matching the size with the original layer size.
         // If there is no such a map, we use a standard 32 by 32 one
         var displacementDataLayer = data.SizeMaps[EyeManager.PixelsPerMeter];
-        var actualRSI = sprite.LayerGetActualRSI(index);
+        var actualRSI = _sprite.LayerGetEffectiveRsi(sprite.AsNullable(), index);
         if (actualRSI is not null)
         {
             if (actualRSI.Size.X != actualRSI.Size.Y)
@@ -72,9 +72,20 @@ public sealed class DisplacementMapSystem : EntitySystem
         var displacementLayer = _serialization.CreateCopy(displacementDataLayer, notNullableOverride: true);
         displacementLayer.CopyToShaderParameters!.LayerKey = key.ToString() ?? "this is impossible";
 
-        sprite.AddLayer(displacementLayer, index);
-        sprite.LayerMapSet(displacementKey, index);
+        _sprite.AddLayer(sprite.AsNullable(), displacementLayer, index);
+        _sprite.LayerMapSet(sprite.AsNullable(), displacementKey, index);
 
         return true;
     }
+
+    /// <inheritdoc cref="TryAddDisplacement"/>
+    [Obsolete("Use the Entity<SpriteComponent> overload")]
+    public bool TryAddDisplacement(DisplacementData data,
+        SpriteComponent sprite,
+        int index,
+        object key,
+        out string displacementKey)
+    {
+        return TryAddDisplacement(data, (sprite.Owner, sprite), index, key, out displacementKey);
+    }
 }

Content.Client/Disposal/Mailing/MailingUnitBoundUserInterface.cs

@@ -4,6 +4,7 @@ using Content.Shared.Disposal;
 using Content.Shared.Disposal.Components;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
+using System.Linq;
 
 namespace Content.Client.Disposal.Mailing;
 
@@ -70,10 +71,10 @@ public sealed class MailingUnitBoundUserInterface : BoundUserInterface
         //UnitTag.Text = state.Tag;
         MailingUnitWindow.Target.Text = entity.Comp.Target;
 
-        MailingUnitWindow.TargetListContainer.Clear();
-        foreach (var target in entity.Comp.TargetList)
-        {
-            MailingUnitWindow.TargetListContainer.AddItem(target);
-        }
+        var entries = entity.Comp.TargetList.Select(target => new ItemList.Item(MailingUnitWindow.TargetListContainer) {
+            Text = target,
+            Selected = target == entity.Comp.Target
+        }).ToList();
+        MailingUnitWindow.TargetListContainer.SetItems(entries);
     }
 }

Content.Client/Disposal/Unit/DisposalUnitSystem.cs

@@ -13,6 +13,7 @@ public sealed class DisposalUnitSystem : SharedDisposalUnitSystem
     [Dependency] private readonly AnimationPlayerSystem _animationSystem = default!;
     [Dependency] private readonly SharedAudioSystem _audioSystem = default!;
     [Dependency] private readonly SharedUserInterfaceSystem _uiSystem = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     private const string AnimationKey = "disposal_unit_animation";
 
@@ -67,13 +68,13 @@ public sealed class DisposalUnitSystem : SharedDisposalUnitSystem
         if (!_appearanceSystem.TryGetData<DisposalUnitComponent.VisualState>(ent, DisposalUnitComponent.Visuals.VisualState, out var state, appearance))
             return;
 
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.Unanchored, state == DisposalUnitComponent.VisualState.UnAnchored);
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.Base, state == DisposalUnitComponent.VisualState.Anchored);
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayFlush, state == DisposalUnitComponent.VisualState.OverlayFlushing);
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.BaseCharging, state == DisposalUnitComponent.VisualState.OverlayCharging);
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.Unanchored, state == DisposalUnitComponent.VisualState.UnAnchored);
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.Base, state == DisposalUnitComponent.VisualState.Anchored);
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.OverlayFlush, state == DisposalUnitComponent.VisualState.OverlayFlushing);
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.BaseCharging, state == DisposalUnitComponent.VisualState.OverlayCharging);
 
-        var chargingState = sprite.LayerMapTryGet(DisposalUnitVisualLayers.BaseCharging, out var chargingLayer)
-            ? sprite.LayerGetState(chargingLayer)
+        var chargingState = _sprite.LayerMapTryGet((ent, sprite), DisposalUnitVisualLayers.BaseCharging, out var chargingLayer, false)
+            ? _sprite.LayerGetRsiState((ent, sprite), chargingLayer)
             : new RSI.StateId(DefaultChargeState);
 
         // This is a transient state so not too worried about replaying in range.
@@ -81,8 +82,8 @@ public sealed class DisposalUnitSystem : SharedDisposalUnitSystem
         {
             if (!_animationSystem.HasRunningAnimation(ent, AnimationKey))
             {
-                var flushState = sprite.LayerMapTryGet(DisposalUnitVisualLayers.OverlayFlush, out var flushLayer)
-                    ? sprite.LayerGetState(flushLayer)
+                var flushState = _sprite.LayerMapTryGet((ent, sprite), DisposalUnitVisualLayers.OverlayFlush, out var flushLayer, false)
+                    ? _sprite.LayerGetRsiState((ent, sprite), flushLayer)
                     : new RSI.StateId(DefaultFlushState);
 
                 // Setup the flush animation to play
@@ -124,16 +125,16 @@ public sealed class DisposalUnitSystem : SharedDisposalUnitSystem
         if (!_appearanceSystem.TryGetData<DisposalUnitComponent.HandleState>(ent, DisposalUnitComponent.Visuals.Handle, out var handleState, appearance))
             handleState = DisposalUnitComponent.HandleState.Normal;
 
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayEngaged, handleState != DisposalUnitComponent.HandleState.Normal);
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.OverlayEngaged, handleState != DisposalUnitComponent.HandleState.Normal);
 
         if (!_appearanceSystem.TryGetData<DisposalUnitComponent.LightStates>(ent, DisposalUnitComponent.Visuals.Light, out var lightState, appearance))
             lightState = DisposalUnitComponent.LightStates.Off;
 
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayCharging,
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.OverlayCharging,
                 (lightState & DisposalUnitComponent.LightStates.Charging) != 0);
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayReady,
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.OverlayReady,
                 (lightState & DisposalUnitComponent.LightStates.Ready) != 0);
-        sprite.LayerSetVisible(DisposalUnitVisualLayers.OverlayFull,
+        _sprite.LayerSetVisible((ent, sprite), DisposalUnitVisualLayers.OverlayFull,
                 (lightState & DisposalUnitComponent.LightStates.Full) != 0);
     }
 }

Content.Client/DoAfter/DoAfterOverlay.cs

@@ -21,6 +21,7 @@ public sealed class DoAfterOverlay : Overlay
     private readonly MetaDataSystem _meta;
     private readonly ProgressColorSystem _progressColor;
     private readonly SharedContainerSystem _container;
+    private readonly SpriteSystem _sprite;
 
     private readonly Texture _barTexture;
     private readonly ShaderInstance _unshadedShader;
@@ -45,6 +46,7 @@ public sealed class DoAfterOverlay : Overlay
         _meta = _entManager.EntitySysManager.GetEntitySystem<MetaDataSystem>();
         _container = _entManager.EntitySysManager.GetEntitySystem<SharedContainerSystem>();
         _progressColor = _entManager.System<ProgressColorSystem>();
+        _sprite = _entManager.System<SpriteSystem>();
         var sprite = new SpriteSpecifier.Rsi(new("/Textures/Interface/Misc/progress_bar.rsi"), "icon");
         _barTexture = _entManager.EntitySysManager.GetEntitySystem<SpriteSystem>().Frame0(sprite);
 
@@ -118,7 +120,7 @@ public sealed class DoAfterOverlay : Overlay
 
                 // Use the sprite itself if we know its bounds. This means short or tall sprites don't get overlapped
                 // by the bar.
-                float yOffset = sprite.Bounds.Height / 2f + 0.05f;
+                var yOffset = _sprite.GetLocalBounds((uid, sprite)).Height / 2f + 0.05f;
 
                 // 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.
@@ -135,7 +137,7 @@ public sealed class DoAfterOverlay : Overlay
                 if (doAfter.CancelledTime != null)
                 {
                     var elapsed = doAfter.CancelledTime.Value - doAfter.StartTime;
-                    elapsedRatio = (float) Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
+                    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);
@@ -143,7 +145,7 @@ public sealed class DoAfterOverlay : Overlay
                 else
                 {
                     var elapsed = time - doAfter.StartTime;
-                    elapsedRatio = (float) Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
+                    elapsedRatio = (float)Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
                     color = GetProgressColor(elapsedRatio, alpha);
                 }
 

Content.Client/Doors/AirlockSystem.cs

@@ -10,6 +10,7 @@ namespace Content.Client.Doors;
 public sealed class AirlockSystem : SharedAirlockSystem
 {
     [Dependency] private readonly AppearanceSystem _appearanceSystem = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -21,7 +22,7 @@ public sealed class AirlockSystem : SharedAirlockSystem
     private void OnComponentStartup(EntityUid uid, AirlockComponent comp, ComponentStartup args)
     {
         // Has to be on component startup because we don't know what order components initialize in and running this before DoorComponent inits _will_ crash.
-        if(!TryComp<DoorComponent>(uid, out var door))
+        if (!TryComp<DoorComponent>(uid, out var door))
             return;
 
         if (comp.OpenUnlitVisible) // Otherwise there are flashes of the fallback sprite between clicking on the door and the door closing animation starting.
@@ -31,17 +32,17 @@ public sealed class AirlockSystem : SharedAirlockSystem
         }
 
         ((Animation)door.OpeningAnimation).AnimationTracks.Add(new AnimationTrackSpriteFlick()
-            {
-                LayerKey = DoorVisualLayers.BaseUnlit,
-                KeyFrames = { new AnimationTrackSpriteFlick.KeyFrame(comp.OpeningSpriteState, 0f) },
-            }
+        {
+            LayerKey = DoorVisualLayers.BaseUnlit,
+            KeyFrames = { new AnimationTrackSpriteFlick.KeyFrame(comp.OpeningSpriteState, 0f) },
+        }
         );
 
         ((Animation)door.ClosingAnimation).AnimationTracks.Add(new AnimationTrackSpriteFlick()
-            {
-                LayerKey = DoorVisualLayers.BaseUnlit,
-                KeyFrames = { new AnimationTrackSpriteFlick.KeyFrame(comp.ClosingSpriteState, 0f) },
-            }
+        {
+            LayerKey = DoorVisualLayers.BaseUnlit,
+            KeyFrames = { new AnimationTrackSpriteFlick.KeyFrame(comp.ClosingSpriteState, 0f) },
+        }
         );
 
         door.DenyingAnimation = new Animation()
@@ -57,19 +58,19 @@ public sealed class AirlockSystem : SharedAirlockSystem
             }
         };
 
-        if(!comp.AnimatePanel)
+        if (!comp.AnimatePanel)
             return;
 
         ((Animation)door.OpeningAnimation).AnimationTracks.Add(new AnimationTrackSpriteFlick()
         {
             LayerKey = WiresVisualLayers.MaintenancePanel,
-            KeyFrames = {new AnimationTrackSpriteFlick.KeyFrame(comp.OpeningPanelSpriteState, 0f)},
+            KeyFrames = { new AnimationTrackSpriteFlick.KeyFrame(comp.OpeningPanelSpriteState, 0f) },
         });
 
         ((Animation)door.ClosingAnimation).AnimationTracks.Add(new AnimationTrackSpriteFlick
         {
             LayerKey = WiresVisualLayers.MaintenancePanel,
-            KeyFrames = {new AnimationTrackSpriteFlick.KeyFrame(comp.ClosingPanelSpriteState, 0f)},
+            KeyFrames = { new AnimationTrackSpriteFlick.KeyFrame(comp.ClosingPanelSpriteState, 0f) },
         });
     }
 
@@ -101,11 +102,12 @@ public sealed class AirlockSystem : SharedAirlockSystem
                     && !boltedVisible && !emergencyLightsVisible;
         }
 
-        args.Sprite.LayerSetVisible(DoorVisualLayers.BaseUnlit, unlitVisible);
-        args.Sprite.LayerSetVisible(DoorVisualLayers.BaseBolted, boltedVisible);
+        _sprite.LayerSetVisible((uid, args.Sprite), DoorVisualLayers.BaseUnlit, unlitVisible);
+        _sprite.LayerSetVisible((uid, args.Sprite), DoorVisualLayers.BaseBolted, boltedVisible);
         if (comp.EmergencyAccessLayer)
         {
-            args.Sprite.LayerSetVisible(
+            _sprite.LayerSetVisible(
+                (uid, args.Sprite),
                 DoorVisualLayers.BaseEmergencyAccess,
                     emergencyLightsVisible
                 &&  state != DoorState.Open
@@ -118,12 +120,12 @@ public sealed class AirlockSystem : SharedAirlockSystem
         switch (state)
         {
             case DoorState.Open:
-                args.Sprite.LayerSetState(DoorVisualLayers.BaseUnlit, comp.ClosingSpriteState);
-                args.Sprite.LayerSetAnimationTime(DoorVisualLayers.BaseUnlit, 0);
+                _sprite.LayerSetRsiState((uid, args.Sprite), DoorVisualLayers.BaseUnlit, comp.ClosingSpriteState);
+                _sprite.LayerSetAnimationTime((uid, args.Sprite), DoorVisualLayers.BaseUnlit, 0);
                 break;
             case DoorState.Closed:
-                args.Sprite.LayerSetState(DoorVisualLayers.BaseUnlit, comp.OpeningSpriteState);
-                args.Sprite.LayerSetAnimationTime(DoorVisualLayers.BaseUnlit, 0);
+                _sprite.LayerSetRsiState((uid, args.Sprite), DoorVisualLayers.BaseUnlit, comp.OpeningSpriteState);
+                _sprite.LayerSetAnimationTime((uid, args.Sprite), DoorVisualLayers.BaseUnlit, 0);
                 break;
         }
     }

Content.Client/Doors/DoorSystem.cs

@@ -11,6 +11,7 @@ public sealed class DoorSystem : SharedDoorSystem
 {
     [Dependency] private readonly AnimationPlayerSystem _animationSystem = default!;
     [Dependency] private readonly IResourceCache _resourceCache = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -85,7 +86,7 @@ public sealed class DoorSystem : SharedDoorSystem
             state = DoorState.Closed;
 
         if (AppearanceSystem.TryGetData<string>(entity, DoorVisuals.BaseRSI, out var baseRsi, args.Component))
-            UpdateSpriteLayers(args.Sprite, baseRsi);
+            UpdateSpriteLayers((entity.Owner, args.Sprite), baseRsi);
 
         if (_animationSystem.HasRunningAnimation(entity, DoorComponent.AnimationKey))
             _animationSystem.Stop(entity.Owner, DoorComponent.AnimationKey);
@@ -95,21 +96,21 @@ public sealed class DoorSystem : SharedDoorSystem
 
     private void UpdateAppearanceForDoorState(Entity<DoorComponent> entity, SpriteComponent sprite, DoorState state)
     {
-        sprite.DrawDepth = state is DoorState.Open ? entity.Comp.OpenDrawDepth : entity.Comp.ClosedDrawDepth;
+        _sprite.SetDrawDepth((entity.Owner, sprite), state is DoorState.Open ? entity.Comp.OpenDrawDepth : entity.Comp.ClosedDrawDepth);
 
         switch (state)
         {
             case DoorState.Open:
                 foreach (var (layer, layerState) in entity.Comp.OpenSpriteStates)
                 {
-                    sprite.LayerSetState(layer, layerState);
+                    _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
                 }
 
                 return;
             case DoorState.Closed:
                 foreach (var (layer, layerState) in entity.Comp.ClosedSpriteStates)
                 {
-                    sprite.LayerSetState(layer, layerState);
+                    _sprite.LayerSetRsiState((entity.Owner, sprite), layer, layerState);
                 }
 
                 return;
@@ -138,7 +139,7 @@ public sealed class DoorSystem : SharedDoorSystem
         }
     }
 
-    private void UpdateSpriteLayers(SpriteComponent sprite, string baseRsi)
+    private void UpdateSpriteLayers(Entity<SpriteComponent> sprite, string baseRsi)
     {
         if (!_resourceCache.TryGetResource<RSIResource>(SpriteSpecifierSerializer.TextureRoot / baseRsi, out var res))
         {
@@ -146,6 +147,6 @@ public sealed class DoorSystem : SharedDoorSystem
             return;
         }
 
-        sprite.BaseRSI = res.RSI;
+        _sprite.SetBaseRsi(sprite.AsNullable(), res.RSI);
     }
 }

Content.Client/Doors/FirelockSystem.cs

@@ -8,6 +8,7 @@ namespace Content.Client.Doors;
 public sealed class FirelockSystem : SharedFirelockSystem
 {
     [Dependency] private readonly SharedAppearanceSystem _appearanceSystem = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -18,7 +19,7 @@ public sealed class FirelockSystem : SharedFirelockSystem
     protected override void OnComponentStartup(Entity<FirelockComponent> ent, ref ComponentStartup args)
     {
         base.OnComponentStartup(ent, ref args);
-        if(!TryComp<DoorComponent>(ent.Owner, out var door))
+        if (!TryComp<DoorComponent>(ent.Owner, out var door))
             return;
 
         door.ClosedSpriteStates.Add((DoorVisualLayers.BaseUnlit, ent.Comp.WarningLightSpriteState));
@@ -57,7 +58,7 @@ public sealed class FirelockSystem : SharedFirelockSystem
             ||  state == DoorState.Denying
             || (_appearanceSystem.TryGetData<bool>(uid, DoorVisuals.ClosedLights, out var closedLights, args.Component) && closedLights);
 
-        args.Sprite.LayerSetVisible(DoorVisualLayers.BaseUnlit, unlitVisible && !boltedVisible);
-        args.Sprite.LayerSetVisible(DoorVisualLayers.BaseBolted, boltedVisible);
+        _sprite.LayerSetVisible((uid, args.Sprite), DoorVisualLayers.BaseUnlit, unlitVisible && !boltedVisible);
+        _sprite.LayerSetVisible((uid, args.Sprite), DoorVisualLayers.BaseBolted, boltedVisible);
     }
 }

Content.Client/Doors/TurnstileSystem.cs

@@ -13,8 +13,9 @@ namespace Content.Client.Doors;
 public sealed class TurnstileSystem : SharedTurnstileSystem
 {
     [Dependency] private readonly AnimationPlayerSystem _animationPlayer = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
-    private static EntProtoId _examineArrow = "TurnstileArrow";
+    private static readonly EntProtoId ExamineArrow = "TurnstileArrow";
 
     private const string AnimationKey = "Turnstile";
 
@@ -33,12 +34,12 @@ public sealed class TurnstileSystem : SharedTurnstileSystem
 
         if (!TryComp<SpriteComponent>(ent, out var sprite))
             return;
-        sprite.LayerSetState(TurnstileVisualLayers.Base, new RSI.StateId(ent.Comp.DefaultState));
+        _sprite.LayerSetRsiState((ent.Owner, sprite), TurnstileVisualLayers.Base, new RSI.StateId(ent.Comp.DefaultState));
     }
 
     private void OnExamined(Entity<TurnstileComponent> ent, ref ExaminedEvent args)
     {
-        Spawn(_examineArrow, new EntityCoordinates(ent, 0, 0));
+        Spawn(ExamineArrow, new EntityCoordinates(ent, 0, 0));
     }
 
     protected override void PlayAnimation(EntityUid uid, string stateId)

Content.Client/Dragon/DragonSystem.cs

@@ -7,6 +7,7 @@ namespace Content.Client.Dragon;
 public sealed class DragonSystem : EntitySystem
 {
     [Dependency] private readonly SharedPointLightSystem _lights = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -31,7 +32,7 @@ public sealed class DragonSystem : EntitySystem
         switch (state.State)
         {
             case DragonRiftState.Charging:
-                sprite?.LayerSetColor(0, Color.FromHex("#569fff"));
+                _sprite.LayerSetColor((uid, sprite), 0, Color.FromHex("#569fff"));
 
                 if (light != null)
                 {
@@ -39,7 +40,7 @@ public sealed class DragonSystem : EntitySystem
                 }
                 break;
             case DragonRiftState.AlmostFinished:
-                sprite?.LayerSetColor(0, Color.FromHex("#cf4cff"));
+                _sprite.LayerSetColor((uid, sprite), 0, Color.FromHex("#cf4cff"));
 
                 if (light != null)
                 {
@@ -47,7 +48,7 @@ public sealed class DragonSystem : EntitySystem
                 }
                 break;
             case DragonRiftState.Finished:
-                sprite?.LayerSetColor(0, Color.FromHex("#edbc36"));
+                _sprite.LayerSetColor((uid, sprite), 0, Color.FromHex("#edbc36"));
 
                 if (light != null)
                 {

Content.Client/Drugs/DrugOverlaySystem.cs

@@ -2,6 +2,7 @@ using Content.Shared.Drugs;
 using Robust.Client.Graphics;
 using Robust.Client.Player;
 using Robust.Shared.Player;
+using Robust.Shared.Random;
 
 namespace Content.Client.Drugs;
 
@@ -12,6 +13,7 @@ public sealed class DrugOverlaySystem : EntitySystem
 {
     [Dependency] private readonly IPlayerManager _player = default!;
     [Dependency] private readonly IOverlayManager _overlayMan = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
 
     private RainbowOverlay _overlay = default!;
 
@@ -45,7 +47,10 @@ public sealed class DrugOverlaySystem : EntitySystem
     private void OnInit(EntityUid uid, SeeingRainbowsComponent component, ComponentInit args)
     {
         if (_player.LocalEntity == uid)
+        {
+            _overlay.Phase = _random.NextFloat(MathF.Tau); // random starting phase for movement effect
             _overlayMan.AddOverlay(_overlay);
+        }
     }
 
     private void OnShutdown(EntityUid uid, SeeingRainbowsComponent component, ComponentShutdown args)

Content.Client/Drugs/RainbowOverlay.cs

@@ -24,16 +24,27 @@ public sealed class RainbowOverlay : Overlay
 
     public float Intoxication = 0.0f;
     public float TimeTicker = 0.0f;
+    public float Phase = 0.0f;
 
     private const float VisualThreshold = 10.0f;
     private const float PowerDivisor = 250.0f;
+    private float _timeScale = 0.0f;
+    private float _warpScale = 0.0f;
 
     private float EffectScale => Math.Clamp((Intoxication - VisualThreshold) / PowerDivisor, 0.0f, 1.0f);
 
     public RainbowOverlay()
     {
         IoCManager.InjectDependencies(this);
+
         _rainbowShader = _prototypeManager.Index<ShaderPrototype>("Rainbow").InstanceUnique();
+        _config.OnValueChanged(CCVars.ReducedMotion, OnReducedMotionChanged, invokeImmediately: true);
+    }
+
+    private void OnReducedMotionChanged(bool reducedMotion)
+    {
+        _timeScale = reducedMotion ? 0.0f : 1.0f;
+        _warpScale = reducedMotion ? 0.0f : 1.0f;
     }
 
     protected override void FrameUpdate(FrameEventArgs args)
@@ -51,7 +62,7 @@ public sealed class RainbowOverlay : Overlay
         if (!statusSys.TryGetTime(playerEntity.Value, DrugOverlaySystem.RainbowKey, out var time, status))
             return;
 
-        var timeLeft = (float) (time.Value.Item2 - time.Value.Item1).TotalSeconds;
+        var timeLeft = (float)(time.Value.Item2 - time.Value.Item1).TotalSeconds;
 
         TimeTicker += args.DeltaSeconds;
 
@@ -61,7 +72,7 @@ public sealed class RainbowOverlay : Overlay
         }
         else
         {
-            Intoxication -= Intoxication/(timeLeft - TimeTicker) * args.DeltaSeconds;
+            Intoxication -= Intoxication / (timeLeft - TimeTicker) * args.DeltaSeconds;
         }
     }
 
@@ -78,16 +89,15 @@ public sealed class RainbowOverlay : Overlay
 
     protected override void Draw(in OverlayDrawArgs args)
     {
-        // TODO disable only the motion part or ike's idea (single static frame of the overlay)
-        if (_config.GetCVar(CCVars.ReducedMotion))
-            return;
-
         if (ScreenTexture == null)
             return;
 
         var handle = args.WorldHandle;
         _rainbowShader.SetParameter("SCREEN_TEXTURE", ScreenTexture);
-        _rainbowShader.SetParameter("effectScale", EffectScale);
+        _rainbowShader.SetParameter("colorScale", EffectScale);
+        _rainbowShader.SetParameter("timeScale", _timeScale);
+        _rainbowShader.SetParameter("warpScale", _warpScale * EffectScale);
+        _rainbowShader.SetParameter("phase", Phase);
         handle.UseShader(_rainbowShader);
         handle.DrawRect(args.WorldBounds, Color.White);
         handle.UseShader(null);

Content.Client/Effects/ColorFlashEffectSystem.cs

@@ -13,6 +13,7 @@ public sealed class ColorFlashEffectSystem : SharedColorFlashEffectSystem
 {
     [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly AnimationPlayerSystem _animation = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     /// <summary>
     /// It's a little on the long side but given we use multiple colours denoting what happened it makes it easier to register.
@@ -44,7 +45,7 @@ public sealed class ColorFlashEffectSystem : SharedColorFlashEffectSystem
 
         if (TryComp<SpriteComponent>(uid, out var sprite))
         {
-            sprite.Color = component.Color;
+            _sprite.SetColor((uid, sprite), component.Color);
         }
     }
 

Content.Client/Electrocution/ElectrocutionHUDVisualizerSystem.cs

@@ -11,6 +11,7 @@ namespace Content.Client.Electrocution;
 public sealed class ElectrocutionHUDVisualizerSystem : VisualizerSystem<ElectrocutionHUDVisualsComponent>
 {
     [Dependency] private readonly IPlayerManager _playerMan = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -53,15 +54,12 @@ public sealed class ElectrocutionHUDVisualizerSystem : VisualizerSystem<Electroc
     private void ShowHUD()
     {
         var electrifiedQuery = AllEntityQuery<ElectrocutionHUDVisualsComponent, AppearanceComponent, SpriteComponent>();
-        while (electrifiedQuery.MoveNext(out var uid, out var _, out var appearanceComp, out var spriteComp))
+        while (electrifiedQuery.MoveNext(out var uid, out _, out var appearanceComp, out var spriteComp))
         {
             if (!AppearanceSystem.TryGetData<bool>(uid, ElectrifiedVisuals.IsElectrified, out var electrified, appearanceComp))
                 continue;
 
-            if (electrified)
-                spriteComp.LayerSetVisible(ElectrifiedLayers.HUD, true);
-            else
-                spriteComp.LayerSetVisible(ElectrifiedLayers.HUD, false);
+            _sprite.LayerSetVisible((uid, spriteComp), ElectrifiedLayers.HUD, electrified);
         }
     }
 
@@ -70,10 +68,9 @@ public sealed class ElectrocutionHUDVisualizerSystem : VisualizerSystem<Electroc
     private void RemoveHUD()
     {
         var electrifiedQuery = AllEntityQuery<ElectrocutionHUDVisualsComponent, AppearanceComponent, SpriteComponent>();
-        while (electrifiedQuery.MoveNext(out var uid, out var _, out var appearanceComp, out var spriteComp))
+        while (electrifiedQuery.MoveNext(out var uid, out _, out _, out var spriteComp))
         {
-
-            spriteComp.LayerSetVisible(ElectrifiedLayers.HUD, false);
+            _sprite.LayerSetVisible((uid, spriteComp), ElectrifiedLayers.HUD, false);
         }
     }
 
@@ -87,9 +84,6 @@ public sealed class ElectrocutionHUDVisualizerSystem : VisualizerSystem<Electroc
             return;
 
         var player = _playerMan.LocalEntity;
-        if (electrified && HasComp<ShowElectrocutionHUDComponent>(player))
-            args.Sprite.LayerSetVisible(ElectrifiedLayers.HUD, true);
-        else
-            args.Sprite.LayerSetVisible(ElectrifiedLayers.HUD, false);
+        _sprite.LayerSetVisible((uid, args.Sprite), ElectrifiedLayers.HUD, electrified && HasComp<ShowElectrocutionHUDComponent>(player));
     }
 }

Content.Client/Ensnaring/EnsnareableSystem.cs

@@ -1,12 +1,14 @@
 using Content.Shared.Ensnaring;
 using Content.Shared.Ensnaring.Components;
 using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Ensnaring;
 
 public sealed class EnsnareableSystem : SharedEnsnareableSystem
 {
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -19,25 +21,25 @@ public sealed class EnsnareableSystem : SharedEnsnareableSystem
     {
         base.OnEnsnareInit(ent, ref args);
 
-        if(!TryComp<SpriteComponent>(ent.Owner, out var sprite))
+        if (!TryComp<SpriteComponent>(ent.Owner, out var sprite))
             return;
 
         // TODO remove this, this should just be in yaml.
-        sprite.LayerMapReserveBlank(EnsnaredVisualLayers.Ensnared);
+        _sprite.LayerMapReserve((ent.Owner, sprite), EnsnaredVisualLayers.Ensnared);
     }
 
     private void OnAppearanceChange(EntityUid uid, EnsnareableComponent component, ref AppearanceChangeEvent args)
     {
-        if (args.Sprite == null || !args.Sprite.LayerMapTryGet(EnsnaredVisualLayers.Ensnared, out var layer))
+        if (args.Sprite == null || !_sprite.LayerMapTryGet((uid, args.Sprite), EnsnaredVisualLayers.Ensnared, out var layer, false))
             return;
 
         if (_appearance.TryGetData<bool>(uid, EnsnareableVisuals.IsEnsnared, out var isEnsnared, args.Component))
         {
             if (component.Sprite != null)
             {
-                args.Sprite.LayerSetRSI(layer, component.Sprite);
-                args.Sprite.LayerSetState(layer, component.State);
-                args.Sprite.LayerSetVisible(layer, isEnsnared);
+                _sprite.LayerSetRsi((uid, args.Sprite), layer, new ResPath(component.Sprite));
+                _sprite.LayerSetRsiState((uid, args.Sprite), layer, component.State);
+                _sprite.LayerSetVisible((uid, args.Sprite), layer, isEnsnared);
             }
         }
     }