upstream

CODE_OF_CONDUCT.md

@@ -0,0 +1,40 @@
+# Space Station 14 Code of Conduct
+
+Space Station 14's staff and community is made up volunteers from all over the world, working on every aspect of the project - including development, teaching, and hosting integral tools.
+
+Diversity is one of our huge strengths, but it can also lead to communication issues and unhappiness. To that end, we have a few ground rules that we ask people to adhere to. This code applies equally to all levels of the project, from commenters to contributors to staff.
+
+This isn’t an exhaustive list of things that you can’t do. Rather, take it in the spirit in which it’s intended - a guide to make it easier to enrich all of us and the technical communities in which we participate.
+
+This code of conduct applies specifically to the Github repositories and its spaces managed by the Space Station 14 project or Space Wizards Federation. Some spaces, such as the Space Station 14 Discord or the official Wizard's Den game servers, have their own rules but are in spirit equal to what may be found in here.
+
+If you believe someone is violating the code of conduct, we ask that you report it by contacting a Maintainer, Project Manager or Wizard staff member through [Discord](https://discord.ss14.io/), [the forums](https://forum.spacestation14.com/), or emailing [telecommunications@spacestation14.com](mailto:telecommunications@spacestation14.com).
+
+- **Be friendly and patient.**
+- **Be welcoming.** We strive to be a community that welcomes and supports people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, colour, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability.
+- **Be considerate.** Your work will be used by other people, and you in turn will depend on the work of others. Any decision you take will affect users and contributors, and you should take those consequences into account when making decisions. Remember that we're a world-wide community, so you might not be communicating in someone else's primary language. We have contributors of all skill levels, some even making their first foray into a new field with this project, so keep that in mind when discussing someone's work.
+- **Be respectful.** Not all of us will agree all the time, but disagreement is no excuse for poor behavior and poor manners. We might all experience some frustration now and then, but we cannot allow that frustration to turn into a personal attack. It’s important to remember that a community where people feel uncomfortable or threatened is not a productive one. Members of the Space Station 14 community should be respectful when dealing with other members as well as with people outside the Space Station 14 community. Assume contributions to the project, even those that do not end up being included, are made in good faith.
+- **Be careful in the words that you choose.** We are a community of professionals, and we conduct ourselves professionally. Be kind to others. Do not insult or put down other participants. Harassment and other exclusionary behavior aren't acceptable. This includes, but is not limited to:
+  - Violent threats or language directed against another person.
+  - Discriminatory jokes and language.
+  - Posting sexually explicit or violent material.
+  - Posting (or threatening to post) other people's personally identifying information ("doxing").
+  - Personal insults, especially those using racist or sexist terms.
+  - Unwelcome sexual attention.
+  - Advocating for, or encouraging, any of the above behavior.
+  - Repeated harassment of others. In general, if someone asks you to stop, then stop.
+- **When we disagree, try to understand why.** Disagreements, both social and technical, happen all the time and Space Station 14 is no exception. It is important that we resolve disagreements and differing views constructively. Remember that we’re different. The strength of Space Station 14 comes from its varied community, people from a wide range of backgrounds. Different people have different perspectives on issues. Being unable to understand why someone holds a viewpoint doesn’t mean that they’re wrong. Don’t forget that it is human to make mistakes and blaming each other doesn’t get us anywhere. Instead, focus on helping to resolve issues and learning from mistakes.
+
+Original text courtesy of the [Speak Up! project](http://web.archive.org/web/20141109123859/http://speakup.io/coc.html).
+
+## On Comunity Moderation
+
+Deviating from the Code of Conduct on the Github repository may result in moderative actions taken by project Maintainers. This can involve your content being edited or deleted, and may result in a temporary or permanent block from the repository.
+
+This is to ensure Space Station 14 is a healthy community in which contributors feel encouraged and empowered to contribute, and to give you as a member of this community a chance to reflect on how you are interacting with it. While outright offensive and bigoted content will *always* be unacceptable on the repository, Maintainers are at liberty to take moderative actions against more ambiguous content that fail to provide constructive criticism, or that provides constructive criticism in a non-constructive manner. Examples of this include using hyperbole, bringing up PRs/changes unrelated to the discussion at hand, hostile tone, off-topic comments, creating PRs/Issues for the sole purpose of causing discussions, skirting the line of acceptable behavior, etc. Disagreeing with content or each other is fine and appreciated, but only as long as it's done with respect and in a constructive manner.
+
+Maintainers are expected to adhere to the guidelines as listed in the [Github Moderation Guidelines](https://docs.spacestation14.com/en/general-development/github-moderation-guidelines.html), though may deviate should they feel it's in the best interest of the community. If you believe you had an action incorrectly applied against you, you are encouraged to contact staff via [Discord](https://discord.ss14.io/) or [the forums](https://forum.spacestation14.com/), [appeal your Github ban](https://forum.spacestation14.com/c/ban-appeals/appeals-github/38), or make a [staff complaint](https://forum.spacestation14.com/t/staff-complaint-instructions-and-info/31).
+
+## Attribution
+
+This Code of Conduct is an edited version of the [Django Code of Conduct](https://www.djangoproject.com/conduct/), licensed under CC BY 3.0, for the Space Station 14 Github repository.

Content.Benchmarks/MapLoadBenchmark.cs

@@ -47,7 +47,7 @@ public class MapLoadBenchmark
         PoolManager.Shutdown();
     }
 
-    public static readonly string[] MapsSource = { "Empty", "Satlern", "Box", "Bagel", "Dev", "CentComm", "Core", "TestTeg", "Packed", "Omega", "Reach", "Meta", "Marathon", "MeteorArena", "Fland", "Oasis", "Convex"};
+    public static readonly string[] MapsSource = { "Empty", "Saltern", "Box", "Bagel", "Dev", "CentComm", "Core", "TestTeg", "Packed", "Omega", "Reach", "Meta", "Marathon", "MeteorArena", "Fland", "Oasis", "Convex"};
 
     [ParamsSource(nameof(MapsSource))]
     public string Map;

Content.Client/Access/Commands/ShowAccessReadersCommand.cs

@@ -4,39 +4,20 @@ using Robust.Shared.Console;
 
 namespace Content.Client.Access.Commands;
 
-public sealed class ShowAccessReadersCommand : IConsoleCommand
+public sealed class ShowAccessReadersCommand : LocalizedEntityCommands
 {
-    public string Command => "showaccessreaders";
+    [Dependency] private readonly IOverlayManager _overlay = default!;
+    [Dependency] private readonly IResourceCache _cache = default!;
+    [Dependency] private readonly SharedTransformSystem _xform = default!;
 
-    public string Description => "Toggles showing access reader permissions on the map";
-    public string Help => """
-        Overlay Info:
-        -Disabled | The access reader is disabled
-        +Unrestricted | The access reader has no restrictions
-        +Set [Index]: [Tag Name]| A tag in an access set (accessor needs all tags in the set to be allowed by the set)
-        +Key [StationUid]: [StationRecordKeyId] | A StationRecordKey that is allowed
-        -Tag [Tag Name] | A tag that is not allowed (takes priority over other allows)
-        """;
-    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    public override string Command => "showaccessreaders";
+
+    public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        var collection = IoCManager.Instance;
+        var existing = _overlay.RemoveOverlay<AccessOverlay>();
+        if (!existing)
+            _overlay.AddOverlay(new AccessOverlay(EntityManager, _cache, _xform));
 
-        if (collection == null)
-            return;
-
-        var overlay = collection.Resolve<IOverlayManager>();
-
-        if (overlay.RemoveOverlay<AccessOverlay>())
-        {
-            shell.WriteLine($"Set access reader debug overlay to false");
-            return;
-        }
-
-        var entManager = collection.Resolve<IEntityManager>();
-        var cache = collection.Resolve<IResourceCache>();
-        var xform = entManager.System<SharedTransformSystem>();
-
-        overlay.AddOverlay(new AccessOverlay(entManager, cache, xform));
-        shell.WriteLine($"Set access reader debug overlay to true");
+        shell.WriteLine(Loc.GetString($"cmd-showaccessreaders-status", ("status", !existing)));
     }
 }

Content.Client/Access/UI/GroupedAccessLevelChecklist.xaml

@@ -0,0 +1,26 @@
+<BoxContainer xmlns="https://spacestation14.io"
+              xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+              Orientation="Horizontal"
+              Margin="10 10 10 10"
+              VerticalExpand="True"
+              HorizontalExpand="True"
+              MinHeight="70">
+
+    <!-- Access groups -->
+    <BoxContainer Name="AccessGroupList" Access="Public" Orientation="Vertical" HorizontalExpand="True" SizeFlagsStretchRatio="0.5" Margin="0 0 10 0">
+        <!-- Populated with C# code -->
+    </BoxContainer>
+
+    <PanelContainer StyleClasses="LowDivider" VerticalExpand="True" Margin="0 0 0 0" SetWidth="2">
+        <PanelContainer.PanelOverride>
+            <gfx:StyleBoxFlat BackgroundColor="#FFFFFF" />
+        </PanelContainer.PanelOverride>
+    </PanelContainer>
+
+    <!-- Access levels -->
+    <ScrollContainer HorizontalExpand="True" VerticalExpand="True" Margin="10 0 0 0">
+        <BoxContainer Name="AccessLevelChecklist" Access="Public" Orientation="Vertical" HorizontalAlignment="Left">
+            <!-- Populated with C# code -->
+        </BoxContainer>
+    </ScrollContainer>
+</BoxContainer>

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

@@ -0,0 +1,449 @@
+using Content.Client.Stylesheets;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Access;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using System.Linq;
+using System.Numerics;
+
+namespace Content.Client.Access.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class GroupedAccessLevelChecklist : BoxContainer
+{
+    [Dependency] private readonly IPrototypeManager _protoManager = default!;
+
+    private bool _isMonotone;
+    private string? _labelStyleClass;
+
+    // Access data
+    private HashSet<ProtoId<AccessGroupPrototype>> _accessGroups = new();
+    private HashSet<ProtoId<AccessLevelPrototype>> _accessLevels = new();
+    private HashSet<ProtoId<AccessLevelPrototype>> _activeAccessLevels = new();
+
+    // Button groups
+    private readonly ButtonGroup _accessGroupsButtons = new();
+
+    // Temp values
+    private int _accessGroupTabIndex = 0;
+    private bool _canInteract = false;
+    private List<AccessLevelPrototype> _accessLevelsForTab = new();
+    private readonly List<AccessLevelEntry> _accessLevelEntries = new();
+    private readonly Dictionary<AccessGroupPrototype, List<AccessLevelPrototype>> _groupedAccessLevels = new();
+
+    // Events
+    public event Action<HashSet<ProtoId<AccessLevelPrototype>>, bool>? OnAccessLevelsChangedEvent;
+
+    /// <summary>
+    /// Creates a UI control for changing access levels.
+    /// Access levels are organized under a list of tabs by their associated access group.
+    /// </summary>
+    public GroupedAccessLevelChecklist()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+    }
+
+    private void ArrangeAccessControls()
+    {
+        // Create a list of known access groups with which to populate the UI
+        _groupedAccessLevels.Clear();
+
+        foreach (var accessGroup in _accessGroups)
+        {
+            if (!_protoManager.TryIndex(accessGroup, out var accessGroupProto))
+                continue;
+
+            _groupedAccessLevels.Add(accessGroupProto, new());
+        }
+
+        // Ensure that the 'general' access group is added to handle
+        // misc. access levels that aren't associated with any group
+        if (_protoManager.TryIndex<AccessGroupPrototype>("General", out var generalAccessProto))
+            _groupedAccessLevels.TryAdd(generalAccessProto, new());
+
+        // Assign known access levels with their associated groups
+        foreach (var accessLevel in _accessLevels)
+        {
+            if (!_protoManager.TryIndex(accessLevel, out var accessLevelProto))
+                continue;
+
+            var assigned = false;
+
+            foreach (var (accessGroup, accessLevels) in _groupedAccessLevels)
+            {
+                if (!accessGroup.Tags.Contains(accessLevelProto.ID))
+                    continue;
+
+                assigned = true;
+                _groupedAccessLevels[accessGroup].Add(accessLevelProto);
+            }
+
+            if (!assigned && generalAccessProto != null)
+                _groupedAccessLevels[generalAccessProto].Add(accessLevelProto);
+        }
+
+        // Remove access groups that have no assigned access levels
+        foreach (var (group, accessLevels) in _groupedAccessLevels)
+        {
+            if (accessLevels.Count == 0)
+                _groupedAccessLevels.Remove(group);
+        }
+    }
+
+    private bool TryRebuildAccessGroupControls()
+    {
+        AccessGroupList.DisposeAllChildren();
+        AccessLevelChecklist.DisposeAllChildren();
+
+        // No access level prototypes were assigned to any of the access level groups.
+        // Either the turret controller has no assigned access levels or their names were invalid.
+        if (_groupedAccessLevels.Count == 0)
+            return false;
+
+        // Reorder the access groups alphabetically
+        var orderedAccessGroups = _groupedAccessLevels.Keys.OrderBy(x => x.GetAccessGroupName()).ToList();
+
+        // Add group access buttons to the UI
+        foreach (var accessGroup in orderedAccessGroups)
+        {
+            var accessGroupButton = CreateAccessGroupButton();
+
+            // Button styling
+            if (_groupedAccessLevels.Count > 1)
+            {
+                if (AccessGroupList.ChildCount == 0)
+                    accessGroupButton.AddStyleClass(StyleBase.ButtonOpenLeft);
+                else if (_groupedAccessLevels.Count > 1 && AccessGroupList.ChildCount == (_groupedAccessLevels.Count - 1))
+                    accessGroupButton.AddStyleClass(StyleBase.ButtonOpenRight);
+                else
+                    accessGroupButton.AddStyleClass(StyleBase.ButtonOpenBoth);
+            }
+
+            accessGroupButton.Pressed = _accessGroupTabIndex == orderedAccessGroups.IndexOf(accessGroup);
+
+            // Label text and styling
+            if (_labelStyleClass != null)
+                accessGroupButton.Label.SetOnlyStyleClass(_labelStyleClass);
+
+            var accessLevelPrototypes = _groupedAccessLevels[accessGroup];
+            var prefix = accessLevelPrototypes.All(x => _activeAccessLevels.Contains(x))
+                ? "»"
+                : accessLevelPrototypes.Any(x => _activeAccessLevels.Contains(x))
+                    ? "›"
+                    : " ";
+
+            var text = Loc.GetString(
+                "turret-controls-window-access-group-label",
+                ("prefix", prefix),
+                ("label", accessGroup.GetAccessGroupName())
+            );
+
+            accessGroupButton.Text = text;
+
+            // Button events
+            accessGroupButton.OnPressed += _ => OnAccessGroupChanged(accessGroupButton.GetPositionInParent());
+
+            AccessGroupList.AddChild(accessGroupButton);
+        }
+
+        // Adjust the current tab index so it remains in range
+        if (_accessGroupTabIndex >= _groupedAccessLevels.Count)
+            _accessGroupTabIndex = _groupedAccessLevels.Count - 1;
+
+        return true;
+    }
+
+    /// <summary>
+    /// Rebuilds the checkbox list for the access level controls.
+    /// </summary>
+    public void RebuildAccessLevelsControls()
+    {
+        AccessLevelChecklist.DisposeAllChildren();
+        _accessLevelEntries.Clear();
+
+        // No access level prototypes were assigned to any of the access level groups
+        // Either turret controller has no assigned access levels, or their names were invalid
+        if (_groupedAccessLevels.Count == 0)
+            return;
+
+        // Reorder the access groups alphabetically
+        var orderedAccessGroups = _groupedAccessLevels.Keys.OrderBy(x => x.GetAccessGroupName()).ToList();
+
+        // Get the access levels associated with the current tab
+        var selectedAccessGroupTabProto = orderedAccessGroups[_accessGroupTabIndex];
+        _accessLevelsForTab = _groupedAccessLevels[selectedAccessGroupTabProto];
+        _accessLevelsForTab = _accessLevelsForTab.OrderBy(x => x.GetAccessLevelName()).ToList();
+
+        // Add an 'all' checkbox as the first child of the list if it has more than one access level
+        // Toggling this checkbox on will mark all other boxes below it on/off
+        var allCheckBox = CreateAccessLevelCheckbox();
+        allCheckBox.Text = Loc.GetString("turret-controls-window-all-checkbox");
+
+        if (_labelStyleClass != null)
+            allCheckBox.Label.SetOnlyStyleClass(_labelStyleClass);
+
+        // Add the 'all' checkbox events
+        allCheckBox.OnPressed += args =>
+        {
+            SetCheckBoxPressedState(_accessLevelEntries, allCheckBox.Pressed);
+
+            var accessLevels = new HashSet<ProtoId<AccessLevelPrototype>>();
+
+            foreach (var accessLevel in _accessLevelsForTab)
+            {
+                accessLevels.Add(accessLevel);
+            }
+
+            OnAccessLevelsChangedEvent?.Invoke(accessLevels, allCheckBox.Pressed);
+        };
+
+        AccessLevelChecklist.AddChild(allCheckBox);
+
+        // Hide the 'all' checkbox if the tab has only one access level
+        var allCheckBoxVisible = _accessLevelsForTab.Count > 1;
+
+        allCheckBox.Visible = allCheckBoxVisible;
+        allCheckBox.Disabled = !_canInteract;
+
+        // Add any remaining missing access level buttons to the UI
+        foreach (var accessLevel in _accessLevelsForTab)
+        {
+            // Create the entry
+            var accessLevelEntry = new AccessLevelEntry(_isMonotone);
+
+            accessLevelEntry.AccessLevel = accessLevel;
+            accessLevelEntry.CheckBox.Text = accessLevel.GetAccessLevelName();
+            accessLevelEntry.CheckBox.Pressed = _activeAccessLevels.Contains(accessLevel);
+            accessLevelEntry.CheckBox.Disabled = !_canInteract;
+
+            if (_labelStyleClass != null)
+                accessLevelEntry.CheckBox.Label.SetOnlyStyleClass(_labelStyleClass);
+
+            // Set the checkbox linkage lines
+            var isEndOfList = _accessLevelsForTab.IndexOf(accessLevel) == (_accessLevelsForTab.Count - 1);
+
+            var lines = new List<(Vector2, Vector2)>
+            {
+                (new Vector2(0.5f, 0f), new Vector2(0.5f, isEndOfList ? 0.5f : 1f)),
+                (new Vector2(0.5f, 0.5f), new Vector2(1f, 0.5f)),
+            };
+
+            accessLevelEntry.UpdateCheckBoxLink(lines);
+            accessLevelEntry.CheckBoxLink.Visible = allCheckBoxVisible;
+            accessLevelEntry.CheckBoxLink.Modulate = !_canInteract ? Color.Gray : Color.White;
+
+            // Add checkbox events
+            accessLevelEntry.CheckBox.OnPressed += args =>
+            {
+                // If the checkbox and its siblings are checked, check the 'all' checkbox too
+                allCheckBox.Pressed = AreAllCheckBoxesPressed(_accessLevelEntries.Select(x => x.CheckBox));
+
+                OnAccessLevelsChangedEvent?.Invoke([accessLevelEntry.AccessLevel], accessLevelEntry.CheckBox.Pressed);
+            };
+
+            AccessLevelChecklist.AddChild(accessLevelEntry);
+            _accessLevelEntries.Add(accessLevelEntry);
+        }
+
+        // Press the 'all' checkbox if all others are pressed
+        allCheckBox.Pressed = AreAllCheckBoxesPressed(_accessLevelEntries.Select(x => x.CheckBox));
+    }
+
+    private bool AreAllCheckBoxesPressed(IEnumerable<CheckBox> checkBoxes)
+    {
+        foreach (var checkBox in checkBoxes)
+        {
+            if (!checkBox.Pressed)
+                return false;
+        }
+
+        return true;
+    }
+
+    private void SetCheckBoxPressedState(List<AccessLevelEntry> accessLevelEntries, bool pressed)
+    {
+        foreach (var accessLevelEntry in accessLevelEntries)
+        {
+            accessLevelEntry.CheckBox.Pressed = pressed;
+        }
+    }
+
+
+    /// <summary>
+    /// Provides the UI with a list of access groups using which list of tabs should be populated.
+    /// </summary>
+    public void SetAccessGroups(HashSet<ProtoId<AccessGroupPrototype>> accessGroups)
+    {
+        _accessGroups = accessGroups;
+
+        ArrangeAccessControls();
+
+        if (TryRebuildAccessGroupControls())
+            RebuildAccessLevelsControls();
+    }
+
+    /// <summary>
+    /// Provides the UI with a list of access levels with which it can populate the currently selected tab.
+    /// </summary>
+    public void SetAccessLevels(HashSet<ProtoId<AccessLevelPrototype>> accessLevels)
+    {
+        _accessLevels = accessLevels;
+
+        ArrangeAccessControls();
+
+        if (TryRebuildAccessGroupControls())
+            RebuildAccessLevelsControls();
+    }
+
+    /// <summary>
+    /// Sets which access level checkboxes should be marked on the UI.
+    /// </summary>
+    public void SetActiveAccessLevels(HashSet<ProtoId<AccessLevelPrototype>> activeAccessLevels)
+    {
+        _activeAccessLevels = activeAccessLevels;
+
+        if (TryRebuildAccessGroupControls())
+            RebuildAccessLevelsControls();
+    }
+
+    /// <summary>
+    /// Sets whether the local player can interact with the checkboxes.
+    /// </summary>
+    public void SetLocalPlayerAccessibility(bool canInteract)
+    {
+        _canInteract = canInteract;
+
+        if (TryRebuildAccessGroupControls())
+            RebuildAccessLevelsControls();
+    }
+
+    /// <summary>
+    /// Sets whether the UI should use monotone buttons and checkboxes.
+    /// </summary>
+    public void SetMonotone(bool monotone)
+    {
+        _isMonotone = monotone;
+
+        if (TryRebuildAccessGroupControls())
+            RebuildAccessLevelsControls();
+    }
+
+    /// <summary>
+    /// Applies the specified style to the labels on the UI buttons and checkboxes.
+    /// </summary>
+    public void SetLabelStyleClass(string? styleClass)
+    {
+        _labelStyleClass = styleClass;
+
+        if (TryRebuildAccessGroupControls())
+            RebuildAccessLevelsControls();
+    }
+
+    private void OnAccessGroupChanged(int newTabIndex)
+    {
+        if (newTabIndex == _accessGroupTabIndex)
+            return;
+
+        _accessGroupTabIndex = newTabIndex;
+
+        if (TryRebuildAccessGroupControls())
+            RebuildAccessLevelsControls();
+    }
+
+    private Button CreateAccessGroupButton()
+    {
+        var button = _isMonotone ? new MonotoneButton() : new Button();
+
+        button.ToggleMode = true;
+        button.Group = _accessGroupsButtons;
+        button.Label.HorizontalAlignment = HAlignment.Left;
+
+        return button;
+    }
+
+    private CheckBox CreateAccessLevelCheckbox()
+    {
+        var checkbox = _isMonotone ? new MonotoneCheckBox() : new CheckBox();
+
+        checkbox.Margin = new Thickness(0, 0, 0, 3);
+        checkbox.ToggleMode = true;
+        checkbox.ReservesSpace = false;
+
+        return checkbox;
+    }
+
+    private sealed class AccessLevelEntry : BoxContainer
+    {
+        public ProtoId<AccessLevelPrototype> AccessLevel;
+        public readonly CheckBox CheckBox;
+        public readonly LineRenderer CheckBoxLink;
+
+        public AccessLevelEntry(bool monotone)
+        {
+            HorizontalExpand = true;
+
+            CheckBoxLink = new LineRenderer
+            {
+                SetWidth = 22,
+                VerticalExpand = true,
+                Margin = new Thickness(0, -1),
+                ReservesSpace = false,
+            };
+
+            AddChild(CheckBoxLink);
+
+            CheckBox = monotone ? new MonotoneCheckBox() : new CheckBox();
+            CheckBox.ToggleMode = true;
+            CheckBox.Margin = new Thickness(0f, 0f, 0f, 3f);
+
+            AddChild(CheckBox);
+        }
+
+        public void UpdateCheckBoxLink(List<(Vector2, Vector2)> lines)
+        {
+            CheckBoxLink.Lines = lines;
+        }
+    }
+
+    private sealed class LineRenderer : Control
+    {
+        /// <summary>
+        /// List of lines to render (their start and end x-y coordinates).
+        /// Position (0,0) is the top left corner of the control and
+        /// position (1,1) is the bottom right corner.
+        /// </summary>
+        /// <remarks>
+        /// The color of the lines is inherited from the control.
+        /// </remarks>
+        public List<(Vector2, Vector2)> Lines;
+
+        public LineRenderer()
+        {
+            Lines = new List<(Vector2, Vector2)>();
+        }
+
+        public LineRenderer(List<(Vector2, Vector2)> lines)
+        {
+            Lines = lines;
+        }
+
+        protected override void Draw(DrawingHandleScreen handle)
+        {
+            foreach (var line in Lines)
+            {
+                var start = PixelPosition +
+                            new Vector2(PixelWidth * line.Item1.X, PixelHeight * line.Item1.Y);
+
+                var end = PixelPosition +
+                          new Vector2(PixelWidth * line.Item2.X, PixelHeight * line.Item2.Y);
+
+                handle.DrawLine(start, end, ActualModulateSelf);
+            }
+        }
+    }
+}

Content.Client/Actions/ActionEvents.cs

@@ -1,3 +1,6 @@
+using Content.Shared.Actions.Components;
+using static Robust.Shared.Input.Binding.PointerInputCmdHandler;
+
 namespace Content.Client.Actions;
 
 /// <summary>
@@ -7,3 +10,17 @@ public sealed class FillActionSlotEvent : EntityEventArgs
 {
     public EntityUid? Action;
 }
+
+/// <summary>
+/// Client-side event used to attempt to trigger a targeted action.
+/// This only gets raised if the has <see cref="TargetActionComponent">.
+/// Handlers must set <c>Handled</c> to true, then if the action has been performed,
+/// i.e. a target is found, then FoundTarget must be set to true.
+/// </summary>
+[ByRefEvent]
+public record struct ActionTargetAttemptEvent(
+    PointerInputCmdArgs Input,
+    Entity<ActionsComponent> User,
+    ActionComponent Action,
+    bool Handled = false,
+    bool FoundTarget = false);

Content.Client/Actions/ActionsSystem.cs

@@ -1,18 +1,23 @@
 using System.IO;
 using System.Linq;
 using Content.Shared.Actions;
+using Content.Shared.Actions.Components;
 using Content.Shared.Charges.Systems;
+using Content.Shared.Mapping;
+using Content.Shared.Maps;
 using JetBrains.Annotations;
 using Robust.Client.Player;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameStates;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Sequence;
 using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using YamlDotNet.RepresentationModel;
 
@@ -25,8 +30,8 @@ namespace Content.Client.Actions
 
         [Dependency] private readonly SharedChargesSystem _sharedCharges = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly IPrototypeManager _proto = default!;
         [Dependency] private readonly IResourceManager _resources = default!;
-        [Dependency] private readonly ISerializationManager _serialization = default!;
         [Dependency] private readonly MetaDataSystem _metaData = default!;
 
         public event Action<EntityUid>? OnActionAdded;
@@ -38,131 +43,67 @@ namespace Content.Client.Actions
         public event Action<List<SlotAssignment>>? AssignSlot;
 
         private readonly List<EntityUid> _removed = new();
-        private readonly List<(EntityUid, BaseActionComponent?)> _added = new();
+        private readonly List<Entity<ActionComponent>> _added = new();
+
+        public static readonly EntProtoId MappingEntityAction = "BaseMappingEntityAction";
 
         public override void Initialize()
         {
             base.Initialize();
+
             SubscribeLocalEvent<ActionsComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
             SubscribeLocalEvent<ActionsComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
-            SubscribeLocalEvent<ActionsComponent, ComponentHandleState>(HandleComponentState);
+            SubscribeLocalEvent<ActionsComponent, ComponentHandleState>(OnHandleState);
 
-            SubscribeLocalEvent<InstantActionComponent, ComponentHandleState>(OnInstantHandleState);
-            SubscribeLocalEvent<EntityTargetActionComponent, ComponentHandleState>(OnEntityTargetHandleState);
-            SubscribeLocalEvent<WorldTargetActionComponent, ComponentHandleState>(OnWorldTargetHandleState);
-            SubscribeLocalEvent<EntityWorldTargetActionComponent, ComponentHandleState>(OnEntityWorldTargetHandleState);
+            SubscribeLocalEvent<ActionComponent, AfterAutoHandleStateEvent>(OnActionAutoHandleState);
+
+            SubscribeLocalEvent<EntityTargetActionComponent, ActionTargetAttemptEvent>(OnEntityTargetAttempt);
+            SubscribeLocalEvent<WorldTargetActionComponent, ActionTargetAttemptEvent>(OnWorldTargetAttempt);
         }
 
-        private void OnInstantHandleState(EntityUid uid, InstantActionComponent component, ref ComponentHandleState args)
-        {
-            if (args.Current is not InstantActionComponentState state)
-                return;
 
-            BaseHandleState<InstantActionComponent>(uid, component, state);
+        private void OnActionAutoHandleState(Entity<ActionComponent> ent, ref AfterAutoHandleStateEvent args)
+        {
+            UpdateAction(ent);
         }
 
-        private void OnEntityTargetHandleState(EntityUid uid, EntityTargetActionComponent component, ref ComponentHandleState args)
+        public override void UpdateAction(Entity<ActionComponent> ent)
         {
-            if (args.Current is not EntityTargetActionComponentState state)
-                return;
-
-            component.Whitelist = state.Whitelist;
-            component.Blacklist = state.Blacklist;
-            component.CanTargetSelf = state.CanTargetSelf;
-            BaseHandleState<EntityTargetActionComponent>(uid, component, state);
-        }
-
-        private void OnWorldTargetHandleState(EntityUid uid, WorldTargetActionComponent component, ref ComponentHandleState args)
-        {
-            if (args.Current is not WorldTargetActionComponentState state)
-                return;
-
-            BaseHandleState<WorldTargetActionComponent>(uid, component, state);
-        }
-
-        private void OnEntityWorldTargetHandleState(EntityUid uid,
-            EntityWorldTargetActionComponent component,
-            ref ComponentHandleState args)
-        {
-            if (args.Current is not EntityWorldTargetActionComponentState state)
-                return;
-
-            component.Whitelist = state.Whitelist;
-            component.CanTargetSelf = state.CanTargetSelf;
-            BaseHandleState<EntityWorldTargetActionComponent>(uid, component, state);
-        }
-
-        private void BaseHandleState<T>(EntityUid uid, BaseActionComponent component, BaseActionComponentState state) where T : BaseActionComponent
-        {
-            // TODO ACTIONS use auto comp states
-            component.Icon = state.Icon;
-            component.IconOn = state.IconOn;
-            component.IconColor = state.IconColor;
-            component.OriginalIconColor = state.OriginalIconColor;
-            component.DisabledIconColor = state.DisabledIconColor;
-            component.Keywords.Clear();
-            component.Keywords.UnionWith(state.Keywords);
-            component.Enabled = state.Enabled;
-            component.Toggled = state.Toggled;
-            component.Cooldown = state.Cooldown;
-            component.UseDelay = state.UseDelay;
-            component.Container = EnsureEntity<T>(state.Container, uid);
-            component.EntityIcon = EnsureEntity<T>(state.EntityIcon, uid);
-            component.CheckCanInteract = state.CheckCanInteract;
-            component.CheckConsciousness = state.CheckConsciousness;
-            component.ClientExclusive = state.ClientExclusive;
-            component.Priority = state.Priority;
-            component.AttachedEntity = EnsureEntity<T>(state.AttachedEntity, uid);
-            component.RaiseOnUser = state.RaiseOnUser;
-            component.RaiseOnAction = state.RaiseOnAction;
-            component.AutoPopulate = state.AutoPopulate;
-            component.Temporary = state.Temporary;
-            component.ItemIconStyle = state.ItemIconStyle;
-            component.Sound = state.Sound;
-
-            UpdateAction(uid, component);
-        }
-
-        public override void UpdateAction(EntityUid? actionId, BaseActionComponent? action = null)
-        {
-            if (!ResolveActionData(actionId, ref action))
-                return;
-
             // TODO: Decouple this.
-            action.IconColor = _sharedCharges.GetCurrentCharges(actionId.Value) == 0 ? action.DisabledIconColor : action.OriginalIconColor;
-
-            base.UpdateAction(actionId, action);
-            if (_playerManager.LocalEntity != action.AttachedEntity)
+            ent.Comp.IconColor = _sharedCharges.GetCurrentCharges(ent.Owner) == 0 ? ent.Comp.DisabledIconColor : ent.Comp.OriginalIconColor;
+            base.UpdateAction(ent);
+            if (_playerManager.LocalEntity != ent.Comp.AttachedEntity)
                 return;
 
             ActionsUpdated?.Invoke();
         }
 
-        private void HandleComponentState(EntityUid uid, ActionsComponent component, ref ComponentHandleState args)
+        private void OnHandleState(Entity<ActionsComponent> ent, ref ComponentHandleState args)
         {
             if (args.Current is not ActionsComponentState state)
                 return;
 
+            var (uid, comp) = ent;
             _added.Clear();
             _removed.Clear();
             var stateEnts = EnsureEntitySet<ActionsComponent>(state.Actions, uid);
-            foreach (var act in component.Actions)
+            foreach (var act in comp.Actions)
             {
                 if (!stateEnts.Contains(act) && !IsClientSide(act))
                     _removed.Add(act);
             }
-            component.Actions.ExceptWith(_removed);
+            comp.Actions.ExceptWith(_removed);
 
             foreach (var actionId in stateEnts)
             {
                 if (!actionId.IsValid())
                     continue;
 
-                if (!component.Actions.Add(actionId))
+                if (!comp.Actions.Add(actionId))
                     continue;
 
-                TryGetActionData(actionId, out var action);
-                _added.Add((actionId, action));
+                if (GetAction(actionId) is {} action)
+                    _added.Add(action);
             }
 
             if (_playerManager.LocalEntity != uid)
@@ -177,47 +118,46 @@ namespace Content.Client.Actions
 
             foreach (var action in _added)
             {
-                OnActionAdded?.Invoke(action.Item1);
+                OnActionAdded?.Invoke(action);
             }
 
             ActionsUpdated?.Invoke();
         }
 
-        public static int ActionComparer((EntityUid, BaseActionComponent?) a, (EntityUid, BaseActionComponent?) b)
+        public static int ActionComparer(Entity<ActionComponent> a, Entity<ActionComponent> b)
         {
-            var priorityA = a.Item2?.Priority ?? 0;
-            var priorityB = b.Item2?.Priority ?? 0;
+            var priorityA = a.Comp?.Priority ?? 0;
+            var priorityB = b.Comp?.Priority ?? 0;
             if (priorityA != priorityB)
                 return priorityA - priorityB;
 
-            priorityA = a.Item2?.Container?.Id ?? 0;
-            priorityB = b.Item2?.Container?.Id ?? 0;
+            priorityA = a.Comp?.Container?.Id ?? 0;
+            priorityB = b.Comp?.Container?.Id ?? 0;
             return priorityA - priorityB;
         }
 
-        protected override void ActionAdded(EntityUid performer, EntityUid actionId, ActionsComponent comp,
-            BaseActionComponent action)
+        protected override void ActionAdded(Entity<ActionsComponent> performer, Entity<ActionComponent> action)
         {
-            if (_playerManager.LocalEntity != performer)
+            if (_playerManager.LocalEntity != performer.Owner)
                 return;
 
-            OnActionAdded?.Invoke(actionId);
+            OnActionAdded?.Invoke(action);
             ActionsUpdated?.Invoke();
         }
 
-        protected override void ActionRemoved(EntityUid performer, EntityUid actionId, ActionsComponent comp, BaseActionComponent action)
+        protected override void ActionRemoved(Entity<ActionsComponent> performer, Entity<ActionComponent> action)
         {
-            if (_playerManager.LocalEntity != performer)
+            if (_playerManager.LocalEntity != performer.Owner)
                 return;
 
-            OnActionRemoved?.Invoke(actionId);
+            OnActionRemoved?.Invoke(action);
             ActionsUpdated?.Invoke();
         }
 
-        public IEnumerable<(EntityUid Id, BaseActionComponent Comp)> GetClientActions()
+        public IEnumerable<Entity<ActionComponent>> GetClientActions()
         {
             if (_playerManager.LocalEntity is not { } user)
-                return Enumerable.Empty<(EntityUid, BaseActionComponent)>();
+                return Enumerable.Empty<Entity<ActionComponent>>();
 
             return GetActions(user);
         }
@@ -254,24 +194,23 @@ namespace Content.Client.Actions
             CommandBinds.Unregister<ActionsSystem>();
         }
 
-        public void TriggerAction(EntityUid actionId, BaseActionComponent action)
+        public void TriggerAction(Entity<ActionComponent> action)
         {
-            if (_playerManager.LocalEntity is not { } user ||
-                !TryComp(user, out ActionsComponent? actions))
-            {
-                return;
-            }
-
-            if (action is not InstantActionComponent instantAction)
+            if (_playerManager.LocalEntity is not { } user)
                 return;
 
-            if (action.ClientExclusive)
+            // TODO: unhardcode this somehow
+
+            if (!HasComp<InstantActionComponent>(action))
+                return;
+
+            if (action.Comp.ClientExclusive)
             {
-                PerformAction(user, actions, actionId, instantAction, instantAction.Event, GameTiming.CurTime);
+                PerformAction(user, action);
             }
             else
             {
-                var request = new RequestPerformActionEvent(GetNetEntity(actionId));
+                var request = new RequestPerformActionEvent(GetNetEntity(action));
                 EntityManager.RaisePredictiveEvent(request);
             }
         }
@@ -295,39 +234,137 @@ namespace Content.Client.Actions
             if (yamlStream.Documents[0].RootNode.ToDataNode() is not SequenceDataNode sequence)
                 return;
 
+            var actions = EnsureComp<ActionsComponent>(user);
+
             ClearAssignments?.Invoke();
 
             var assignments = new List<SlotAssignment>();
-
             foreach (var entry in sequence.Sequence)
             {
                 if (entry is not MappingDataNode map)
                     continue;
 
-                if (!map.TryGet("action", out var actionNode))
-                    continue;
-
-                var action = _serialization.Read<BaseActionComponent>(actionNode, notNullableOverride: true);
-                var actionId = Spawn();
-                AddComp(actionId, action);
-                AddActionDirect(user, actionId);
-
-                if (map.TryGet<ValueDataNode>("name", out var nameNode))
-                    _metaData.SetEntityName(actionId, nameNode.Value);
-
                 if (!map.TryGet("assignments", out var assignmentNode))
                     continue;
 
-                var nodeAssignments = _serialization.Read<List<(byte Hotbar, byte Slot)>>(assignmentNode, notNullableOverride: true);
-
-                foreach (var index in nodeAssignments)
+                var actionId = EntityUid.Invalid;
+                if (map.TryGet<ValueDataNode>("action", out var actionNode))
                 {
-                    var assignment = new SlotAssignment(index.Hotbar, index.Slot, actionId);
-                    assignments.Add(assignment);
+                    var id = new EntProtoId(actionNode.Value);
+                    actionId = Spawn(id);
                 }
+                else if (map.TryGet<ValueDataNode>("entity", out var entityNode))
+                {
+                    var id = new EntProtoId(entityNode.Value);
+                    var proto = _proto.Index(id);
+                    actionId = Spawn(MappingEntityAction);
+                    SetIcon(actionId, new SpriteSpecifier.EntityPrototype(id));
+                    SetEvent(actionId, new StartPlacementActionEvent()
+                    {
+                        PlacementOption = "SnapgridCenter",
+                        EntityType = id
+                    });
+                    _metaData.SetEntityName(actionId, proto.Name);
+                }
+                else if (map.TryGet<ValueDataNode>("tileId", out var tileNode))
+                {
+                    var id = new ProtoId<ContentTileDefinition>(tileNode.Value);
+                    var proto = _proto.Index(id);
+                    actionId = Spawn(MappingEntityAction);
+                    if (proto.Sprite is {} sprite)
+                        SetIcon(actionId, new SpriteSpecifier.Texture(sprite));
+                    SetEvent(actionId, new StartPlacementActionEvent()
+                    {
+                        PlacementOption = "AlignTileAny",
+                        TileId = id
+                    });
+                    _metaData.SetEntityName(actionId, Loc.GetString(proto.Name));
+                }
+                else
+                {
+                    Log.Error($"Mapping actions from {path} had unknown action data!");
+                    continue;
+                }
+
+                AddActionDirect((user, actions), actionId);
+            }
+        }
+
+        private void OnWorldTargetAttempt(Entity<WorldTargetActionComponent> ent, ref ActionTargetAttemptEvent args)
+        {
+            if (args.Handled)
+                return;
+
+            args.Handled = true;
+
+            var (uid, comp) = ent;
+            var action = args.Action;
+            var coords = args.Input.Coordinates;
+            var user = args.User;
+
+            if (!ValidateWorldTarget(user, coords, ent))
+                return;
+
+            // optionally send the clicked entity too, if it matches its whitelist etc
+            // this is the actual entity-world targeting magic
+            EntityUid? targetEnt = null;
+            if (TryComp<EntityTargetActionComponent>(ent, out var entity) &&
+                args.Input.EntityUid != null &&
+                ValidateEntityTarget(user, args.Input.EntityUid, (uid, entity)))
+            {
+                targetEnt = args.Input.EntityUid;
             }
 
-            AssignSlot?.Invoke(assignments);
+            if (action.ClientExclusive)
+            {
+                // TODO: abstract away from single event or maybe just RaiseLocalEvent?
+                if (comp.Event is {} ev)
+                {
+                    ev.Target = coords;
+                    ev.Entity = targetEnt;
+                }
+
+                PerformAction((user, user.Comp), (uid, action));
+            }
+            else
+                RaisePredictiveEvent(new RequestPerformActionEvent(GetNetEntity(uid), GetNetEntity(targetEnt), GetNetCoordinates(coords)));
+
+            args.FoundTarget = true;
+        }
+
+        private void OnEntityTargetAttempt(Entity<EntityTargetActionComponent> ent, ref ActionTargetAttemptEvent args)
+        {
+            if (args.Handled || args.Input.EntityUid is not { Valid: true } entity)
+                return;
+
+            // let world target component handle it
+            var (uid, comp) = ent;
+            if (comp.Event is not {} ev)
+            {
+                DebugTools.Assert(HasComp<WorldTargetActionComponent>(ent), $"Action {ToPrettyString(ent)} requires WorldTargetActionComponent for entity-world targeting");
+                return;
+            }
+
+            args.Handled = true;
+
+            var action = args.Action;
+            var user = args.User;
+
+            if (!ValidateEntityTarget(user, entity, ent))
+                return;
+
+            if (action.ClientExclusive)
+            {
+                ev.Target = entity;
+
+                PerformAction((user, user.Comp), (uid, action));
+            }
+            else
+            {
+                RaisePredictiveEvent(new RequestPerformActionEvent(GetNetEntity(uid), GetNetEntity(entity)));
+            }
+
+            args.FoundTarget = true;
         }
 
         public record struct SlotAssignment(byte Hotbar, byte Slot, EntityUid ActionId);

Content.Client/Administration/UI/Tabs/RoundTab.xaml

@@ -1,13 +1,13 @@
 <Control
     xmlns="https://spacestation14.io"
-    xmlns:cc="clr-namespace:Content.Client.Administration.UI.CustomControls"
+    xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
     Margin="4"
     MinSize="50 50">
     <GridContainer
         Columns="3">
-        <cc:CommandButton Command="startround" Text="{Loc administration-ui-round-tab-start-round}" />
-        <cc:CommandButton Command="endround" Text="{Loc administration-ui-round-tab-end-round}" />
-        <cc:CommandButton Command="restartround" Text="{Loc administration-ui-round-tab-restart-round}" />
-        <cc:CommandButton Command="restartroundnow" Text="{Loc administration-ui-round-tab-restart-round-now}" />
+        <controls:ConfirmButton Name="StartRound" Text="{Loc administration-ui-round-tab-start-round}" />
+        <controls:ConfirmButton Name="EndRound" Text="{Loc administration-ui-round-tab-end-round}" />
+        <controls:ConfirmButton Name="RestartRound" Text="{Loc administration-ui-round-tab-restart-round}" />
+        <controls:ConfirmButton Name="RestartRoundNow" Text="{Loc administration-ui-round-tab-restart-round-now}" />
     </GridContainer>
 </Control>

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

@@ -1,10 +1,24 @@
 using Robust.Client.AutoGenerated;
+using Robust.Client.Console;
 using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
 
 namespace Content.Client.Administration.UI.Tabs
 {
     [GenerateTypedNameReferences]
     public sealed partial class RoundTab : Control
     {
+        [Dependency] private readonly IClientConsoleHost _console = default!;
+
+        public RoundTab()
+        {
+            RobustXamlLoader.Load(this);
+            IoCManager.InjectDependencies(this);
+
+            StartRound.OnPressed += _ => _console.ExecuteCommand("startround");
+            EndRound.OnPressed += _ => _console.ExecuteCommand("endround");
+            RestartRound.OnPressed += _ => _console.ExecuteCommand("restartround");
+            RestartRoundNow.OnPressed += _ => _console.ExecuteCommand("restartroundnow");
+        }
     }
 }

Content.Client/Administration/UI/Tabs/ServerTab.xaml

@@ -1,11 +1,12 @@
 <Control
     xmlns="https://spacestation14.io"
     xmlns:cc="clr-namespace:Content.Client.Administration.UI.CustomControls"
+    xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
     Margin="4"
     MinSize="50 50">
     <GridContainer
         Columns="4" >
-        <cc:CommandButton Command="shutdown" Text="{Loc server-shutdown}" />
+        <controls:ConfirmButton Name="ServerShutdownButton" Text="{Loc server-shutdown}" />
         <cc:CommandButton Name="SetOocButton" Command="setooc" Text="{Loc server-ooc-toggle}" ToggleMode="True" />
         <cc:CommandButton Name="SetLoocButton" Command="setlooc" Text="{Loc server-looc-toggle}" ToggleMode="True" />
     </GridContainer>

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

@@ -1,5 +1,6 @@
 using Content.Shared.CCVar;
 using Robust.Client.AutoGenerated;
+using Robust.Client.Console;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Configuration;
@@ -10,6 +11,7 @@ namespace Content.Client.Administration.UI.Tabs
     public sealed partial class ServerTab : Control
     {
         [Dependency] private readonly IConfigurationManager _config = default!;
+        [Dependency] private readonly IClientConsoleHost _console = default!;
 
         public ServerTab()
         {
@@ -18,6 +20,8 @@ namespace Content.Client.Administration.UI.Tabs
 
             _config.OnValueChanged(CCVars.OocEnabled, OocEnabledChanged, true);
             _config.OnValueChanged(CCVars.LoocEnabled, LoocEnabledChanged, true);
+
+            ServerShutdownButton.OnPressed += _ => _console.ExecuteCommand("shutdown");
         }
 
         private void OocEnabledChanged(bool value)

Content.Client/Atmos/AlignAtmosPipeLayers.cs

@@ -0,0 +1,203 @@
+using Content.Client.Construction;
+using Content.Shared.Atmos.Components;
+using Content.Shared.Atmos.EntitySystems;
+using Content.Shared.Construction.Prototypes;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Placement;
+using Robust.Client.Placement.Modes;
+using Robust.Client.Utility;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+using System.Numerics;
+using static Robust.Client.Placement.PlacementManager;
+
+namespace Content.Client.Atmos;
+
+/// <summary>
+/// Allows users to place atmos pipes on different layers depending on how the mouse cursor is positioned within a grid tile.
+/// </summary>
+/// <remarks>
+/// This placement mode is not on the engine because it is content specific.
+/// </remarks>
+public sealed class AlignAtmosPipeLayers : SnapgridCenter
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly IPrototypeManager _protoManager = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+
+    private readonly SharedMapSystem _mapSystem;
+    private readonly SharedTransformSystem _transformSystem;
+    private readonly SharedAtmosPipeLayersSystem _pipeLayersSystem;
+    private readonly SpriteSystem _spriteSystem;
+
+    private const float SearchBoxSize = 2f;
+    private EntityCoordinates _unalignedMouseCoords = default;
+    private const float MouseDeadzoneRadius = 0.25f;
+
+    private Color _guideColor = new Color(0, 0, 0.5785f);
+    private const float GuideRadius = 0.1f;
+    private const float GuideOffset = 0.21875f;
+
+    public AlignAtmosPipeLayers(PlacementManager pMan) : base(pMan)
+    {
+        IoCManager.InjectDependencies(this);
+
+        _mapSystem = _entityManager.System<SharedMapSystem>();
+        _transformSystem = _entityManager.System<SharedTransformSystem>();
+        _pipeLayersSystem = _entityManager.System<SharedAtmosPipeLayersSystem>();
+        _spriteSystem = _entityManager.System<SpriteSystem>();
+    }
+
+    /// <inheritdoc/>
+    public override void Render(in OverlayDrawArgs args)
+    {
+        var gridUid = _entityManager.System<SharedTransformSystem>().GetGrid(MouseCoords);
+
+        if (gridUid == null || Grid == null)
+            return;
+
+        // Draw guide circles for each pipe layer if we are not in line/grid placing mode
+        if (pManager.PlacementType == PlacementTypes.None)
+        {
+            var gridRotation = _transformSystem.GetWorldRotation(gridUid.Value);
+            var worldPosition = _mapSystem.LocalToWorld(gridUid.Value, Grid, MouseCoords.Position);
+            var direction = (_eyeManager.CurrentEye.Rotation + gridRotation + Math.PI / 2).GetCardinalDir();
+            var multi = (direction == Direction.North || direction == Direction.South) ? -1f : 1f;
+
+            args.WorldHandle.DrawCircle(worldPosition, GuideRadius, _guideColor);
+            args.WorldHandle.DrawCircle(worldPosition + gridRotation.RotateVec(new Vector2(multi * GuideOffset, GuideOffset)), GuideRadius, _guideColor);
+            args.WorldHandle.DrawCircle(worldPosition - gridRotation.RotateVec(new Vector2(multi * GuideOffset, GuideOffset)), GuideRadius, _guideColor);
+        }
+
+        base.Render(args);
+    }
+
+    /// <inheritdoc/>
+    public override void AlignPlacementMode(ScreenCoordinates mouseScreen)
+    {
+        _unalignedMouseCoords = ScreenToCursorGrid(mouseScreen);
+        base.AlignPlacementMode(mouseScreen);
+
+        // Exit early if we are in line/grid placing mode
+        if (pManager.PlacementType != PlacementTypes.None)
+            return;
+
+        MouseCoords = _unalignedMouseCoords.AlignWithClosestGridTile(SearchBoxSize, _entityManager, _mapManager);
+
+        var gridId = _transformSystem.GetGrid(MouseCoords);
+
+        if (!_entityManager.TryGetComponent<MapGridComponent>(gridId, out var mapGrid))
+            return;
+
+        var gridRotation = _transformSystem.GetWorldRotation(gridId.Value);
+        CurrentTile = _mapSystem.GetTileRef(gridId.Value, mapGrid, MouseCoords);
+
+        float tileSize = mapGrid.TileSize;
+        GridDistancing = tileSize;
+
+        MouseCoords = new EntityCoordinates(MouseCoords.EntityId, new Vector2(CurrentTile.X + tileSize / 2 + pManager.PlacementOffset.X,
+            CurrentTile.Y + tileSize / 2 + pManager.PlacementOffset.Y));
+
+        // Calculate the position of the mouse cursor with respect to the center of the tile to determine which layer to use
+        var mouseCoordsDiff = _unalignedMouseCoords.Position - MouseCoords.Position;
+        var layer = AtmosPipeLayer.Primary;
+
+        if (mouseCoordsDiff.Length() > MouseDeadzoneRadius)
+        {
+            // Determine the direction of the mouse is relative to the center of the tile, adjusting for the player eye and grid rotation
+            var direction = (new Angle(mouseCoordsDiff) + _eyeManager.CurrentEye.Rotation + gridRotation + Math.PI / 2).GetCardinalDir();
+            layer = (direction == Direction.North || direction == Direction.East) ? AtmosPipeLayer.Secondary : AtmosPipeLayer.Tertiary;
+        }
+
+        // Update the construction menu placer
+        if (pManager.Hijack != null)
+            UpdateHijackedPlacer(layer, mouseScreen);
+
+        // Otherwise update the debug placer
+        else
+            UpdatePlacer(layer);
+    }
+
+    private void UpdateHijackedPlacer(AtmosPipeLayer layer, ScreenCoordinates mouseScreen)
+    {
+        // Try to get alternative prototypes from the construction prototype
+        var constructionSystem = (pManager.Hijack as ConstructionPlacementHijack)?.CurrentConstructionSystem;
+        var altPrototypes = (pManager.Hijack as ConstructionPlacementHijack)?.CurrentPrototype?.AlternativePrototypes;
+
+        if (constructionSystem == null || altPrototypes == null || (int)layer >= altPrototypes.Length)
+            return;
+
+        var newProtoId = altPrototypes[(int)layer];
+
+        if (!_protoManager.TryIndex(newProtoId, out var newProto))
+            return;
+
+        if (newProto.Type != ConstructionType.Structure)
+        {
+            pManager.Clear();
+            return;
+        }
+
+        if (newProto.ID == (pManager.Hijack as ConstructionPlacementHijack)?.CurrentPrototype?.ID)
+            return;
+
+        // Start placing
+        pManager.BeginPlacing(new PlacementInformation()
+        {
+            IsTile = false,
+            PlacementOption = newProto.PlacementMode,
+        }, new ConstructionPlacementHijack(constructionSystem, newProto));
+
+        if (pManager.CurrentMode is AlignAtmosPipeLayers { } newMode)
+            newMode.RefreshGrid(mouseScreen);
+
+        // Update construction guide
+        constructionSystem.GetGuide(newProto);
+    }
+
+    private void UpdatePlacer(AtmosPipeLayer layer)
+    {
+        // Try to get alternative prototypes from the entity atmos pipe layer component
+        if (pManager.CurrentPermission?.EntityType == null)
+            return;
+
+        if (!_protoManager.TryIndex<EntityPrototype>(pManager.CurrentPermission.EntityType, out var currentProto))
+            return;
+
+        if (!currentProto.TryGetComponent<AtmosPipeLayersComponent>(out var atmosPipeLayers, _entityManager.ComponentFactory))
+            return;
+
+        if (!_pipeLayersSystem.TryGetAlternativePrototype(atmosPipeLayers, layer, out var newProtoId))
+            return;
+
+        if (_protoManager.TryIndex<EntityPrototype>(newProtoId, out var newProto))
+        {
+            // Update the placed prototype
+            pManager.CurrentPermission.EntityType = newProtoId;
+
+            // Update the appearance of the ghost sprite
+            if (newProto.TryGetComponent<SpriteComponent>(out var sprite, _entityManager.ComponentFactory))
+            {
+                var textures = new List<IDirectionalTextureProvider>();
+
+                foreach (var spriteLayer in sprite.AllLayers)
+                {
+                    if (spriteLayer.ActualRsi?.Path != null && spriteLayer.RsiState.Name != null)
+                        textures.Add(_spriteSystem.RsiStateLike(new SpriteSpecifier.Rsi(spriteLayer.ActualRsi.Path, spriteLayer.RsiState.Name)));
+                }
+
+                pManager.CurrentTextures = textures;
+            }
+        }
+    }
+
+    private void RefreshGrid(ScreenCoordinates mouseScreen)
+    {
+        base.AlignPlacementMode(mouseScreen);
+    }
+}

Content.Client/Atmos/Consoles/AtmosMonitoringConsoleNavMapControl.cs

@@ -17,6 +17,10 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
     public int? FocusNetId = null;
 
     private const int ChunkSize = 4;
+    private const float ScaleModifier = 4f;
+
+    private readonly float[] _layerFraction = { 0.5f, 0.75f, 0.25f };
+    private const float LineThickness = 0.05f;
 
     private readonly Color _basePipeNetColor = Color.LightGray;
     private readonly Color _unfocusedPipeNetColor = Color.DimGray;
@@ -95,23 +99,23 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
             foreach (var chunkedLine in atmosPipeNetwork)
             {
                 var leftTop = ScalePosition(new Vector2
-                    (Math.Min(chunkedLine.Origin.X, chunkedLine.Terminus.X) - 0.1f,
-                    Math.Min(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) - 0.1f)
+                    (Math.Min(chunkedLine.Origin.X, chunkedLine.Terminus.X) - LineThickness,
+                    Math.Min(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) - LineThickness)
                     - offset);
 
                 var rightTop = ScalePosition(new Vector2
-                    (Math.Max(chunkedLine.Origin.X, chunkedLine.Terminus.X) + 0.1f,
-                    Math.Min(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) - 0.1f)
+                    (Math.Max(chunkedLine.Origin.X, chunkedLine.Terminus.X) + LineThickness,
+                    Math.Min(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) - LineThickness)
                     - offset);
 
                 var leftBottom = ScalePosition(new Vector2
-                    (Math.Min(chunkedLine.Origin.X, chunkedLine.Terminus.X) - 0.1f,
-                    Math.Max(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) + 0.1f)
+                    (Math.Min(chunkedLine.Origin.X, chunkedLine.Terminus.X) - LineThickness,
+                    Math.Max(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) + LineThickness)
                     - offset);
 
                 var rightBottom = ScalePosition(new Vector2
-                    (Math.Max(chunkedLine.Origin.X, chunkedLine.Terminus.X) + 0.1f,
-                    Math.Max(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) + 0.1f)
+                    (Math.Max(chunkedLine.Origin.X, chunkedLine.Terminus.X) + LineThickness,
+                    Math.Max(chunkedLine.Origin.Y, chunkedLine.Terminus.Y) + LineThickness)
                     - offset);
 
                 if (!pipeVertexUVs.TryGetValue(chunkedLine.Color, out var pipeVertexUV))
@@ -142,7 +146,7 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
         if (chunks == null || grid == null)
             return decodedOutput;
 
-        // Clear stale look up table values 
+        // Clear stale look up table values
         _horizLines.Clear();
         _horizLinesReversed.Clear();
         _vertLines.Clear();
@@ -158,7 +162,7 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
         {
             var list = new List<AtmosMonitoringConsoleLine>();
 
-            foreach (var ((netId, hexColor), atmosPipeData) in chunk.AtmosPipeData)
+            foreach (var ((netId, layer, hexColor), atmosPipeData) in chunk.AtmosPipeData)
             {
                 // Determine the correct coloration for the pipe
                 var color = Color.FromHex(hexColor) * _basePipeNetColor;
@@ -191,6 +195,9 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
                     _vertLinesReversed[color] = vertLinesReversed;
                 }
 
+                var layerFraction = _layerFraction[(int)layer];
+                var origin = new Vector2(grid.TileSize * layerFraction, -grid.TileSize * layerFraction);
+
                 // Loop over the chunk
                 for (var tileIdx = 0; tileIdx < ChunkSize * ChunkSize; tileIdx++)
                 {
@@ -208,21 +215,22 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
 
                     // Calculate the draw point offsets
                     var vertLineOrigin = (atmosPipeData & northMask << tileIdx * SharedNavMapSystem.Directions) > 0 ?
-                        new Vector2(grid.TileSize * 0.5f, -grid.TileSize * 1f) : new Vector2(grid.TileSize * 0.5f, -grid.TileSize * 0.5f);
+                        new Vector2(grid.TileSize * layerFraction, -grid.TileSize * 1f) : origin;
 
                     var vertLineTerminus = (atmosPipeData & southMask << tileIdx * SharedNavMapSystem.Directions) > 0 ?
-                        new Vector2(grid.TileSize * 0.5f, -grid.TileSize * 0f) : new Vector2(grid.TileSize * 0.5f, -grid.TileSize * 0.5f);
+                        new Vector2(grid.TileSize * layerFraction, -grid.TileSize * 0f) : origin;
 
                     var horizLineOrigin = (atmosPipeData & eastMask << tileIdx * SharedNavMapSystem.Directions) > 0 ?
-                        new Vector2(grid.TileSize * 1f, -grid.TileSize * 0.5f) : new Vector2(grid.TileSize * 0.5f, -grid.TileSize * 0.5f);
+                        new Vector2(grid.TileSize * 1f, -grid.TileSize * layerFraction) : origin;
 
                     var horizLineTerminus = (atmosPipeData & westMask << tileIdx * SharedNavMapSystem.Directions) > 0 ?
-                        new Vector2(grid.TileSize * 0f, -grid.TileSize * 0.5f) : new Vector2(grid.TileSize * 0.5f, -grid.TileSize * 0.5f);
+                        new Vector2(grid.TileSize * 0f, -grid.TileSize * layerFraction) : origin;
 
-                    // Since we can have pipe lines that have a length of a half tile, 
-                    // double the vectors and convert to vector2i so we can merge them
-                    AddOrUpdateNavMapLine(ConvertVector2ToVector2i(tile + horizLineOrigin, 2), ConvertVector2ToVector2i(tile + horizLineTerminus, 2), horizLines, horizLinesReversed);
-                    AddOrUpdateNavMapLine(ConvertVector2ToVector2i(tile + vertLineOrigin, 2), ConvertVector2ToVector2i(tile + vertLineTerminus, 2), vertLines, vertLinesReversed);
+                    // Scale up the vectors and convert to vector2i so we can merge them
+                    AddOrUpdateNavMapLine(ConvertVector2ToVector2i(tile + horizLineOrigin, ScaleModifier),
+                        ConvertVector2ToVector2i(tile + horizLineTerminus, ScaleModifier), horizLines, horizLinesReversed);
+                    AddOrUpdateNavMapLine(ConvertVector2ToVector2i(tile + vertLineOrigin, ScaleModifier),
+                        ConvertVector2ToVector2i(tile + vertLineTerminus, ScaleModifier), vertLines, vertLinesReversed);
                 }
             }
         }
@@ -235,7 +243,7 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
 
             foreach (var (origin, terminal) in horizLines)
                 decodedOutput.Add(new AtmosMonitoringConsoleLine
-                    (ConvertVector2iToVector2(origin, 0.5f), ConvertVector2iToVector2(terminal, 0.5f), sRGB));
+                    (ConvertVector2iToVector2(origin, 1f / ScaleModifier), ConvertVector2iToVector2(terminal, 1f / ScaleModifier), sRGB));
         }
 
         foreach (var (color, vertLines) in _vertLines)
@@ -245,7 +253,7 @@ public sealed partial class AtmosMonitoringConsoleNavMapControl : NavMapControl
 
             foreach (var (origin, terminal) in vertLines)
                 decodedOutput.Add(new AtmosMonitoringConsoleLine
-                    (ConvertVector2iToVector2(origin, 0.5f), ConvertVector2iToVector2(terminal, 0.5f), sRGB));
+                    (ConvertVector2iToVector2(origin, 1f / ScaleModifier), ConvertVector2iToVector2(terminal, 1f / ScaleModifier), sRGB));
         }
 
         return decodedOutput;

Content.Client/Atmos/Consoles/AtmosMonitoringConsoleSystem.cs

@@ -15,7 +15,7 @@ public sealed class AtmosMonitoringConsoleSystem : SharedAtmosMonitoringConsoleS
 
     private void OnHandleState(EntityUid uid, AtmosMonitoringConsoleComponent component, ref ComponentHandleState args)
     {
-        Dictionary<Vector2i, Dictionary<(int, string), ulong>> modifiedChunks;
+        Dictionary<Vector2i, Dictionary<AtmosMonitoringConsoleSubnet, ulong>> modifiedChunks;
         Dictionary<NetEntity, AtmosDeviceNavMapData> atmosDevices;
 
         switch (args.Current)
@@ -54,7 +54,7 @@ public sealed class AtmosMonitoringConsoleSystem : SharedAtmosMonitoringConsoleS
         foreach (var (origin, chunk) in modifiedChunks)
         {
             var newChunk = new AtmosPipeChunk(origin);
-            newChunk.AtmosPipeData = new Dictionary<(int, string), ulong>(chunk);
+            newChunk.AtmosPipeData = new Dictionary<AtmosMonitoringConsoleSubnet, ulong>(chunk);
 
             component.AtmosPipeChunks[origin] = newChunk;
         }

Content.Client/Atmos/Consoles/AtmosMonitoringConsoleWindow.xaml.cs

@@ -13,6 +13,7 @@ using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Numerics;
 
 namespace Content.Client.Atmos.Consoles;
 
@@ -33,6 +34,8 @@ public sealed partial class AtmosMonitoringConsoleWindow : FancyWindow
     private ProtoId<NavMapBlipPrototype> _navMapConsoleProtoId = "NavMapConsole";
     private ProtoId<NavMapBlipPrototype> _gasPipeSensorProtoId = "GasPipeSensor";
 
+    private readonly Vector2[] _pipeLayerOffsets = { new Vector2(0f, 0f), new Vector2(0.25f, 0.25f), new Vector2(-0.25f, -0.25f) };
+
     public AtmosMonitoringConsoleWindow(AtmosMonitoringConsoleBoundUserInterface userInterface, EntityUid? owner)
     {
         RobustXamlLoader.Load(this);
@@ -53,7 +56,7 @@ public sealed partial class AtmosMonitoringConsoleWindow : FancyWindow
             consoleCoords = xform.Coordinates;
             NavMap.MapUid = xform.GridUid;
 
-            // Assign station name      
+            // Assign station name
             if (_entManager.TryGetComponent<MetaDataComponent>(xform.GridUid, out var stationMetaData))
                 stationName = stationMetaData.EntityName;
 
@@ -238,6 +241,10 @@ public sealed partial class AtmosMonitoringConsoleWindow : FancyWindow
 
         var blinks = proto.Blinks || _focusEntity == metaData.NetEntity;
         var coords = _entManager.GetCoordinates(metaData.NetCoordinates);
+
+        if (proto.Placement == NavMapBlipPlacement.Offset && metaData.PipeLayer > 0)
+            coords = coords.Offset(_pipeLayerOffsets[(int)metaData.PipeLayer]);
+
         var blip = new NavMapBlip(coords, _spriteSystem.Frame0(new SpriteSpecifier.Texture(texture)), color, blinks, proto.Selectable, proto.Scale);
         NavMap.TrackedEntities[metaData.NetEntity] = blip;
     }

Content.Client/Atmos/EntitySystems/AtmosPipeAppearanceSystem.cs

@@ -1,6 +1,7 @@
 using Content.Client.SubFloor;
 using Content.Shared.Atmos;
 using Content.Shared.Atmos.Components;
+using Content.Shared.Atmos.EntitySystems;
 using Content.Shared.Atmos.Piping;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
@@ -8,7 +9,7 @@ using Robust.Client.GameObjects;
 namespace Content.Client.Atmos.EntitySystems;
 
 [UsedImplicitly]
-public sealed class AtmosPipeAppearanceSystem : EntitySystem
+public sealed partial class AtmosPipeAppearanceSystem : SharedAtmosPipeAppearanceSystem
 {
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
     [Dependency] private readonly SpriteSystem _sprite = default!;
@@ -26,26 +27,37 @@ public sealed class AtmosPipeAppearanceSystem : EntitySystem
         if (!TryComp(uid, out SpriteComponent? sprite))
             return;
 
+        var numberOfPipeLayers = GetNumberOfPipeLayers(uid, out _);
+
         foreach (var layerKey in Enum.GetValues<PipeConnectionLayer>())
         {
-            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));
+            for (byte i = 0; i < numberOfPipeLayers; i++)
+            {
+                var layerName = layerKey.ToString() + i.ToString();
+                var layer = _sprite.LayerMapReserve((uid, sprite), layerName);
+                _sprite.LayerSetRsi((uid, sprite), layer, component.Sprite[i].RsiPath);
+                _sprite.LayerSetRsiState((uid, sprite), layer, component.Sprite[i].RsiState);
+                _sprite.LayerSetDirOffset((uid, sprite), layer, ToOffset(layerKey));
+            }
         }
     }
 
-    private void HideAllPipeConnection(Entity<SpriteComponent> entity)
+    private void HideAllPipeConnection(Entity<SpriteComponent> entity, AtmosPipeLayersComponent? atmosPipeLayers, int numberOfPipeLayers)
     {
         var sprite = entity.Comp;
 
         foreach (var layerKey in Enum.GetValues<PipeConnectionLayer>())
         {
-            if (!_sprite.LayerMapTryGet(entity.AsNullable(), layerKey, out var key, false))
-                continue;
+            for (byte i = 0; i < numberOfPipeLayers; i++)
+            {
+                var layerName = layerKey.ToString() + i.ToString();
 
-            var layer = sprite[key];
-            layer.Visible = false;
+                if (!_sprite.LayerMapTryGet(entity.AsNullable(), layerName, out var key, false))
+                    continue;
+
+                var layer = sprite[key];
+                layer.Visible = false;
+            }
         }
     }
 
@@ -61,33 +73,45 @@ public sealed class AtmosPipeAppearanceSystem : EntitySystem
             return;
         }
 
-        if (!_appearance.TryGetData<PipeDirection>(uid, PipeVisuals.VisualState, out var worldConnectedDirections, args.Component))
+        var numberOfPipeLayers = GetNumberOfPipeLayers(uid, out var atmosPipeLayers);
+
+        if (!_appearance.TryGetData<int>(uid, PipeVisuals.VisualState, out var worldConnectedDirections, args.Component))
         {
-            HideAllPipeConnection((uid, args.Sprite));
+            HideAllPipeConnection((uid, args.Sprite), atmosPipeLayers, numberOfPipeLayers);
             return;
         }
 
         if (!_appearance.TryGetData<Color>(uid, PipeColorVisuals.Color, out var color, args.Component))
             color = Color.White;
 
-        // transform connected directions to local-coordinates
-        var connectedDirections = worldConnectedDirections.RotatePipeDirection(-Transform(uid).LocalRotation);
-
-        foreach (var layerKey in Enum.GetValues<PipeConnectionLayer>())
+        for (byte i = 0; i < numberOfPipeLayers; i++)
         {
-            if (!_sprite.LayerMapTryGet((uid, args.Sprite), layerKey, out var key, false))
-                continue;
+            // Extract the cardinal pipe orientations for the current pipe layer
+            // '15' is the four bit mask that is used to extract the pipe orientations of interest from 'worldConnectedDirections'
+            // Fun fact: a collection of four bits is called a 'nibble'! They aren't natively supported :(
+            var pipeLayerConnectedDirections = (PipeDirection)(15 & (worldConnectedDirections >> (PipeDirectionHelpers.PipeDirections * i)));
 
-            var layer = args.Sprite[key];
-            var dir = (PipeDirection)layerKey;
-            var visible = connectedDirections.HasDirection(dir);
+            // Transform the connected directions to local-coordinates
+            var connectedDirections = pipeLayerConnectedDirections.RotatePipeDirection(-Transform(uid).LocalRotation);
 
-            layer.Visible &= visible;
+            foreach (var layerKey in Enum.GetValues<PipeConnectionLayer>())
+            {
+                var layerName = layerKey.ToString() + i.ToString();
 
-            if (!visible)
-                continue;
+                if (!_sprite.LayerMapTryGet((uid, args.Sprite), layerName, out var key, false))
+                    continue;
 
-            layer.Color = color;
+                var layer = args.Sprite[key];
+                var dir = (PipeDirection)layerKey;
+                var visible = connectedDirections.HasDirection(dir);
+
+                layer.Visible &= visible;
+
+                if (!visible)
+                    continue;
+
+                layer.Color = color;
+            }
         }
     }
 

Content.Client/Atmos/EntitySystems/AtmosPipeLayersSystem.cs

@@ -0,0 +1,56 @@
+using Content.Shared.Atmos.Components;
+using Content.Shared.Atmos.EntitySystems;
+using Robust.Client.GameObjects;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Reflection;
+using Robust.Shared.Serialization.TypeSerializers.Implementations;
+using Robust.Shared.Utility;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Content.Client.Atmos.EntitySystems;
+
+/// <summary>
+/// The system responsible for updating the appearance of layered gas pipe
+/// </summary>
+public sealed partial class AtmosPipeLayersSystem : SharedAtmosPipeLayersSystem
+{
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly IReflectionManager _reflection = default!;
+    [Dependency] private readonly IResourceCache _resourceCache = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<AtmosPipeLayersComponent, AppearanceChangeEvent>(OnAppearanceChange);
+    }
+
+    private void OnAppearanceChange(Entity<AtmosPipeLayersComponent> ent, ref AppearanceChangeEvent ev)
+    {
+        if (!TryComp<SpriteComponent>(ent, out var sprite))
+            return;
+
+        if (_appearance.TryGetData<string>(ent, AtmosPipeLayerVisuals.Sprite, out var spriteRsi) &&
+            _resourceCache.TryGetResource(SpriteSpecifierSerializer.TextureRoot / spriteRsi, out RSIResource? resource))
+        {
+            _sprite.SetBaseRsi((ent, sprite), resource.RSI);
+        }
+
+        if (_appearance.TryGetData<Dictionary<string, string>>(ent, AtmosPipeLayerVisuals.SpriteLayers, out var pipeState))
+        {
+            foreach (var (layerKey, rsiPath) in pipeState)
+            {
+                if (TryParseKey(layerKey, out var @enum))
+                    _sprite.LayerSetRsi((ent, sprite), @enum, new ResPath(rsiPath));
+                else
+                    _sprite.LayerSetRsi((ent, sprite), layerKey, new ResPath(rsiPath));
+            }
+        }
+    }
+
+    private bool TryParseKey(string keyString, [NotNullWhen(true)] out Enum? @enum)
+    {
+        return _reflection.TryParseEnumReference(keyString, out @enum);
+    }
+}

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

@@ -136,6 +136,7 @@ namespace Content.Client.Atmos.UI
                 else
                 {
                     // oh shit of fuck its more than 4 this ui isn't gonna look pretty anymore
+                    CDeviceMixes.RemoveAllChildren();
                     for (var i = 1; i < msg.NodeGasMixes.Length; i++)
                     {
                         GenerateGasDisplay(msg.NodeGasMixes[i], CDeviceMixes);

Content.Client/Charges/ChargesSystem.cs

@@ -25,16 +25,14 @@ public sealed class ChargesSystem : SharedChargesSystem
 
         while (query.MoveNext(out var uid, out var recharge, out var charges))
         {
-            BaseActionComponent? actionComp = null;
-
-            if (!_actions.ResolveActionData(uid, ref actionComp, logError: false))
+            if (_actions.GetAction(uid, false) is not {} action)
                 continue;
 
             var current = GetCurrentCharges((uid, charges, recharge));
 
             if (!_lastCharges.TryGetValue(uid, out var last) || current != last)
             {
-                _actions.UpdateAction(uid, actionComp);
+                _actions.UpdateAction(action);
             }
 
             _tempLastCharges[uid] = current;

Content.Client/Clothing/Systems/ChameleonClothingSystem.cs

@@ -11,18 +11,6 @@ namespace Content.Client.Clothing.Systems;
 // All valid items for chameleon are calculated on client startup and stored in dictionary.
 public sealed class ChameleonClothingSystem : SharedChameleonClothingSystem
 {
-    [Dependency] private readonly IPrototypeManager _proto = default!;
-
-    private static readonly SlotFlags[] IgnoredSlots =
-    {
-        SlotFlags.All,
-        SlotFlags.PREVENTEQUIP,
-        SlotFlags.NONE
-    };
-    private static readonly SlotFlags[] Slots = Enum.GetValues<SlotFlags>().Except(IgnoredSlots).ToArray();
-
-    private readonly Dictionary<SlotFlags, List<string>> _data = new();
-
     public override void Initialize()
     {
         base.Initialize();
@@ -61,49 +49,4 @@ public sealed class ChameleonClothingSystem : SharedChameleonClothingSystem
             borderColor.AccentVColor = otherBorderColor.AccentVColor;
         }
     }
-
-    /// <summary>
-    ///     Get a list of valid chameleon targets for these slots.
-    /// </summary>
-    public IEnumerable<string> GetValidTargets(SlotFlags slot)
-    {
-        var set = new HashSet<string>();
-        foreach (var availableSlot in _data.Keys)
-        {
-            if (slot.HasFlag(availableSlot))
-            {
-                set.UnionWith(_data[availableSlot]);
-            }
-        }
-        return set;
-    }
-
-    private void PrepareAllVariants()
-    {
-        _data.Clear();
-        var prototypes = _proto.EnumeratePrototypes<EntityPrototype>();
-
-        foreach (var proto in prototypes)
-        {
-            // check if this is valid clothing
-            if (!IsValidTarget(proto))
-                continue;
-            if (!proto.TryGetComponent(out ClothingComponent? item, Factory))
-                continue;
-
-            // sort item by their slot flags
-            // one item can be placed in several buckets
-            foreach (var slot in Slots)
-            {
-                if (!item.Slots.HasFlag(slot))
-                    continue;
-
-                if (!_data.ContainsKey(slot))
-                {
-                    _data.Add(slot, new List<string>());
-                }
-                _data[slot].Add(proto.ID);
-            }
-        }
-    }
 }

Content.Client/Clothing/UI/ChameleonBoundUserInterface.cs

@@ -42,7 +42,7 @@ public sealed class ChameleonBoundUserInterface : BoundUserInterface
         var targets = _chameleon.GetValidTargets(st.Slot);
         if (st.RequiredTag != null)
         {
-            var newTargets = new List<string>();
+            var newTargets = new List<EntProtoId>();
             foreach (var target in targets)
             {
                 if (string.IsNullOrEmpty(target) || !_proto.TryIndex(target, out EntityPrototype? proto))

Content.Client/Clothing/UI/ChameleonMenu.xaml.cs

@@ -19,8 +19,8 @@ public sealed partial class ChameleonMenu : DefaultWindow
     private readonly SpriteSystem _sprite;
     public event Action<string>? OnIdSelected;
 
-    private IEnumerable<string> _possibleIds = Enumerable.Empty<string>();
-    private string? _selectedId;
+    private IEnumerable<EntProtoId> _possibleIds = [];
+    private EntProtoId? _selectedId;
     private string _searchFilter = "";
 
     public ChameleonMenu()
@@ -32,7 +32,7 @@ public sealed partial class ChameleonMenu : DefaultWindow
         Search.OnTextChanged += OnSearchEntered;
     }
 
-    public void UpdateState(IEnumerable<string> possibleIds, string? selectedId)
+    public void UpdateState(IEnumerable<EntProtoId> possibleIds, string? selectedId)
     {
         _possibleIds = possibleIds;
         _selectedId = selectedId;
@@ -57,7 +57,7 @@ public sealed partial class ChameleonMenu : DefaultWindow
             if (!_prototypeManager.TryIndex(id, out EntityPrototype? proto))
                 continue;
 
-            var lowId = id.ToLowerInvariant();
+            var lowId = id.Id.ToLowerInvariant();
             var lowName = proto.Name.ToLowerInvariant();
             if (!lowId.Contains(searchFilterLow) && !lowName.Contains(_searchFilter))
                 continue;

Content.Client/Construction/ConstructionPlacementHijack.cs

@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 using Content.Shared.Construction.Prototypes;
 using Robust.Client.GameObjects;
 using Robust.Client.Placement;
@@ -13,6 +13,9 @@ namespace Content.Client.Construction
         private readonly ConstructionSystem _constructionSystem;
         private readonly ConstructionPrototype? _prototype;
 
+        public ConstructionSystem? CurrentConstructionSystem { get { return _constructionSystem; } }
+        public ConstructionPrototype? CurrentPrototype { get { return _prototype; } }
+
         public override bool CanRotate { get; }
 
         public ConstructionPlacementHijack(ConstructionSystem constructionSystem, ConstructionPrototype? prototype)

Content.Client/ContextMenu/UI/ContextMenuUIController.cs

@@ -131,7 +131,7 @@ namespace Content.Client.ContextMenu.UI
         {
             if (!Menus.TryPeek(out var topMenu))
             {
-                Logger.Error("Context Menu: Mouse entered menu without any open menus?");
+                Log.Error("Context Menu: Mouse entered menu without any open menus?");
                 return;
             }
 
@@ -181,7 +181,7 @@ namespace Content.Client.ContextMenu.UI
         {
             if (!Menus.TryPeek(out var topMenu))
             {
-                Logger.Error("Context Menu: Attempting to open sub menu without any open menus?");
+                Log.Error("Context Menu: Attempting to open sub menu without any open menus?");
                 return;
             }
 

Content.Client/ContextMenu/UI/EntityMenuUIController.cs

@@ -306,7 +306,7 @@ namespace Content.Client.ContextMenu.UI
             // find the element associated with this entity
             if (!Elements.TryGetValue(entity, out var element))
             {
-                Logger.Error($"Attempted to remove unknown entity from the entity menu: {_entityManager.GetComponent<MetaDataComponent>(entity).EntityName} ({entity})");
+                Log.Error($"Attempted to remove unknown entity from the entity menu: {_entityManager.GetComponent<MetaDataComponent>(entity).EntityName} ({entity})");
                 return;
             }
 

Content.Client/Decals/DecalPlacementSystem.cs

@@ -2,6 +2,7 @@ using System.Numerics;
 using Content.Client.Actions;
 using Content.Client.Decals.Overlays;
 using Content.Shared.Actions;
+using Content.Shared.Actions.Components;
 using Content.Shared.Decals;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
@@ -21,9 +22,12 @@ public sealed class DecalPlacementSystem : EntitySystem
     [Dependency] private readonly IPrototypeManager _protoMan = default!;
     [Dependency] private readonly InputSystem _inputSystem = default!;
     [Dependency] private readonly MetaDataSystem _metaData = default!;
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
     [Dependency] private readonly SharedTransformSystem _transform = default!;
     [Dependency] private readonly SpriteSystem _sprite = default!;
 
+    public static readonly EntProtoId DecalAction = "BaseMappingDecalAction";
+
     private string? _decalId;
     private Color _decalColor = Color.White;
     private Angle _decalAngle = Angle.Zero;
@@ -152,19 +156,12 @@ public sealed class DecalPlacementSystem : EntitySystem
             Cleanable = _cleanable,
         };
 
-        var actionId = Spawn(null);
-        AddComp(actionId, new WorldTargetActionComponent
-        {
-            // non-unique actions may be considered duplicates when saving/loading.
-            Icon = decalProto.Sprite,
-            Repeat = true,
-            ClientExclusive = true,
-            CheckCanAccess = false,
-            CheckCanInteract = false,
-            Range = -1,
-            Event = actionEvent,
-            IconColor = _decalColor,
-        });
+        var actionId = Spawn(DecalAction);
+        var action = Comp<ActionComponent>(actionId);
+        var ent = (actionId, action);
+        _actions.SetEvent(actionId, actionEvent);
+        _actions.SetIcon(ent, decalProto.Sprite);
+        _actions.SetIconColor(ent, _decalColor);
 
         _metaData.SetEntityName(actionId, $"{_decalId} ({_decalColor.ToHex()}, {(int) _decalAngle.Degrees})");
 

Content.Client/Ensnaring/Components/EnsnaringComponent.cs

@@ -1,3 +0,0 @@
-using Content.Shared.Ensnaring.Components;
-
-

Content.Client/Entry/EntryPoint.cs

@@ -126,6 +126,8 @@ namespace Content.Client.Entry
             _prototypeManager.RegisterIgnore("nukeopsRole");
             _prototypeManager.RegisterIgnore("stationGoal"); // Corvax-StationGoal
             _prototypeManager.RegisterIgnore("ghostRoleRaffleDecider");
+            _prototypeManager.RegisterIgnore("codewordGenerator");
+            _prototypeManager.RegisterIgnore("codewordFaction");
 
             _componentFactory.GenerateNetIds();
             _adminManager.Initialize();

Content.Client/Guidebook/Controls/GuideEntityEmbed.xaml.cs

@@ -28,12 +28,15 @@ public sealed partial class GuideEntityEmbed : BoxContainer, IDocumentTag
 {
     [Dependency] private readonly IEntityManager _entityManager = default!;
     [Dependency] private readonly IEntitySystemManager _systemManager = default!;
+    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly IUserInterfaceManager _ui = default!;
 
     private readonly TagSystem _tagSystem;
     private readonly ExamineSystem _examineSystem;
     private readonly GuidebookSystem _guidebookSystem;
 
+    private readonly ISawmill _sawmill;
+
     public bool Interactive;
 
     public Entity<SpriteComponent>? Sprite => View.Entity == null || View.Sprite == null
@@ -53,6 +56,7 @@ public sealed partial class GuideEntityEmbed : BoxContainer, IDocumentTag
         _tagSystem = _systemManager.GetEntitySystem<TagSystem>();
         _examineSystem = _systemManager.GetEntitySystem<ExamineSystem>();
         _guidebookSystem = _systemManager.GetEntitySystem<GuidebookSystem>();
+        _sawmill = _logManager.GetSawmill("guidebook.entity");
         MouseFilter = MouseFilterMode.Stop;
     }
 
@@ -135,7 +139,7 @@ public sealed partial class GuideEntityEmbed : BoxContainer, IDocumentTag
     {
         if (!args.TryGetValue("Entity", out var proto))
         {
-            Logger.Error("Entity embed tag is missing entity prototype argument");
+            _sawmill.Error("Entity embed tag is missing entity prototype argument");
             control = null;
             return false;
         }

Content.Client/Guidebook/Controls/GuideMicrowaveEmbed.xaml.cs

@@ -24,7 +24,7 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
     [Dependency] private readonly IPrototypeManager _prototype = default!;
     [Dependency] private readonly ILogManager _logManager = default!;
 
-    private ISawmill _sawmill = default!;
+    private readonly ISawmill _sawmill = default!;
 
     public IPrototype? RepresentedPrototype { get; private set; }
 
@@ -34,7 +34,7 @@ public sealed partial class GuideMicrowaveEmbed : PanelContainer, IDocumentTag,
         IoCManager.InjectDependencies(this);
         MouseFilter = MouseFilterMode.Stop;
 
-        _sawmill = _logManager.GetSawmill("guidemicrowaveembed");
+        _sawmill = _logManager.GetSawmill("guidebook.microwave");
     }
 
     public GuideMicrowaveEmbed(string recipe) : this()

Content.Client/Guidebook/Controls/GuideMicrowaveGroupEmbed.cs

@@ -15,12 +15,16 @@ namespace Content.Client.Guidebook.Controls;
 [UsedImplicitly]
 public sealed partial class GuideMicrowaveGroupEmbed : BoxContainer, IDocumentTag
 {
+    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly IPrototypeManager _prototype = default!;
 
+    private readonly ISawmill _sawmill;
+
     public GuideMicrowaveGroupEmbed()
     {
         Orientation = LayoutOrientation.Vertical;
         IoCManager.InjectDependencies(this);
+        _sawmill = _logManager.GetSawmill("guidebook.microwave_group");
         MouseFilter = MouseFilterMode.Stop;
     }
 
@@ -34,7 +38,7 @@ public sealed partial class GuideMicrowaveGroupEmbed : BoxContainer, IDocumentTa
         control = null;
         if (!args.TryGetValue("Group", out var group))
         {
-            Logger.Error("Microwave group embed tag is missing group argument");
+            _sawmill.Error("Microwave group embed tag is missing group argument");
             return false;
         }
 

Content.Client/Guidebook/Controls/GuideReagentEmbed.xaml.cs

@@ -25,9 +25,11 @@ namespace Content.Client.Guidebook.Controls;
 public sealed partial class GuideReagentEmbed : BoxContainer, IDocumentTag, ISearchableControl, IPrototypeRepresentationControl
 {
     [Dependency] private readonly IEntitySystemManager _systemManager = default!;
+    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly IPrototypeManager _prototype = default!;
 
     private readonly ChemistryGuideDataSystem _chemistryGuideData;
+    private readonly ISawmill _sawmill;
 
     public IPrototype? RepresentedPrototype { get; private set; }
 
@@ -35,6 +37,7 @@ public sealed partial class GuideReagentEmbed : BoxContainer, IDocumentTag, ISea
     {
         RobustXamlLoader.Load(this);
         IoCManager.InjectDependencies(this);
+        _sawmill = _logManager.GetSawmill("guidebook.reagent");
         _chemistryGuideData = _systemManager.GetEntitySystem<ChemistryGuideDataSystem>();
         MouseFilter = MouseFilterMode.Stop;
     }
@@ -64,13 +67,13 @@ public sealed partial class GuideReagentEmbed : BoxContainer, IDocumentTag, ISea
         control = null;
         if (!args.TryGetValue("Reagent", out var id))
         {
-            Logger.Error("Reagent embed tag is missing reagent prototype argument");
+            _sawmill.Error("Reagent embed tag is missing reagent prototype argument");
             return false;
         }
 
         if (!_prototype.TryIndex<ReagentPrototype>(id, out var reagent))
         {
-            Logger.Error($"Specified reagent prototype \"{id}\" is not a valid reagent prototype");
+            _sawmill.Error($"Specified reagent prototype \"{id}\" is not a valid reagent prototype");
             return false;
         }
 

Content.Client/Guidebook/Controls/GuideReagentGroupEmbed.xaml.cs

@@ -17,12 +17,16 @@ namespace Content.Client.Guidebook.Controls;
 [UsedImplicitly, GenerateTypedNameReferences]
 public sealed partial class GuideReagentGroupEmbed : BoxContainer, IDocumentTag
 {
+    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly IPrototypeManager _prototype = default!;
 
+    private readonly ISawmill _sawmill;
+
     public GuideReagentGroupEmbed()
     {
         RobustXamlLoader.Load(this);
         IoCManager.InjectDependencies(this);
+        _sawmill = _logManager.GetSawmill("guidebook.reagent_group");
         MouseFilter = MouseFilterMode.Stop;
     }
 
@@ -42,7 +46,7 @@ public sealed partial class GuideReagentGroupEmbed : BoxContainer, IDocumentTag
         control = null;
         if (!args.TryGetValue("Group", out var group))
         {
-            Logger.Error("Reagent group embed tag is missing group argument");
+            _sawmill.Error("Reagent group embed tag is missing group argument");
             return false;
         }
 

Content.Client/Guidebook/Controls/GuideTechDisciplineEmbed.xaml.cs

@@ -17,12 +17,16 @@ namespace Content.Client.Guidebook.Controls;
 [UsedImplicitly, GenerateTypedNameReferences]
 public sealed partial class GuideTechDisciplineEmbed : BoxContainer, IDocumentTag
 {
+    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly IPrototypeManager _prototype = default!;
 
+    private readonly ISawmill _sawmill;
+
     public GuideTechDisciplineEmbed()
     {
         RobustXamlLoader.Load(this);
         IoCManager.InjectDependencies(this);
+        _sawmill = _logManager.GetSawmill("guidebook.tech_discipline");
         MouseFilter = MouseFilterMode.Stop;
     }
 
@@ -42,7 +46,7 @@ public sealed partial class GuideTechDisciplineEmbed : BoxContainer, IDocumentTa
         control = null;
         if (!args.TryGetValue("Discipline", out var group))
         {
-            Logger.Error("Technology discipline embed tag is missing discipline argument");
+            _sawmill.Error("Technology discipline embed tag is missing discipline argument");
             return false;
         }
 

Content.Client/Guidebook/Controls/GuideTechnologyEmbed.xaml.cs

@@ -22,10 +22,12 @@ namespace Content.Client.Guidebook.Controls;
 public sealed partial class GuideTechnologyEmbed : BoxContainer, IDocumentTag, ISearchableControl
 {
     [Dependency] private readonly IEntitySystemManager _systemManager = default!;
+    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly IPrototypeManager _prototype = default!;
 
     private readonly ResearchSystem _research;
     private readonly SpriteSystem _sprite;
+    private readonly ISawmill _sawmill;
 
     public GuideTechnologyEmbed()
     {
@@ -33,6 +35,7 @@ public sealed partial class GuideTechnologyEmbed : BoxContainer, IDocumentTag, I
         IoCManager.InjectDependencies(this);
         _research = _systemManager.GetEntitySystem<ResearchSystem>();
         _sprite = _systemManager.GetEntitySystem<SpriteSystem>();
+        _sawmill = _logManager.GetSawmill("guidebook.technology");
         MouseFilter = MouseFilterMode.Stop;
     }
 
@@ -61,13 +64,13 @@ public sealed partial class GuideTechnologyEmbed : BoxContainer, IDocumentTag, I
         control = null;
         if (!args.TryGetValue("Technology", out var id))
         {
-            Logger.Error("Technology embed tag is missing technology prototype argument");
+            _sawmill.Error("Technology embed tag is missing technology prototype argument");
             return false;
         }
 
         if (!_prototype.TryIndex<TechnologyPrototype>(id, out var technology))
         {
-            Logger.Error($"Specified technology prototype \"{id}\" is not a valid technology prototype");
+            _sawmill.Error($"Specified technology prototype \"{id}\" is not a valid technology prototype");
             return false;
         }
 

Content.Client/Guidebook/Controls/GuidebookWindow.xaml.cs

@@ -31,7 +31,7 @@ public sealed partial class GuidebookWindow : FancyWindow, ILinkClickHandler, IA
     {
         RobustXamlLoader.Load(this);
         IoCManager.InjectDependencies(this);
-        _sawmill = Logger.GetSawmill("Guidebook");
+        _sawmill = Logger.GetSawmill("guidebook");
 
         Tree.OnSelectedItemChanged += OnSelectionChanged;
 
@@ -225,7 +225,7 @@ public sealed partial class GuidebookWindow : FancyWindow, ILinkClickHandler, IA
         {
             // TODO GUIDEBOOK Maybe allow duplicate entries?
             // E.g., for adding medicine under both chemicals & the chemist job
-            Logger.Error($"Adding duplicate guide entry: {id}");
+            _sawmill.Error($"Adding duplicate guide entry: {id}");
             return null;
         }
 

Content.Client/Implants/ChameleonControllerSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.Implants;
+
+namespace Content.Client.Implants;
+
+public sealed partial class ChameleonControllerSystem : SharedChameleonControllerSystem;

Content.Client/Implants/UI/ChameleonControllerBoundUserInterface.cs

@@ -0,0 +1,49 @@
+using Content.Shared.Clothing;
+using Content.Shared.Implants;
+using Content.Shared.Preferences.Loadouts;
+using Content.Shared.Roles;
+using Content.Shared.Timing;
+using JetBrains.Annotations;
+using Robust.Client.UserInterface;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Implants.UI;
+
+[UsedImplicitly]
+public sealed class ChameleonControllerBoundUserInterface : BoundUserInterface
+{
+    private readonly UseDelaySystem _delay;
+
+    [ViewVariables]
+    private ChameleonControllerMenu? _menu;
+
+    public ChameleonControllerBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+    {
+        _delay =  EntMan.System<UseDelaySystem>();
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _menu = this.CreateWindow<ChameleonControllerMenu>();
+        _menu.OnJobSelected += OnJobSelected;
+    }
+
+    private void OnJobSelected(ProtoId<ChameleonOutfitPrototype> outfit)
+    {
+        if (!EntMan.TryGetComponent<UseDelayComponent>(Owner, out var useDelayComp))
+            return;
+
+        if (!_delay.TryResetDelay((Owner, useDelayComp), true))
+            return;
+
+        SendMessage(new ChameleonControllerSelectedOutfitMessage(outfit));
+
+        if (!_delay.TryGetDelayInfo((Owner, useDelayComp), out var delay) || _menu == null)
+            return;
+
+        _menu._lockedUntil = DateTime.Now.Add(delay.Length);
+        _menu.UpdateGrid(true);
+    }
+}

Content.Client/Implants/UI/ChameleonControllerMenu.xaml

@@ -0,0 +1,12 @@
+<controls:FancyWindow xmlns="https://spacestation14.io"
+             xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+             Title="{Loc 'chameleon-controller-ui-window-name'}"
+             MinSize="250 300"
+             SetSize="850 700">
+    <BoxContainer Orientation="Vertical" Margin="7 0 0 0">
+        <ScrollContainer VerticalExpand="True">
+            <GridContainer Name="Grid" Columns="3" Margin="0 5" >
+            </GridContainer>
+        </ScrollContainer>
+    </BoxContainer>
+</controls:FancyWindow>

Content.Client/Implants/UI/ChameleonControllerMenu.xaml.cs

@@ -0,0 +1,157 @@
+using System.Linq;
+using System.Numerics;
+using Content.Client.Roles;
+using Content.Client.Stylesheets;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Implants;
+using Content.Shared.StatusIcon;
+using Robust.Client.AutoGenerated;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Client.Implants.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ChameleonControllerMenu : FancyWindow
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    private readonly SpriteSystem _sprite;
+    private readonly JobSystem _job;
+
+    // List of all the job protos that you can select!
+    private IEnumerable<ChameleonOutfitPrototype> _outfits;
+
+    // Lock the UI until this time
+    public DateTime? _lockedUntil;
+
+    private static readonly ProtoId<JobIconPrototype> UnknownIcon = "JobIconUnknown";
+    private static readonly LocId UnknownDepartment = "department-Unknown";
+
+    public event Action<ProtoId<ChameleonOutfitPrototype>>? OnJobSelected;
+
+    public ChameleonControllerMenu()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+        _sprite = _entityManager.System<SpriteSystem>();
+        _job = _entityManager.System<JobSystem>();
+
+        _outfits = _prototypeManager.EnumeratePrototypes<ChameleonOutfitPrototype>();
+
+        UpdateGrid();
+    }
+
+    /// <summary>
+    ///     Fill the grid with the correct job icons and buttons.
+    /// </summary>
+    /// <param name="disabled">Set to true to disable all the buttons.</param>
+    public void UpdateGrid(bool disabled = false)
+    {
+        Grid.RemoveAllChildren();
+
+        // Dictionary to easily put outfits in departments.
+        // Department name -> UI element holding that department.
+        var departments = new Dictionary<string, BoxContainer>();
+
+        departments.Add(UnknownDepartment, CreateDepartment(UnknownDepartment));
+
+        // Go through every outfit and add them to the correct department.
+        foreach (var outfit in _outfits)
+        {
+            _prototypeManager.TryIndex(outfit.Job, out var jobProto);
+
+            var name = outfit.LoadoutName ?? outfit.Name ?? jobProto?.Name ?? "Prototype has no name or job.";
+
+            var jobIconId = outfit.Icon ?? jobProto?.Icon ?? UnknownIcon;
+            var jobIconProto = _prototypeManager.Index(jobIconId);
+
+            var outfitButton = CreateOutfitButton(disabled, name, jobIconProto, outfit.ID);
+
+            if (outfit.Job != null && _job.TryGetLowestWeightDepartment(outfit.Job, out var departmentPrototype))
+            {
+                if (!departments.ContainsKey(departmentPrototype.Name))
+                    departments.Add(departmentPrototype.Name, CreateDepartment(departmentPrototype.Name));
+
+                departments[departmentPrototype.Name].AddChild(outfitButton);
+            }
+            else
+            {
+                departments[UnknownDepartment].AddChild(outfitButton);
+            }
+        }
+
+        // Sort the departments by their weight.
+        var departmentList = departments.ToList();
+        departmentList.Sort((a, b) => a.Value.ChildCount.CompareTo(b.Value.ChildCount));
+
+        // Actually add the departments to the window.
+        foreach (var department in departmentList)
+        {
+            Grid.AddChild(department.Value);
+        }
+    }
+
+    private BoxContainer CreateDepartment(string name)
+    {
+        var departmentContainer = new BoxContainer
+        {
+            Orientation = BoxContainer.LayoutOrientation.Vertical,
+        };
+        departmentContainer.AddChild(new Label
+        {
+            Text = Loc.GetString(name),
+        });
+
+        return departmentContainer;
+    }
+
+    private BoxContainer CreateOutfitButton(bool disabled, string name, JobIconPrototype jobIconProto, ProtoId<ChameleonOutfitPrototype> outfitProto)
+    {
+        var outfitButton = new BoxContainer();
+
+        var button = new Button
+        {
+            HorizontalExpand = true,
+            StyleClasses = {StyleBase.ButtonSquare},
+            ToolTip = Loc.GetString(name),
+            Text = Loc.GetString(name),
+            Margin = new Thickness(0, 0, 15, 0),
+            Disabled = disabled,
+        };
+
+        var jobIconTexture = new TextureRect
+        {
+            Texture = _sprite.Frame0(jobIconProto.Icon),
+            TextureScale = new Vector2(2.5f, 2.5f),
+            Stretch = TextureRect.StretchMode.KeepCentered,
+            Margin = new Thickness(0, 0, 5, 0),
+        };
+
+        outfitButton.AddChild(jobIconTexture);
+        outfitButton.AddChild(button);
+
+        button.OnPressed += _ => JobButtonPressed(outfitProto);
+
+        return outfitButton;
+    }
+
+    private void JobButtonPressed(ProtoId<ChameleonOutfitPrototype> outfit)
+    {
+        OnJobSelected?.Invoke(outfit);
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        base.FrameUpdate(args);
+
+        if (_lockedUntil == null || DateTime.Now < _lockedUntil)
+            return;
+
+        _lockedUntil = null;
+        UpdateGrid();
+    }
+}

Content.Client/Light/HandheldLightSystem.cs

@@ -44,7 +44,7 @@ public sealed class HandheldLightSystem : SharedHandheldLightSystem
             return;
         }
 
-        if (!_appearance.TryGetData<bool>(uid, ToggleableLightVisuals.Enabled, out var enabled, args.Component))
+        if (!_appearance.TryGetData<bool>(uid, ToggleableVisuals.Enabled, out var enabled, args.Component))
         {
             return;
         }

Content.Client/Lobby/LobbyUIController.cs

@@ -33,7 +33,6 @@ public sealed partial class LobbyUIController : UIController, IOnStateEntered<Lo
     [Dependency] private readonly IClientPreferencesManager _preferencesManager = default!;
     [Dependency] private readonly IConfigurationManager _configurationManager = default!;
     [Dependency] private readonly IFileDialogManager _dialogManager = default!;
-    [Dependency] private readonly ILogManager _logManager = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly IResourceCache _resourceCache = default!;
@@ -270,7 +269,7 @@ public sealed partial class LobbyUIController : UIController, IOnStateEntered<Lo
             _configurationManager,
             EntityManager,
             _dialogManager,
-            _logManager,
+            LogManager,
             _playerManager,
             _prototypeManager,
             _resourceCache,

Content.Client/Machines/Components/MultipartMachineGhostComponent.cs

@@ -0,0 +1,14 @@
+namespace Content.Client.Machines.Components;
+
+/// <summary>
+/// Component attached to all multipart machine ghosts
+/// Intended for client side usage only, but used on prototypes.
+/// </summary>
+[RegisterComponent]
+public sealed partial class MultipartMachineGhostComponent : Component
+{
+    /// <summary>
+    /// Machine this particular ghost is linked to.
+    /// </summary>
+    public EntityUid? LinkedMachine = null;
+}

Content.Client/Machines/EntitySystems/MultipartMachineSystem.cs

@@ -0,0 +1,109 @@
+using Content.Client.Examine;
+using Content.Client.Machines.Components;
+using Content.Shared.Machines.Components;
+using Content.Shared.Machines.EntitySystems;
+using Robust.Client.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Spawners;
+
+namespace Content.Client.Machines.EntitySystems;
+
+/// <summary>
+/// Client side handling of multipart machines.
+/// Handles client side examination events to show the expected layout of the machine
+/// based on the origin of the main entity.
+/// </summary>
+public sealed class MultipartMachineSystem : SharedMultipartMachineSystem
+{
+    private readonly EntProtoId _ghostPrototype = "MultipartMachineGhost";
+    private readonly Color _partiallyTransparent = new Color(255, 255, 255, 180);
+
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+    [Dependency] private readonly MetaDataSystem _metaData = default!;
+    [Dependency] private readonly ISerializationManager _serialization= default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<MultipartMachineComponent, ClientExaminedEvent>(OnMachineExamined);
+        SubscribeLocalEvent<MultipartMachineComponent, AfterAutoHandleStateEvent>(OnHandleState);
+        SubscribeLocalEvent<MultipartMachineGhostComponent, TimedDespawnEvent>(OnGhostDespawned);
+    }
+
+    /// <summary>
+    /// Handles spawning several ghost sprites to show where the different parts of the machine
+    /// should go and the rotations they're expected to have.
+    /// Can only show one set of ghost parts at a time and their location depends on the current map/grid
+    /// location of the origin machine.
+    /// </summary>
+    /// <param name="ent">Entity/Component that has been inspected.</param>
+    /// <param name="args">Args for the event.</param>
+    private void OnMachineExamined(Entity<MultipartMachineComponent> ent, ref ClientExaminedEvent args)
+    {
+        if (ent.Comp.Ghosts.Count != 0)
+        {
+            // Already showing some part ghosts
+            return;
+        }
+
+        foreach (var part in ent.Comp.Parts.Values)
+        {
+            if (part.Entity.HasValue)
+                continue;
+
+            var entityCoords = new EntityCoordinates(ent.Owner, part.Offset);
+            var ghostEnt = Spawn(_ghostPrototype, entityCoords);
+
+            if (!XformQuery.TryGetComponent(ghostEnt, out var xform))
+                break;
+
+            xform.LocalRotation = part.Rotation;
+
+            Comp<MultipartMachineGhostComponent>(ghostEnt).LinkedMachine = ent;
+
+            ent.Comp.Ghosts.Add(ghostEnt);
+
+            if (part.GhostProto == null)
+                continue;
+
+            var entProto = _prototype.Index(part.GhostProto.Value);
+            if (!entProto.Components.TryGetComponent("Sprite", out var s) || s is not SpriteComponent protoSprite)
+                return;
+
+            var ghostSprite = EnsureComp<SpriteComponent>(ghostEnt);
+            _serialization.CopyTo(protoSprite, ref ghostSprite, notNullableOverride: true);
+
+            _sprite.SetColor((ghostEnt, ghostSprite), _partiallyTransparent);
+
+            _metaData.SetEntityName(ghostEnt, entProto.Name);
+            _metaData.SetEntityDescription(ghostEnt, entProto.Description);
+        }
+    }
+
+    private void OnHandleState(Entity<MultipartMachineComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        foreach (var part in ent.Comp.Parts.Values)
+        {
+            part.Entity = part.NetEntity.HasValue ? EnsureEntity<MultipartMachinePartComponent>(part.NetEntity.Value, ent) : null;
+        }
+    }
+
+    /// <summary>
+    /// Handles when a ghost part despawns after its short lifetime.
+    /// Will attempt to remove itself from the list of known ghost entities in the main multipart
+    /// machine component.
+    /// </summary>
+    /// <param name="ent">Ghost entity that has been despawned.</param>
+    /// <param name="args">Args for the event.</param>
+    private void OnGhostDespawned(Entity<MultipartMachineGhostComponent> ent, ref TimedDespawnEvent args)
+    {
+        if (!TryComp<MultipartMachineComponent>(ent.Comp.LinkedMachine, out var machine))
+            return;
+
+        machine.Ghosts.Remove(ent);
+    }
+}

Content.Client/Mapping/MappingSystem.cs

@@ -4,8 +4,8 @@ using Content.Shared.Mapping;
 using Content.Shared.Maps;
 using Robust.Client.Placement;
 using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
-using static Robust.Shared.Utility.SpriteSpecifier;
 
 namespace Content.Client.Mapping;
 
@@ -14,16 +14,10 @@ public sealed partial class MappingSystem : EntitySystem
     [Dependency] private readonly IPlacementManager _placementMan = default!;
     [Dependency] private readonly ITileDefinitionManager _tileMan = default!;
     [Dependency] private readonly MetaDataSystem _metaData = default!;
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
 
-    /// <summary>
-    ///     The icon to use for space tiles.
-    /// </summary>
-    private readonly SpriteSpecifier _spaceIcon = new Texture(new ("Tiles/cropped_parallax.png"));
-
-    /// <summary>
-    ///     The icon to use for entity-eraser.
-    /// </summary>
-    private readonly SpriteSpecifier _deleteIcon = new Texture(new ("Interface/VerbIcons/delete.svg.192dpi.png"));
+    public static readonly EntProtoId SpawnAction = "BaseMappingSpawnAction";
+    public static readonly EntProtoId EraserAction = "ActionMappingEraser";
 
     public override void Initialize()
     {
@@ -38,90 +32,46 @@ public sealed partial class MappingSystem : EntitySystem
     ///     some entity or tile into an action. This is somewhat janky, but it seem to work well enough. Though I'd
     ///     prefer if it were to function more like DecalPlacementSystem.
     /// </summary>
-    private void OnFillActionSlot(FillActionSlotEvent ev)
+    private void OnFillActionSlot(FillActionSlotEvent args)
     {
         if (!_placementMan.IsActive)
             return;
 
-        if (ev.Action != null)
+        if (args.Action != null)
             return;
 
-        var actionEvent = new StartPlacementActionEvent();
-        ITileDefinition? tileDef = null;
-
-        if (_placementMan.CurrentPermission != null)
+        if (_placementMan.CurrentPermission is {} permission)
         {
-            actionEvent.EntityType = _placementMan.CurrentPermission.EntityType;
-            actionEvent.PlacementOption = _placementMan.CurrentPermission.PlacementOption;
+            var ev = new StartPlacementActionEvent()
+            {
+                EntityType = permission.EntityType,
+                PlacementOption = permission.PlacementOption,
+            };
 
+            var action = Spawn(SpawnAction);
             if (_placementMan.CurrentPermission.IsTile)
             {
-                tileDef = _tileMan[_placementMan.CurrentPermission.TileType];
-                actionEvent.TileId = tileDef.ID;
+                if (_tileMan[_placementMan.CurrentPermission.TileType] is not ContentTileDefinition tileDef)
+                    return;
+
+                if (!tileDef.MapAtmosphere && tileDef.Sprite is {} sprite)
+                    _actions.SetIcon(action, new SpriteSpecifier.Texture(sprite));
+                ev.TileId = tileDef.ID;
+                _metaData.SetEntityName(action, Loc.GetString(tileDef.Name));
             }
+            else if (permission.EntityType is {} id)
+            {
+                _actions.SetIcon(action, new SpriteSpecifier.EntityPrototype(id));
+                _metaData.SetEntityName(action, id);
+            }
+
+            _actions.SetEvent(action, ev);
+            args.Action = action;
         }
         else if (_placementMan.Eraser)
         {
-            actionEvent.Eraser = true;
+            args.Action = Spawn(EraserAction);
         }
-        else
-            return;
-
-        InstantActionComponent action;
-        string name;
-
-        if (tileDef != null)
-        {
-            if (tileDef is not ContentTileDefinition contentTileDef)
-                return;
-
-            var tileIcon = contentTileDef.MapAtmosphere
-                ? _spaceIcon
-                : new Texture(contentTileDef.Sprite!.Value);
-
-            action = new InstantActionComponent
-            {
-                ClientExclusive = true,
-                CheckCanInteract = false,
-                Event = actionEvent,
-                Icon = tileIcon
-            };
-
-            name = Loc.GetString(tileDef.Name);
-        }
-        else if (actionEvent.Eraser)
-        {
-            action = new InstantActionComponent
-            {
-                ClientExclusive = true,
-                CheckCanInteract = false,
-                Event = actionEvent,
-                Icon = _deleteIcon,
-            };
-
-            name = Loc.GetString("action-name-mapping-erase");
-        }
-        else
-        {
-            if (string.IsNullOrWhiteSpace(actionEvent.EntityType))
-                return;
-
-            action = new InstantActionComponent
-            {
-                ClientExclusive = true,
-                CheckCanInteract = false,
-                Event = actionEvent,
-                Icon = new EntityPrototype(actionEvent.EntityType),
-            };
-
-            name = actionEvent.EntityType;
-        }
-
-        var actionId = Spawn(null);
-        AddComp<Component>(actionId, action);
-        _metaData.SetEntityName(actionId, name);
-
-        ev.Action = actionId;
     }
 
     private void OnStartPlacementAction(StartPlacementActionEvent args)

Content.Client/Movement/Systems/JetpackSystem.cs

@@ -16,7 +16,6 @@ public sealed class JetpackSystem : SharedJetpackSystem
     [Dependency] private readonly ClothingSystem _clothing = default!;
     [Dependency] private readonly SharedTransformSystem _transform = default!;
     [Dependency] private readonly SharedMapSystem _mapSystem = default!;
-    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     public override void Initialize()
     {
@@ -34,10 +33,6 @@ public sealed class JetpackSystem : SharedJetpackSystem
     {
         Appearance.TryGetData<bool>(uid, JetpackVisuals.Enabled, out var enabled, args.Component);
 
-        var state = "icon" + (enabled ? "-on" : "");
-        if (args.Sprite != null)
-            _sprite.LayerSetRsiState((uid, args.Sprite), 0, state);
-
         if (TryComp<ClothingComponent>(uid, out var clothing))
             _clothing.SetEquippedPrefix(uid, enabled ? "on" : null, clothing);
     }

Content.Client/Options/UI/OptionColorSlider.xaml

@@ -0,0 +1,7 @@
+<Control xmlns="https://spacestation14.io">
+    <BoxContainer Orientation="Vertical">
+        <Label Name="TitleLabel" Access="Public" />
+        <Label Name="ExampleLabel" Access="Public" />
+        <ColorSelectorSliders Name="Slider" Access="Public" HorizontalExpand="True" />
+    </BoxContainer>
+</Control>

Content.Client/Options/UI/OptionColorSlider.xaml.cs

@@ -0,0 +1,31 @@
+using Content.Client.Options.UI;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+
+namespace Content.Client.Options.UI;
+
+/// <summary>
+/// Standard UI control used for color sliders in the options menu. Intended for use with <see cref="OptionsTabControlRow"/>.
+/// </summary>
+/// <seealso cref="OptionsTabControlRow.AddOptionColorSlider"/>
+[GenerateTypedNameReferences]
+public sealed partial class OptionColorSlider : Control
+{
+    /// <summary>
+    /// The text describing what this slider affects.
+    /// </summary>
+    public string? Title
+    {
+        get => TitleLabel.Text;
+        set => TitleLabel.Text = value;
+    }
+
+    /// <summary>
+    /// The example text showing the current color of the slider.
+    /// </summary>
+    public string? Example
+    {
+        get => ExampleLabel.Text;
+        set => ExampleLabel.Text = value;
+    }
+}

Content.Client/Options/UI/OptionsTabControlRow.xaml.cs

@@ -121,6 +121,19 @@ public sealed partial class OptionsTabControlRow : Control
         return AddOption(new OptionSliderFloatCVar(this, _cfg, cVar, slider, min, max, scale, FormatPercent));
     }
 
+    /// <summary>
+    /// Add a color slider option, backed by a simple string CVar.
+    /// </summary>
+    /// <param name="cVar">The CVar represented by the slider.</param>
+    /// <param name="slider">The UI control for the option.</param>
+    /// <returns>The option instance backing the added option.</returns>
+    public OptionColorSliderCVar AddOptionColorSlider(
+        CVarDef<string> cVar,
+        OptionColorSlider slider)
+    {
+        return AddOption(new OptionColorSliderCVar(this, _cfg, cVar, slider));
+    }
+
     /// <summary>
     /// Add a slider option, backed by a simple integer CVar.
     /// </summary>
@@ -518,6 +531,58 @@ public sealed class OptionSliderFloatCVar : BaseOptionCVar<float>
     }
 }
 
+/// <summary>
+/// Implementation of a CVar option that simply corresponds with a string <see cref="OptionColorSlider"/>.
+/// </summary>
+/// <seealso cref="OptionsTabControlRow"/>
+public sealed class OptionColorSliderCVar : BaseOptionCVar<string>
+{
+    private readonly OptionColorSlider _slider;
+
+    protected override string Value
+    {
+        get => _slider.Slider.Color.ToHex();
+        set
+        {
+            _slider.Slider.Color = Color.FromHex(value);
+            UpdateLabelColor();
+        }
+    }
+
+    /// <summary>
+    /// Creates a new instance of this type.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// It is generally more convenient to call overloads on <see cref="OptionsTabControlRow"/>
+    /// such as <see cref="OptionsTabControlRow.AddOptionPercentSlider"/> instead of instantiating this type directly.
+    /// </para>
+    /// </remarks>
+    /// <param name="controller">The control row that owns this option.</param>
+    /// <param name="cfg">The configuration manager to get and set values from.</param>
+    /// <param name="cVar">The CVar that is being controlled by this option.</param>
+    /// <param name="slider">The UI control for the option.</param>
+    public OptionColorSliderCVar(
+        OptionsTabControlRow controller,
+        IConfigurationManager cfg,
+        CVarDef<string> cVar,
+        OptionColorSlider slider) : base(controller, cfg, cVar)
+    {
+        _slider = slider;
+
+        slider.Slider.OnColorChanged += _ =>
+        {
+            ValueChanged();
+            UpdateLabelColor();
+        };
+    }
+
+    private void UpdateLabelColor()
+    {
+        _slider.ExampleLabel.FontColorOverride = Color.FromHex(Value);
+    }
+}
+
 /// <summary>
 /// Implementation of a CVar option that simply corresponds with an integer <see cref="OptionSlider"/>.
 /// </summary>

Content.Client/Options/UI/Tabs/AccessibilityTab.xaml

@@ -14,6 +14,10 @@
                 <ui:OptionSlider Name="SpeechBubbleTextOpacitySlider" Title="{Loc 'ui-options-speech-bubble-text-opacity'}" />
                 <ui:OptionSlider Name="SpeechBubbleSpeakerOpacitySlider" Title="{Loc 'ui-options-speech-bubble-speaker-opacity'}" />
                 <ui:OptionSlider Name="SpeechBubbleBackgroundOpacitySlider" Title="{Loc 'ui-options-speech-bubble-background-opacity'}" />
+                <CheckBox Name="AutoFillHighlightsCheckBox" Text="{Loc 'ui-options-auto-fill-highlights'}" />
+                <ui:OptionColorSlider Name="HighlightsColorSlider" 
+                    Title="{Loc 'ui-options-highlights-color'}" 
+                    Example="{Loc 'ui-options-highlights-color-example'}"/>
                 <Label Text="{Loc 'ui-options-accessability-header-content'}"
                        StyleClasses="LabelKeyText"/>
                 <CheckBox Name="CensorNudityCheckBox" Text="{Loc 'ui-options-censor-nudity'}" />

Content.Client/Options/UI/Tabs/AccessibilityTab.xaml.cs

@@ -20,6 +20,8 @@ public sealed partial class AccessibilityTab : Control
         Control.AddOptionPercentSlider(CCVars.SpeechBubbleTextOpacity, SpeechBubbleTextOpacitySlider);
         Control.AddOptionPercentSlider(CCVars.SpeechBubbleSpeakerOpacity, SpeechBubbleSpeakerOpacitySlider);
         Control.AddOptionPercentSlider(CCVars.SpeechBubbleBackgroundOpacity, SpeechBubbleBackgroundOpacitySlider);
+        Control.AddOptionCheckBox(CCVars.ChatAutoFillHighlights, AutoFillHighlightsCheckBox);
+        Control.AddOptionColorSlider(CCVars.ChatHighlightsColor, HighlightsColorSlider);
 
         Control.AddOptionCheckBox(CCVars.AccessibilityClientCensorNudity, CensorNudityCheckBox);
 

Content.Client/Overlays/BlackAndWhiteOverlay.cs

@@ -1,5 +1,4 @@
 using Robust.Client.Graphics;
-using Robust.Client.Player;
 using Robust.Shared.Enums;
 using Robust.Shared.Prototypes;
 
@@ -7,9 +6,7 @@ namespace Content.Client.Overlays;
 
 public sealed partial class BlackAndWhiteOverlay : Overlay
 {
-    [Dependency] private readonly IEntityManager _entityManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-    [Dependency] private readonly IPlayerManager _playerManager = default!;
 
     public override OverlaySpace Space => OverlaySpace.WorldSpace;
     public override bool RequestScreenTexture => true;
@@ -22,17 +19,6 @@ public sealed partial class BlackAndWhiteOverlay : Overlay
         ZIndex = 10; // draw this over the DamageOverlay, RainbowOverlay etc.
     }
 
-    protected override bool BeforeDraw(in OverlayDrawArgs args)
-    {
-        if (!_entityManager.TryGetComponent(_playerManager.LocalEntity, out EyeComponent? eyeComp))
-            return false;
-
-        if (args.Viewport.Eye != eyeComp.Eye)
-            return false;
-
-        return true;
-    }
-
     protected override void Draw(in OverlayDrawArgs args)
     {
         if (ScreenTexture == null)

Content.Client/Overlays/BlackAndWhiteOverlaySystem.cs

@@ -1,7 +1,6 @@
 using Content.Shared.Inventory.Events;
 using Content.Shared.Overlays;
 using Robust.Client.Graphics;
-using Robust.Client.Player;
 
 namespace Content.Client.Overlays;
 

Content.Client/Overlays/NoirOverlay.cs

@@ -0,0 +1,33 @@
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Overlays;
+
+public sealed partial class NoirOverlay : Overlay
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+    public override bool RequestScreenTexture => true;
+    private readonly ShaderInstance _noirShader;
+
+    public NoirOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _noirShader = _prototypeManager.Index<ShaderPrototype>("Noir").InstanceUnique();
+        ZIndex = 9; // draw this over the DamageOverlay, RainbowOverlay etc, but before the black and white shader
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (ScreenTexture == null)
+            return;
+
+        var handle = args.WorldHandle;
+        _noirShader.SetParameter("SCREEN_TEXTURE", ScreenTexture);
+        handle.UseShader(_noirShader);
+        handle.DrawRect(args.WorldBounds, Color.White);
+        handle.UseShader(null);
+    }
+}

Content.Client/Overlays/NoirOverlaySystem.cs

@@ -0,0 +1,33 @@
+using Content.Shared.Inventory.Events;
+using Content.Shared.Overlays;
+using Robust.Client.Graphics;
+
+namespace Content.Client.Overlays;
+
+public sealed partial class NoirOverlaySystem : EquipmentHudSystem<NoirOverlayComponent>
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+    private NoirOverlay _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _overlay = new();
+    }
+
+    protected override void UpdateInternal(RefreshEquipmentHudEvent<NoirOverlayComponent> component)
+    {
+        base.UpdateInternal(component);
+
+        _overlayMan.AddOverlay(_overlay);
+    }
+
+    protected override void DeactivateInternal()
+    {
+        base.DeactivateInternal();
+
+        _overlayMan.RemoveOverlay(_overlay);
+    }
+}

Content.Client/ParticleAccelerator/UI/ParticleAcceleratorControlMenu.xaml

@@ -127,7 +127,7 @@
                             <Control/>
                             <ui:PASegmentControl Name="EndCapTexture" BaseState="end_cap"/>
                             <Control/>
-                            <ui:PASegmentControl Name="ControlBoxTexture" BaseState="control_box"/>
+                            <ui:PASegmentControl Name="ControlBoxTexture" BaseState="control_box" DefaultVisible="True"/>
                             <ui:PASegmentControl Name="FuelChamberTexture" BaseState="fuel_chamber"/>
                             <Control/>
                             <Control/>

Content.Client/ParticleAccelerator/UI/ParticleAcceleratorControlMenu.xaml.cs

@@ -268,6 +268,7 @@ public sealed class PASegmentControl : Control
     private RSI? _rsi;
 
     public string BaseState { get; set; } = "control_box";
+    public bool DefaultVisible { get; set; } = false;
 
     public PASegmentControl()
     {
@@ -283,12 +284,14 @@ public sealed class PASegmentControl : Control
         _rsi = IoCManager.Resolve<IResourceCache>().GetResource<RSIResource>($"/Textures/Structures/Power/Generation/PA/{BaseState}.rsi").RSI;
         MinSize = _rsi.Size;
         _base.Texture = _rsi["completed"].Frame0;
+
+        SetVisible(DefaultVisible);
+        _unlit.Visible = DefaultVisible;
     }
 
     public void SetPowerState(ParticleAcceleratorUIState state, bool exists)
     {
-        _base.ShaderOverride = exists ? null : _greyScaleShader;
-        _base.ModulateSelfOverride = exists ? null : new Color(127, 127, 127);
+        SetVisible(exists);
 
         if (!state.Enabled || !exists)
         {
@@ -319,4 +322,23 @@ public sealed class PASegmentControl : Control
 
         _unlit.Texture = rState.Frame0;
     }
+
+    /// <summary>
+    /// Adds/Removes the shading to the part in the control menu based on the
+    /// input state.
+    /// </summary>
+    /// <param name="state">True if the part exists, false otherwise</param>
+    private void SetVisible(bool state)
+    {
+        if (state)
+        {
+            _base.ShaderOverride = null;
+            _base.ModulateSelfOverride = null;
+        }
+        else
+        {
+            _base.ShaderOverride = _greyScaleShader;
+            _base.ModulateSelfOverride = new Color(127, 127, 127);
+        }
+    }
 }

Content.Client/Physics/Controllers/MoverController.cs

@@ -1,5 +1,6 @@
 using Content.Shared.Alert;
 using Content.Shared.CCVar;
+using Content.Shared.Friction;
 using Content.Shared.Movement.Components;
 using Content.Shared.Movement.Pulling.Components;
 using Content.Shared.Movement.Systems;

Content.Client/Radiation/Overlays/RadiationPulseOverlay.cs

@@ -59,7 +59,7 @@ namespace Content.Client.Radiation.Overlays
                 shd?.SetParameter("positionInput", tempCoords);
                 shd?.SetParameter("range", instance.Range);
                 var life = (_gameTiming.RealTime - instance.Start).TotalSeconds / instance.Duration;
-                shd?.SetParameter("life", (float) life);
+                shd?.SetParameter("life", (float)life);
 
                 // There's probably a very good reason not to do this.
                 // Oh well!

Content.Client/Rootable/RootableSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.Rootable;
+
+namespace Content.Client.Rootable;
+
+public sealed class RootableSystem : SharedRootableSystem;

Content.Client/Shuttles/Commands/ShowEmergencyShuttleCommand.cs

@@ -3,15 +3,15 @@ using Robust.Shared.Console;
 
 namespace Content.Client.Shuttles.Commands;
 
-public sealed class ShowEmergencyShuttleCommand : IConsoleCommand
+public sealed class ShowEmergencyShuttleCommand : LocalizedEntityCommands
 {
-    public string Command => "showemergencyshuttle";
-    public string Description => "Shows the expected position of the emergency shuttle";
-    public string Help => $"{Command}";
-    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    [Dependency] private readonly ShuttleSystem _shuttle = default!;
+
+    public override string Command => "showemergencyshuttle";
+
+    public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        var tstalker = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<ShuttleSystem>();
-        tstalker.EnableShuttlePosition ^= true;
-        shell.WriteLine($"Set emergency shuttle debug to {tstalker.EnableShuttlePosition}");
+        _shuttle.EnableShuttlePosition ^= true;
+        shell.WriteLine(Loc.GetString($"cmd-showemergencyshuttle-status", ("status", _shuttle.EnableShuttlePosition)));
     }
 }

Content.Client/Store/Ui/StoreMenu.xaml.cs

@@ -141,11 +141,8 @@ public sealed partial class StoreMenu : DefaultWindow
         else if (listing.ProductAction != null)
         {
             var actionId = _entityManager.Spawn(listing.ProductAction);
-            if (_entityManager.System<ActionsSystem>().TryGetActionData(actionId, out var action) &&
-                action.Icon != null)
-            {
-                texture = spriteSys.Frame0(action.Icon);
-            }
+            if (_entityManager.System<ActionsSystem>().GetAction(actionId)?.Comp?.Icon is {} icon)
+                texture = spriteSys.Frame0(icon);
         }
 
         var listingInStock = GetListingPriceString(listing);

Content.Client/Toggleable/ToggleableLightVisualsComponent.cs

@@ -1,32 +0,0 @@
-using Content.Shared.Hands.Components;
-
-namespace Content.Client.Toggleable;
-
-/// <summary>
-///     Component that handles the toggling the visuals of some light emitting entity.
-/// </summary>
-/// <remarks>
-///     This will toggle the visibility of layers on an entity's sprite, the in-hand visuals, and the clothing/equipment
-///     visuals. This will modify the color of any attached point lights.
-/// </remarks>
-[RegisterComponent]
-public sealed partial class ToggleableLightVisualsComponent : Component
-{
-    /// <summary>
-    ///     Sprite layer that will have its visibility toggled when this item is toggled.
-    /// </summary>
-    [DataField("spriteLayer")]
-    public string? SpriteLayer = "light";
-
-    /// <summary>
-    ///     Layers to add to the sprite of the player that is holding this entity (while the component is toggled on).
-    /// </summary>
-    [DataField("inhandVisuals")]
-    public Dictionary<HandLocation, List<PrototypeLayerData>> InhandVisuals = new();
-
-    /// <summary>
-    ///     Layers to add to the sprite of the player that is wearing this entity (while the component is toggled on).
-    /// </summary>
-    [DataField("clothingVisuals")]
-    public Dictionary<string, List<PrototypeLayerData>> ClothingVisuals = new();
-}

Content.Client/Toggleable/ToggleableLightVisualsSystem.cs

@@ -1,126 +0,0 @@
-using Content.Client.Clothing;
-using Content.Client.Items.Systems;
-using Content.Shared.Clothing;
-using Content.Shared.Hands;
-using Content.Shared.Inventory;
-using Content.Shared.Item;
-using Content.Shared.Toggleable;
-using Robust.Client.GameObjects;
-using Robust.Shared.Utility;
-using System.Linq;
-
-namespace Content.Client.Toggleable;
-
-public sealed class ToggleableLightVisualsSystem : VisualizerSystem<ToggleableLightVisualsComponent>
-{
-    [Dependency] private readonly SharedItemSystem _itemSys = default!;
-    [Dependency] private readonly SharedPointLightSystem _lights = default!;
-
-    public override void Initialize()
-    {
-        base.Initialize();
-        SubscribeLocalEvent<ToggleableLightVisualsComponent, GetInhandVisualsEvent>(OnGetHeldVisuals, after: new[] { typeof(ItemSystem) });
-        SubscribeLocalEvent<ToggleableLightVisualsComponent, GetEquipmentVisualsEvent>(OnGetEquipmentVisuals, after: new[] { typeof(ClientClothingSystem) });
-    }
-
-    protected override void OnAppearanceChange(EntityUid uid, ToggleableLightVisualsComponent component, ref AppearanceChangeEvent args)
-    {
-        if (!AppearanceSystem.TryGetData<bool>(uid, ToggleableLightVisuals.Enabled, out var enabled, args.Component))
-            return;
-
-        var modulate = AppearanceSystem.TryGetData<Color>(uid, ToggleableLightVisuals.Color, out var color, args.Component);
-
-        // Update the item's sprite
-        if (args.Sprite != null && component.SpriteLayer != null && SpriteSystem.LayerMapTryGet((uid, args.Sprite), component.SpriteLayer, out var layer, false))
-        {
-            SpriteSystem.LayerSetVisible((uid, args.Sprite), layer, enabled);
-            if (modulate)
-                SpriteSystem.LayerSetColor((uid, args.Sprite), layer, color);
-        }
-
-        // Update any point-lights
-        if (TryComp(uid, out PointLightComponent? light))
-        {
-            DebugTools.Assert(!light.NetSyncEnabled, "light visualizers require point lights without net-sync");
-            _lights.SetEnabled(uid, enabled, light);
-            if (enabled && modulate)
-            {
-                _lights.SetColor(uid, color, light);
-            }
-        }
-
-        // update clothing & in-hand visuals.
-        _itemSys.VisualsChanged(uid);
-    }
-
-    /// <summary>
-    ///     Add the unshaded light overlays to any clothing sprites.
-    /// </summary>
-    private void OnGetEquipmentVisuals(EntityUid uid, ToggleableLightVisualsComponent component, GetEquipmentVisualsEvent args)
-    {
-        if (!TryComp(uid, out AppearanceComponent? appearance)
-            || !AppearanceSystem.TryGetData<bool>(uid, ToggleableLightVisuals.Enabled, out var enabled, appearance)
-            || !enabled)
-            return;
-
-        if (!TryComp(args.Equipee, out InventoryComponent? inventory))
-            return;
-        List<PrototypeLayerData>? layers = null;
-
-        // attempt to get species specific data
-        if (inventory.SpeciesId != null)
-            component.ClothingVisuals.TryGetValue($"{args.Slot}-{inventory.SpeciesId}", out layers);
-
-        // No species specific data.  Try to default to generic data.
-        if (layers == null && !component.ClothingVisuals.TryGetValue(args.Slot, out layers))
-            return;
-
-        var modulate = AppearanceSystem.TryGetData<Color>(uid, ToggleableLightVisuals.Color, out var color, appearance);
-
-        var i = 0;
-        foreach (var layer in layers)
-        {
-            var key = layer.MapKeys?.FirstOrDefault();
-            if (key == null)
-            {
-                key = i == 0 ? $"{args.Slot}-toggle" : $"{args.Slot}-toggle-{i}";
-                i++;
-            }
-
-            if (modulate)
-                layer.Color = color;
-
-            args.Layers.Add((key, layer));
-        }
-    }
-
-    private void OnGetHeldVisuals(EntityUid uid, ToggleableLightVisualsComponent component, GetInhandVisualsEvent args)
-    {
-        if (!TryComp(uid, out AppearanceComponent? appearance)
-            || !AppearanceSystem.TryGetData<bool>(uid, ToggleableLightVisuals.Enabled, out var enabled, appearance)
-            || !enabled)
-            return;
-
-        if (!component.InhandVisuals.TryGetValue(args.Location, out var layers))
-            return;
-
-        var modulate = AppearanceSystem.TryGetData<Color>(uid, ToggleableLightVisuals.Color, out var color, appearance);
-
-        var i = 0;
-        var defaultKey = $"inhand-{args.Location.ToString().ToLowerInvariant()}-toggle";
-        foreach (var layer in layers)
-        {
-            var key = layer.MapKeys?.FirstOrDefault();
-            if (key == null)
-            {
-                key = i == 0 ? defaultKey : $"{defaultKey}-{i}";
-                i++;
-            }
-
-            if (modulate)
-                layer.Color = color;
-
-            args.Layers.Add((key, layer));
-        }
-    }
-}

Content.Client/Toggleable/ToggleableVisualsComponent.cs

@@ -0,0 +1,30 @@
+using Content.Shared.Hands.Components;
+
+namespace Content.Client.Toggleable;
+
+/// <summary>
+/// Component that handles toggling the visuals of an entity, including layers on an entity's sprite,
+/// the in-hand visuals, and the clothing/equipment visuals.
+/// </summary>
+/// <see cref="ToggleableVisualsSystem"/>
+[RegisterComponent]
+public sealed partial class ToggleableVisualsComponent : Component
+{
+    /// <summary>
+    /// Sprite layer that will have its visibility toggled when this item is toggled.
+    /// </summary>
+    [DataField(required: true)]
+    public string? SpriteLayer;
+
+    /// <summary>
+    /// Layers to add to the sprite of the player that is holding this entity (while the component is toggled on).
+    /// </summary>
+    [DataField]
+    public Dictionary<HandLocation, List<PrototypeLayerData>> InhandVisuals = new();
+
+    /// <summary>
+    /// Layers to add to the sprite of the player that is wearing this entity (while the component is toggled on).
+    /// </summary>
+    [DataField]
+    public Dictionary<string, List<PrototypeLayerData>> ClothingVisuals = new();
+}

Content.Client/Toggleable/ToggleableVisualsSystem.cs

@@ -0,0 +1,140 @@
+using System.Linq;
+using Content.Client.Clothing;
+using Content.Client.Items.Systems;
+using Content.Shared.Clothing;
+using Content.Shared.Hands;
+using Content.Shared.Inventory;
+using Content.Shared.Item;
+using Content.Shared.Light.Components;
+using Content.Shared.Toggleable;
+using Robust.Client.GameObjects;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Toggleable;
+
+/// <summary>
+/// Implements the behavior of <see cref="ToggleableVisualsComponent"/> by reacting to
+/// <see cref="AppearanceChangeEvent"/>, for the sprite directly; <see cref="OnGetHeldVisuals"/> for the
+/// in-hand visuals; and <see cref="OnGetEquipmentVisuals"/> for the clothing visuals.
+/// </summary>
+/// <see cref="ToggleableVisualsComponent"/>
+public sealed class ToggleableVisualsSystem : VisualizerSystem<ToggleableVisualsComponent>
+{
+    [Dependency] private readonly SharedItemSystem _item = default!;
+    [Dependency] private readonly SharedPointLightSystem _pointLight = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<ToggleableVisualsComponent, GetInhandVisualsEvent>(OnGetHeldVisuals,
+            after: [typeof(ItemSystem)]);
+        SubscribeLocalEvent<ToggleableVisualsComponent, GetEquipmentVisualsEvent>(OnGetEquipmentVisuals,
+            after: [typeof(ClientClothingSystem)]);
+    }
+
+    protected override void OnAppearanceChange(EntityUid uid,
+        ToggleableVisualsComponent component,
+        ref AppearanceChangeEvent args)
+    {
+        if (!AppearanceSystem.TryGetData<bool>(uid, ToggleableVisuals.Enabled, out var enabled, args.Component))
+            return;
+
+        var modulateColor =
+            AppearanceSystem.TryGetData<Color>(uid, ToggleableVisuals.Color, out var color, args.Component);
+
+        // Update the item's sprite
+        if (args.Sprite != null && component.SpriteLayer != null &&
+            SpriteSystem.LayerMapTryGet((uid, args.Sprite), component.SpriteLayer, out var layer, false))
+        {
+            SpriteSystem.LayerSetVisible((uid, args.Sprite), layer, enabled);
+            if (modulateColor)
+                SpriteSystem.LayerSetColor((uid, args.Sprite), component.SpriteLayer, color);
+        }
+
+        // If there's a `ItemTogglePointLightComponent` that says to apply the color to attached lights, do so.
+        if (TryComp<ItemTogglePointLightComponent>(uid, out var toggleLights) &&
+            TryComp(uid, out PointLightComponent? light))
+        {
+            DebugTools.Assert(!light.NetSyncEnabled,
+                $"{typeof(ItemTogglePointLightComponent)} requires point lights without net-sync");
+            _pointLight.SetEnabled(uid, enabled, light);
+            if (modulateColor && toggleLights.ToggleableVisualsColorModulatesLights)
+            {
+                _pointLight.SetColor(uid, color, light);
+            }
+        }
+
+        // update clothing & in-hand visuals.
+        _item.VisualsChanged(uid);
+    }
+
+    private void OnGetEquipmentVisuals(EntityUid uid,
+        ToggleableVisualsComponent component,
+        GetEquipmentVisualsEvent args)
+    {
+        if (!TryComp(uid, out AppearanceComponent? appearance)
+            || !AppearanceSystem.TryGetData<bool>(uid, ToggleableVisuals.Enabled, out var enabled, appearance)
+            || !enabled)
+            return;
+
+        if (!TryComp(args.Equipee, out InventoryComponent? inventory))
+            return;
+        List<PrototypeLayerData>? layers = null;
+
+        // attempt to get species specific data
+        if (inventory.SpeciesId != null)
+            component.ClothingVisuals.TryGetValue($"{args.Slot}-{inventory.SpeciesId}", out layers);
+
+        // No species specific data.  Try to default to generic data.
+        if (layers == null && !component.ClothingVisuals.TryGetValue(args.Slot, out layers))
+            return;
+
+        var modulateColor = AppearanceSystem.TryGetData<Color>(uid, ToggleableVisuals.Color, out var color, appearance);
+
+        var i = 0;
+        foreach (var layer in layers)
+        {
+            var key = layer.MapKeys?.FirstOrDefault();
+            if (key == null)
+            {
+                key = i == 0 ? $"{args.Slot}-toggle" : $"{args.Slot}-toggle-{i}";
+                i++;
+            }
+
+            if (modulateColor)
+                layer.Color = color;
+
+            args.Layers.Add((key, layer));
+        }
+    }
+
+    private void OnGetHeldVisuals(EntityUid uid, ToggleableVisualsComponent component, GetInhandVisualsEvent args)
+    {
+        if (!TryComp(uid, out AppearanceComponent? appearance)
+            || !AppearanceSystem.TryGetData<bool>(uid, ToggleableVisuals.Enabled, out var enabled, appearance)
+            || !enabled)
+            return;
+
+        if (!component.InhandVisuals.TryGetValue(args.Location, out var layers))
+            return;
+
+        var modulateColor = AppearanceSystem.TryGetData<Color>(uid, ToggleableVisuals.Color, out var color, appearance);
+
+        var i = 0;
+        var defaultKey = $"inhand-{args.Location.ToString().ToLowerInvariant()}-toggle";
+        foreach (var layer in layers)
+        {
+            var key = layer.MapKeys?.FirstOrDefault();
+            if (key == null)
+            {
+                key = i == 0 ? defaultKey : $"{defaultKey}-{i}";
+                i++;
+            }
+
+            if (modulateColor)
+                layer.Color = color;
+
+            args.Layers.Add((key, layer));
+        }
+    }
+}

Content.Client/TurretController/DeployableTurretControllerSystem.cs

@@ -0,0 +1,9 @@
+using Content.Shared.TurretController;
+
+namespace Content.Client.TurretController;
+
+/// <inheritdoc/>
+public sealed class DeployableTurretControllerSystem : SharedDeployableTurretControllerSystem
+{
+
+}

Content.Client/TurretController/TurretControllerWindow.xaml

@@ -0,0 +1,125 @@
+<ui:TurretControllerWindow xmlns="https://spacestation14.io"
+                        xmlns:ui="clr-namespace:Content.Client.TurretController"
+                        xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+                        xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
+                        xmlns:access="clr-namespace:Content.Client.Access.UI"
+                        SetWidth="550"
+                        Resizable="False"
+                        MouseFilter="Stop">
+
+    <PanelContainer Name="Background" StyleClasses="PdaBackgroundRect" ModulateSelfOverride="#4a5466"/>
+    <PanelContainer Name="Border" StyleClasses="PdaBorderRect" />
+
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+
+        <!--Header-->
+        <BoxContainer SetHeight="26" Margin="4 2 8 0" Orientation="Horizontal" HorizontalAlignment="Right">
+            <TextureButton Name="CloseButton" StyleClasses="windowCloseButton" Modulate="#646464" VerticalAlignment="Center" Margin="0 4 4 0"/>
+        </BoxContainer>
+
+        <!--Content-->
+        <Control Margin="18 0" RectClipContent="True" VerticalExpand="true"
+                 HorizontalExpand="True">
+            <PanelContainer Name="ContentBorder" StyleClasses="PdaBackground"/>
+            <Control Name="ContentsContainer" Margin="3 3" Modulate="#FFFFFF">
+
+                <!-- Screen Background -->
+                <PanelContainer Name="ContentBackground" StyleClasses="PdaContentBackground"/>
+
+                <!-- Screen foreground -->
+                <BoxContainer Orientation="Vertical">
+
+                    <Label Text="{Loc 'turret-controls-window-title'}" StyleClasses="ConsoleHeading"
+                           HorizontalAlignment="Center" Margin="0 5 0 0" />
+
+                    <!-- Linked devices -->
+                    <PanelContainer Margin="10 5 10 5">
+                        <PanelContainer.PanelOverride>
+                            <gfx:StyleBoxFlat BorderColor="#FFFFFF" BorderThickness="2" />
+                        </PanelContainer.PanelOverride>
+
+                        <BoxContainer Orientation="Vertical" MinHeight="195" Margin="5 5 5 5">
+                            <Label Name="TurretStatusHeader" Text="{Loc 'turret-controls-window-turret-status-label'}" StyleClasses="ConsoleSubHeading"
+                                   HorizontalAlignment="Center" />
+
+                            <PanelContainer StyleClasses="LowDivider" HorizontalExpand="True" Margin="-5 5 -5 5" SetHeight="2">
+                                <PanelContainer.PanelOverride>
+                                    <gfx:StyleBoxFlat BackgroundColor="#FFFFFF" />
+                                </PanelContainer.PanelOverride>
+                            </PanelContainer>
+
+                            <BoxContainer Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True">
+                                <Label Name="NoLinkedTurretsText" Text="{Loc 'turret-controls-window-no-turrets'}" StyleClasses="ConsoleText"
+                                       HorizontalAlignment="Center" ReservesSpace="False"/>
+
+                                <ScrollContainer VerticalExpand="True" HorizontalExpand="True">
+                                    <BoxContainer Name="LinkedTurretsContainer" Orientation="Vertical" Visible="False" ReservesSpace="False">
+                                        <!-- Populated with C# code -->
+                                    </BoxContainer>
+                                </ScrollContainer>
+                            </BoxContainer>
+                        </BoxContainer>
+                    </PanelContainer>
+
+                    <!-- Armament controls -->
+                    <PanelContainer Margin="10 0 10 5">
+                        <PanelContainer.PanelOverride>
+                            <gfx:StyleBoxFlat BorderColor="#FFFFFF" BorderThickness="2" />
+                        </PanelContainer.PanelOverride>
+
+                        <BoxContainer Orientation="Vertical">
+                            <Label Text="{Loc 'turret-controls-window-armament-controls-label'}" StyleClasses="ConsoleSubHeading"
+                                   HorizontalAlignment="Center" Margin="0 5 0 5" />
+
+                            <PanelContainer StyleClasses="LowDivider" HorizontalExpand="True" SetHeight="2">
+                                <PanelContainer.PanelOverride>
+                                    <gfx:StyleBoxFlat BackgroundColor="#FFFFFF" />
+                                </PanelContainer.PanelOverride>
+                            </PanelContainer>
+
+                            <BoxContainer Orientation="Horizontal" Margin="10 10 10 10">
+                                <controls:MonotoneButton Name="SafeButton" Text="{Loc 'turret-controls-window-safe'}"
+                                                   StyleClasses="OpenRight" Pressed="False" ToggleMode="True" HorizontalExpand="True"/>
+                                <controls:MonotoneButton Name="StunButton" Text="{Loc 'turret-controls-window-stun'}"
+                                                   StyleClasses="OpenBoth" Pressed="False" ToggleMode="True" HorizontalExpand="True"/>
+                                <controls:MonotoneButton Name="LethalButton" Text="{Loc 'turret-controls-window-lethal'}"
+                                                   StyleClasses="OpenLeft" Pressed="False" ToggleMode="True" HorizontalExpand="True"/>
+                            </BoxContainer>
+
+                        </BoxContainer>
+                    </PanelContainer>
+
+                    <!-- Targeting controls -->
+                    <PanelContainer Name="TargetingControlsPanel" Margin="10 0 10 10" VerticalExpand="True" HorizontalExpand="True">
+                        <PanelContainer.PanelOverride>
+                            <gfx:StyleBoxFlat BorderColor="#FFFFFF" BorderThickness="2" />
+                        </PanelContainer.PanelOverride>
+
+                        <BoxContainer Orientation="Vertical" VerticalExpand="True" HorizontalExpand="True">
+                            <Label Text="{Loc 'turret-controls-window-targeting-controls-label'}" StyleClasses="ConsoleSubHeading"
+                                   HorizontalAlignment="Center" Margin="0 5 0 5" />
+
+                            <PanelContainer StyleClasses="LowDivider" HorizontalExpand="True" SetHeight="2">
+                                <PanelContainer.PanelOverride>
+                                    <gfx:StyleBoxFlat BackgroundColor="#FFFFFF" />
+                                </PanelContainer.PanelOverride>
+                            </PanelContainer>
+
+                            <!-- Access configuration -->
+                            <access:GroupedAccessLevelChecklist Name="AccessConfiguration"/>
+
+                        </BoxContainer>
+                    </PanelContainer>
+                </BoxContainer>
+            </Control>
+        </Control>
+
+        <!--Footer-->
+        <BoxContainer Orientation="Horizontal" SetHeight="28">
+            <Label Text="⚠" Margin="0 0 4 4" HorizontalExpand="True" HorizontalAlignment="Right"/>
+            <Label Name="Footer" Text="{Loc 'turret-controls-window-footer'}"
+                   HorizontalAlignment="Center" Margin="0 0 0 4"/>
+            <Label Text="⚠" Margin="4 0 0 4" HorizontalExpand="True" HorizontalAlignment="Left"/>
+        </BoxContainer>
+    </BoxContainer>
+</ui:TurretControllerWindow>

Content.Client/TurretController/TurretControllerWindow.xaml.cs

@@ -0,0 +1,202 @@
+using Content.Client.Stylesheets;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Access;
+using Content.Shared.Access.Systems;
+using Content.Shared.TurretController;
+using Content.Shared.Turrets;
+using Robust.Client.AutoGenerated;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using System.Numerics;
+
+namespace Content.Client.TurretController;
+
+[GenerateTypedNameReferences]
+public sealed partial class TurretControllerWindow : BaseWindow
+{
+    [Dependency] private readonly IEntityManager _entManager = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IResourceCache _cache = default!;
+
+    private readonly AccessReaderSystem _accessReaderSystem;
+
+    private EntityUid? _owner;
+
+    // Button groups
+    private readonly ButtonGroup _armamentButtons = new();
+
+    // Events
+    public event Action<HashSet<ProtoId<AccessLevelPrototype>>, bool>? OnAccessLevelsChangedEvent;
+    public event Action<TurretArmamentSetting>? OnArmamentSettingChangedEvent;
+
+    // Colors
+    private static readonly Dictionary<TurretArmamentSetting, Color> ThemeColors = new()
+    {
+        [TurretArmamentSetting.Safe] = Color.FromHex("#33e633"),
+        [TurretArmamentSetting.Stun] = Color.FromHex("#dfb827"),
+        [TurretArmamentSetting.Lethal] = Color.FromHex("#da2a2a")
+    };
+
+    public TurretControllerWindow()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        _accessReaderSystem = _entManager.System<AccessReaderSystem>();
+
+        CloseButton.OnPressed += _ => Close();
+
+        // Set up armament buttons
+        SafeButton.OnToggled += args => OnArmamentButtonPressed(SafeButton, TurretArmamentSetting.Safe);
+        StunButton.OnToggled += args => OnArmamentButtonPressed(StunButton, TurretArmamentSetting.Stun);
+        LethalButton.OnToggled += args => OnArmamentButtonPressed(LethalButton, TurretArmamentSetting.Lethal);
+
+        SafeButton.Group = _armamentButtons;
+        StunButton.Group = _armamentButtons;
+        LethalButton.Group = _armamentButtons;
+
+        SafeButton.Label.AddStyleClass("ConsoleText");
+        StunButton.Label.AddStyleClass("ConsoleText");
+        LethalButton.Label.AddStyleClass("ConsoleText");
+
+        // Set up access configuration buttons
+        AccessConfiguration.SetMonotone(true);
+        AccessConfiguration.SetLabelStyleClass("ConsoleText");
+        AccessConfiguration.OnAccessLevelsChangedEvent += OnAccessLevelsChanged;
+
+        // Override footer font
+        var smallFont = _cache.NotoStack(size: 8);
+        Footer.FontOverride = smallFont;
+    }
+
+    private void OnAccessLevelsChanged(HashSet<ProtoId<AccessLevelPrototype>> accessLevels, bool isPressed)
+    {
+        OnAccessLevelsChangedEvent?.Invoke(accessLevels, isPressed);
+    }
+
+    private void OnArmamentButtonPressed(MonotoneButton pressedButton, TurretArmamentSetting setting)
+    {
+        UpdateTheme(setting);
+        OnArmamentSettingChangedEvent?.Invoke(setting);
+    }
+
+    private void Initialize()
+    {
+        RefreshLinkedTurrets(new());
+
+        if (_entManager.TryGetComponent<DeployableTurretControllerComponent>(_owner, out var turretController))
+        {
+            AccessConfiguration.SetAccessGroups(turretController.AccessGroups);
+            AccessConfiguration.SetAccessLevels(turretController.AccessLevels);
+            UpdateTheme((TurretArmamentSetting)turretController.ArmamentState);
+        }
+
+        if (_entManager.TryGetComponent<TurretTargetSettingsComponent>(_owner, out var turretTargetSettings))
+        {
+            RefreshAccessControls(turretTargetSettings.ExemptAccessLevels);
+        }
+    }
+
+    public void SetOwner(EntityUid owner)
+    {
+        _owner = owner;
+
+        Initialize();
+    }
+
+    private void UpdateTheme(TurretArmamentSetting setting)
+    {
+        var setPressedOn = setting switch
+        {
+            TurretArmamentSetting.Safe => SafeButton,
+            TurretArmamentSetting.Stun => StunButton,
+            TurretArmamentSetting.Lethal => LethalButton,
+            _ => throw new NotImplementedException(),
+        };
+        setPressedOn.Pressed = true;
+
+        var canInteract = IsLocalPlayerAllowedToInteract();
+
+        SafeButton.Disabled = !SafeButton.Pressed && !canInteract;
+        StunButton.Disabled = !StunButton.Pressed && !canInteract;
+        LethalButton.Disabled = !LethalButton.Pressed && !canInteract;
+
+        ContentsContainer.Modulate = ThemeColors[setting];
+    }
+
+    public void UpdateState(DeployableTurretControllerBoundInterfaceState state)
+    {
+        if (_entManager.TryGetComponent<DeployableTurretControllerComponent>(_owner, out var turretController))
+            UpdateTheme((TurretArmamentSetting)turretController.ArmamentState);
+
+        if (_entManager.TryGetComponent<TurretTargetSettingsComponent>(_owner, out var turretTargetSettings))
+            RefreshAccessControls(turretTargetSettings.ExemptAccessLevels);
+
+        RefreshLinkedTurrets(state.TurretStateByAddress);
+    }
+
+    public void RefreshLinkedTurrets(Dictionary<string, string> turretStates)
+    {
+        var turretCount = turretStates.Count;
+        var hasTurrets = turretCount > 0;
+
+        NoLinkedTurretsText.Visible = !hasTurrets;
+        LinkedTurretsContainer.Visible = hasTurrets;
+
+        LinkedTurretsContainer.RemoveAllChildren();
+
+        foreach (var (address, state) in turretStates)
+        {
+            var text = Loc.GetString(
+                "turret-controls-window-turret-status",
+                ("device", address),
+                ("status", Loc.GetString(state))
+            );
+
+            var label = new Label
+            {
+                Text = text,
+                HorizontalAlignment = HAlignment.Left,
+                Margin = new Thickness(10f, 0f, 10f, 0f),
+                HorizontalExpand = true,
+                SetHeight = 20f,
+            };
+
+            label.AddStyleClass("ConsoleText");
+
+            LinkedTurretsContainer.AddChild(label);
+        }
+
+        TurretStatusHeader.Text = Loc.GetString("turret-controls-window-turret-status-label", ("count", turretCount));
+    }
+
+    public void RefreshAccessControls(HashSet<ProtoId<AccessLevelPrototype>> exemptAccessLevels)
+    {
+        AccessConfiguration.SetActiveAccessLevels(exemptAccessLevels);
+        AccessConfiguration.SetLocalPlayerAccessibility(IsLocalPlayerAllowedToInteract());
+    }
+
+    protected override DragMode GetDragModeFor(Vector2 relativeMousePos)
+    {
+        return DragMode.Move;
+    }
+
+    private bool IsLocalPlayerAllowedToInteract()
+    {
+        if (_owner == null || _playerManager.LocalSession?.AttachedEntity == null)
+            return false;
+
+        return _accessReaderSystem.IsAllowed(_playerManager.LocalSession.AttachedEntity.Value, _owner.Value);
+    }
+
+    public enum TurretArmamentSetting
+    {
+        Safe = -1,
+        Stun = 0,
+        Lethal = 1,
+    }
+}

Content.Client/TurretController/TurretControllerWindowBoundUserInterface.cs

@@ -0,0 +1,44 @@
+using Content.Shared.Access;
+using Content.Shared.TurretController;
+using Robust.Client.UserInterface;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.TurretController;
+
+public sealed class TurretControllerWindowBoundUserInterface(EntityUid owner, Enum uiKey) : BoundUserInterface(owner, uiKey)
+{
+    [ViewVariables]
+    private TurretControllerWindow? _window;
+
+    protected override void Open()
+    {
+        base.Open();
+
+        _window = this.CreateWindow<TurretControllerWindow>();
+        _window.SetOwner(Owner);
+        _window.OpenCentered();
+
+        _window.OnAccessLevelsChangedEvent += OnAccessLevelChanged;
+        _window.OnArmamentSettingChangedEvent += OnArmamentSettingChanged;
+    }
+
+    protected override void UpdateState(BoundUserInterfaceState state)
+    {
+        base.UpdateState(state);
+
+        if (state is not DeployableTurretControllerBoundInterfaceState { } castState)
+            return;
+
+        _window?.UpdateState(castState);
+    }
+
+    private void OnAccessLevelChanged(HashSet<ProtoId<AccessLevelPrototype>> accessLevels, bool enabled)
+    {
+        SendPredictedMessage(new DeployableTurretExemptAccessLevelChangedMessage(accessLevels, enabled));
+    }
+
+    private void OnArmamentSettingChanged(TurretControllerWindow.TurretArmamentSetting setting)
+    {
+        SendPredictedMessage(new DeployableTurretArmamentSettingChangedMessage((int)setting));
+    }
+}

Content.Client/Turrets/DeployableTurretSystem.cs

@@ -84,9 +84,6 @@ public sealed partial class DeployableTurretSystem : SharedDeployableTurretSyste
         if (_animation.HasRunningAnimation(ent, animPlayer, DeployableTurretComponent.AnimationKey))
             return;
 
-        if (state == ent.Comp.VisualState)
-            return;
-
         var targetState = state & DeployableTurretState.Deployed;
         var destinationState = ent.Comp.VisualState & DeployableTurretState.Deployed;
 

Content.Client/UserInterface/Controls/MonotoneButton.cs

@@ -7,7 +7,7 @@ namespace Content.Client.UserInterface.Controls;
 /// <summary>
 /// A button intended for use with a monotone color palette
 /// </summary>
-public sealed class MonotoneButton : ContainerButton
+public sealed class MonotoneButton : Button
 {
     /// <summary>
     /// Specifies the color of the label text when the button is pressed.
@@ -15,43 +15,9 @@ public sealed class MonotoneButton : ContainerButton
     [ViewVariables]
     public Color AltTextColor { set; get; } = new Color(0.2f, 0.2f, 0.2f);
 
-    /// <summary>
-    /// The label that holds the button text.
-    /// </summary>
-    public Label Label { get; }
-
-    /// <summary>
-    /// The text displayed by the button.
-    /// </summary>
-    [PublicAPI, ViewVariables]
-    public string? Text { get => Label.Text; set => Label.Text = value; }
-
-    /// <summary>
-    /// How to align the text inside the button.
-    /// </summary>
-    [PublicAPI, ViewVariables]
-    public AlignMode TextAlign { get => Label.Align; set => Label.Align = value; }
-
-    /// <summary>
-    /// If true, the button will allow shrinking and clip text
-    /// to prevent the text from going outside the bounds of the button.
-    /// If false, the minimum size will always fit the contained text.
-    /// </summary>
-    [PublicAPI, ViewVariables]
-    public bool ClipText
-    {
-        get => Label.ClipText;
-        set => Label.ClipText = value;
-    }
-
     public MonotoneButton()
     {
-        Label = new Label
-        {
-            StyleClasses = { StyleClassButton }
-        };
-
-        AddChild(Label);
+        RemoveStyleClass("button");
         UpdateAppearance();
     }
 

Content.Client/UserInterface/Systems/Actions/ActionUIController.cs

@@ -12,6 +12,7 @@ using Content.Client.UserInterface.Systems.Actions.Widgets;
 using Content.Client.UserInterface.Systems.Actions.Windows;
 using Content.Client.UserInterface.Systems.Gameplay;
 using Content.Shared.Actions;
+using Content.Shared.Actions.Components;
 using Content.Shared.Charges.Systems;
 using Content.Shared.Input;
 using Robust.Client.GameObjects;
@@ -162,142 +163,33 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         if (_playerManager.LocalEntity is not { } user)
             return false;
 
-        if (!EntityManager.TryGetComponent(user, out ActionsComponent? comp))
+        if (!EntityManager.TryGetComponent<ActionsComponent>(user, out var comp))
             return false;
 
-        if (!_actionsSystem.TryGetActionData(actionId, out var baseAction) ||
-            baseAction is not BaseTargetActionComponent action)
+        if (_actionsSystem.GetAction(actionId) is not {} action ||
+            !EntityManager.TryGetComponent<TargetActionComponent>(action, out var target))
         {
             return false;
         }
 
         // Is the action currently valid?
-        if (!action.Enabled
-            || action.Cooldown.HasValue && action.Cooldown.Value.End > _timing.CurTime)
+        if (!_actionsSystem.ValidAction(action))
         {
             // The user is targeting with this action, but it is not valid. Maybe mark this click as
             // handled and prevent further interactions.
-            return !action.InteractOnMiss;
+            return !target.InteractOnMiss;
         }
 
-        switch (action)
+        var ev = new ActionTargetAttemptEvent(args, (user, comp), action);
+        EntityManager.EventBus.RaiseLocalEvent(action, ref ev);
+        if (!ev.Handled)
         {
-            case WorldTargetActionComponent mapTarget:
-                return TryTargetWorld(args, actionId, mapTarget, user, comp) || !mapTarget.InteractOnMiss;
-
-            case EntityTargetActionComponent entTarget:
-                return TryTargetEntity(args, actionId, entTarget, user, comp) || !entTarget.InteractOnMiss;
-
-            case EntityWorldTargetActionComponent entMapTarget:
-                return TryTargetEntityWorld(args, actionId, entMapTarget, user, comp) || !entMapTarget.InteractOnMiss;
-
-            default:
-                Logger.Error($"Unknown targeting action: {actionId.GetType()}");
-                return false;
-        }
-    }
-
-    private bool TryTargetWorld(in PointerInputCmdArgs args, EntityUid actionId, WorldTargetActionComponent action, EntityUid user, ActionsComponent actionComp)
-    {
-        if (_actionsSystem == null)
-            return false;
-
-        var coords = args.Coordinates;
-
-        if (!_actionsSystem.ValidateWorldTarget(user, coords, (actionId, action)))
-        {
-            // Invalid target.
-            if (action.DeselectOnMiss)
-                StopTargeting();
-
+            Log.Error($"Action {EntityManager.ToPrettyString(actionId)} did not handle ActionTargetAttemptEvent!");
             return false;
         }
 
-        if (action.ClientExclusive)
-        {
-            if (action.Event != null)
-            {
-                action.Event.Target = coords;
-            }
-
-            _actionsSystem.PerformAction(user, actionComp, actionId, action, action.Event, _timing.CurTime);
-        }
-        else
-            EntityManager.RaisePredictiveEvent(new RequestPerformActionEvent(EntityManager.GetNetEntity(actionId), EntityManager.GetNetCoordinates(coords)));
-
-        if (!action.Repeat)
-            StopTargeting();
-
-        return true;
-    }
-
-    private bool TryTargetEntity(in PointerInputCmdArgs args, EntityUid actionId, EntityTargetActionComponent action, EntityUid user, ActionsComponent actionComp)
-    {
-        if (_actionsSystem == null)
-            return false;
-
-        var entity = args.EntityUid;
-
-        if (!_actionsSystem.ValidateEntityTarget(user, entity, (actionId, action)))
-        {
-            if (action.DeselectOnMiss)
-                StopTargeting();
-
-            return false;
-        }
-
-        if (action.ClientExclusive)
-        {
-            if (action.Event != null)
-            {
-                action.Event.Target = entity;
-            }
-
-            _actionsSystem.PerformAction(user, actionComp, actionId, action, action.Event, _timing.CurTime);
-        }
-        else
-            EntityManager.RaisePredictiveEvent(new RequestPerformActionEvent(EntityManager.GetNetEntity(actionId), EntityManager.GetNetEntity(args.EntityUid)));
-
-        if (!action.Repeat)
-            StopTargeting();
-
-        return true;
-    }
-
-    private bool TryTargetEntityWorld(in PointerInputCmdArgs args,
-        EntityUid actionId,
-        EntityWorldTargetActionComponent action,
-        EntityUid user,
-        ActionsComponent actionComp)
-    {
-        if (_actionsSystem == null)
-            return false;
-
-        var entity = args.EntityUid;
-        var coords = args.Coordinates;
-
-        if (!_actionsSystem.ValidateEntityWorldTarget(user, entity, coords, (actionId, action)))
-        {
-            if (action.DeselectOnMiss)
-                StopTargeting();
-
-            return false;
-        }
-
-        if (action.ClientExclusive)
-        {
-            if (action.Event != null)
-            {
-                action.Event.Entity = entity;
-                action.Event.Coords = coords;
-            }
-
-            _actionsSystem.PerformAction(user, actionComp, actionId, action, action.Event, _timing.CurTime);
-        }
-        else
-            EntityManager.RaisePredictiveEvent(new RequestPerformActionEvent(EntityManager.GetNetEntity(actionId), EntityManager.GetNetEntity(args.EntityUid), EntityManager.GetNetCoordinates(coords)));
-
-        if (!action.Repeat)
+        // stop targeting when needed
+        if (ev.FoundTarget ? !target.Repeat : target.DeselectOnMiss)
             StopTargeting();
 
         return true;
@@ -305,36 +197,26 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
 
     public void UnloadButton()
     {
-        if (ActionButton == null)
-        {
-            return;
-        }
-
-        ActionButton.OnPressed -= ActionButtonPressed;
+        if (ActionButton != null)
+            ActionButton.OnPressed -= ActionButtonPressed;
     }
 
     public void LoadButton()
     {
-        if (ActionButton == null)
-        {
-            return;
-        }
-
-        ActionButton.OnPressed += ActionButtonPressed;
+        if (ActionButton != null)
+            ActionButton.OnPressed += ActionButtonPressed;
     }
 
     private void OnWindowOpened()
     {
-        if (ActionButton != null)
-            ActionButton.SetClickPressed(true);
+        ActionButton?.SetClickPressed(true);
 
         SearchAndDisplay();
     }
 
     private void OnWindowClosed()
     {
-        if (ActionButton != null)
-            ActionButton.SetClickPressed(false);
+        ActionButton?.SetClickPressed(false);
     }
 
     public void OnStateExited(GameplayState state)
@@ -351,35 +233,33 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
 
     private void TriggerAction(int index)
     {
-        if (_actionsSystem == null ||
-            !_actions.TryGetValue(index, out var actionId) ||
-            !_actionsSystem.TryGetActionData(actionId, out var baseAction))
+        if (!_actions.TryGetValue(index, out var actionId) ||
+            _actionsSystem?.GetAction(actionId) is not {} action)
         {
             return;
         }
 
-        if (baseAction is BaseTargetActionComponent action)
-            ToggleTargeting(actionId.Value, action);
+        // TODO: probably should have a clientside event raised for flexibility
+        if (EntityManager.TryGetComponent<TargetActionComponent>(action, out var target))
+            ToggleTargeting((action, action, target));
         else
-            _actionsSystem?.TriggerAction(actionId.Value, baseAction);
+            _actionsSystem?.TriggerAction(action);
     }
 
     private void OnActionAdded(EntityUid actionId)
     {
-        if (_actionsSystem == null ||
-            !_actionsSystem.TryGetActionData(actionId, out var action))
-        {
+        if (_actionsSystem?.GetAction(actionId) is not {} action)
             return;
-        }
 
+        // TODO: event
         // if the action is toggled when we add it, start targeting
-        if (action is BaseTargetActionComponent targetAction && action.Toggled)
-            StartTargeting(actionId, targetAction);
+        if (action.Comp.Toggled && EntityManager.TryGetComponent<TargetActionComponent>(actionId, out var target))
+            StartTargeting((action, action, target));
 
-        if (_actions.Contains(actionId))
+        if (_actions.Contains(action))
             return;
 
-        _actions.Add(actionId);
+        _actions.Add(action);
     }
 
     private void OnActionRemoved(EntityUid actionId)
@@ -437,15 +317,16 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         }
     }
 
-    private bool MatchesFilter(BaseActionComponent action, Filters filter)
+    private bool MatchesFilter(Entity<ActionComponent> ent, Filters filter)
     {
+        var (uid, comp) = ent;
         return filter switch
         {
-            Filters.Enabled => action.Enabled,
-            Filters.Item => action.Container != null && action.Container != _playerManager.LocalEntity,
-            Filters.Innate => action.Container == null || action.Container == _playerManager.LocalEntity,
-            Filters.Instant => action is InstantActionComponent,
-            Filters.Targeted => action is BaseTargetActionComponent,
+            Filters.Enabled => comp.Enabled,
+            Filters.Item => comp.Container != null && comp.Container != _playerManager.LocalEntity,
+            Filters.Innate => comp.Container == null || comp.Container == _playerManager.LocalEntity,
+            Filters.Instant => EntityManager.HasComponent<InstantActionComponent>(uid),
+            Filters.Targeted => EntityManager.HasComponent<TargetActionComponent>(uid),
             _ => throw new ArgumentOutOfRangeException(nameof(filter), filter, null)
         };
     }
@@ -456,7 +337,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
             _window.ResultsGrid.RemoveAllChildren();
     }
 
-    private void PopulateActions(IEnumerable<(EntityUid Id, BaseActionComponent Comp)> actions)
+    private void PopulateActions(IEnumerable<Entity<ActionComponent>> actions)
     {
         if (_window is not { Disposed: false, IsOpen: true })
             return;
@@ -478,7 +359,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         {
             if (i < existing.Count)
             {
-                existing[i++].UpdateData(action.Id, _actionsSystem);
+                existing[i++].UpdateData(action, _actionsSystem);
                 continue;
             }
 
@@ -486,7 +367,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
             button.ActionPressed += OnWindowActionPressed;
             button.ActionUnpressed += OnWindowActionUnPressed;
             button.ActionFocusExited += OnWindowActionFocusExisted;
-            button.UpdateData(action.Id, _actionsSystem);
+            button.UpdateData(action, _actionsSystem);
             _window.ResultsGrid.AddChild(button);
         }
 
@@ -525,13 +406,13 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
 
         actions = actions.Where(action =>
         {
-            if (filters.Count > 0 && filters.Any(filter => !MatchesFilter(action.Comp, filter)))
+            if (filters.Count > 0 && filters.Any(filter => !MatchesFilter(action, filter)))
                 return false;
 
             if (action.Comp.Keywords.Any(keyword => search.Contains(keyword, StringComparison.OrdinalIgnoreCase)))
                 return true;
 
-            var name = EntityManager.GetComponent<MetaDataComponent>(action.Id).EntityName;
+            var name = EntityManager.GetComponent<MetaDataComponent>(action).EntityName;
             if (name.Contains(search, StringComparison.OrdinalIgnoreCase))
                 return true;
 
@@ -581,7 +462,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
 
     private void DragAction()
     {
-        if (_menuDragHelper.Dragged is not {ActionId: {} action} dragged)
+        if (_menuDragHelper.Dragged is not {Action: {} action} dragged)
         {
             _menuDragHelper.EndDrag();
             return;
@@ -591,7 +472,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         var currentlyHovered = UIManager.MouseGetControl(_input.MouseScreenPosition);
         if (currentlyHovered is ActionButton button)
         {
-            swapAction = button.ActionId;
+            swapAction = button.Action;
             SetAction(button, action, false);
         }
 
@@ -665,16 +546,13 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
     private void HandleActionPressed(GUIBoundKeyEventArgs args, ActionButton button)
     {
         args.Handle();
-        if (button.ActionId != null)
+        if (button.Action != null)
         {
             _menuDragHelper.MouseDown(button);
             return;
         }
 
-        var ev = new FillActionSlotEvent();
-        EntityManager.EventBus.RaiseEvent(EventSource.Local, ev);
-        if (ev.Action != null)
-            SetAction(button, ev.Action);
+        // good job
     }
 
     private void OnActionUnpressed(GUIBoundKeyEventArgs args, ActionButton button)
@@ -700,12 +578,13 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
 
         _menuDragHelper.EndDrag();
 
-        if (!_actionsSystem.TryGetActionData(button.ActionId, out var baseAction))
+        if (button.Action is not {} action)
             return;
 
-        if (baseAction is not BaseTargetActionComponent action)
+        // TODO: make this an event
+        if (!EntityManager.TryGetComponent<TargetActionComponent>(action, out var target))
         {
-            _actionsSystem?.TriggerAction(button.ActionId.Value, baseAction);
+            _actionsSystem?.TriggerAction(action);
             return;
         }
 
@@ -714,7 +593,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
 
         // if we're clicking the same thing we're already targeting for, then we simply cancel
         // targeting
-        ToggleTargeting(button.ActionId.Value, action);
+        ToggleTargeting((action, action.Comp, target));
     }
 
     private bool OnMenuBeginDrag()
@@ -722,16 +601,16 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         // TODO ACTIONS
         // The dragging icon shuld be based on the entity's icon style. I.e. if the action has a large icon texture,
         // and a small item/provider sprite, then the dragged icon should be the big texture, not the provider.
-        if (_actionsSystem != null && _actionsSystem.TryGetActionData(_menuDragHelper.Dragged?.ActionId, out var action))
+        if (_menuDragHelper.Dragged?.Action is {} action)
         {
-            if (EntityManager.TryGetComponent(action.EntityIcon, out SpriteComponent? sprite)
+            if (EntityManager.TryGetComponent(action.Comp.EntityIcon, out SpriteComponent? sprite)
                 && sprite.Icon?.GetFrame(RsiDirection.South, 0) is {} frame)
             {
                 _dragShadow.Texture = frame;
             }
-            else if (action.Icon != null)
+            else if (action.Comp.Icon is {} icon)
             {
-                _dragShadow.Texture = _spriteSystem.Frame0(action.Icon);
+                _dragShadow.Texture = _spriteSystem.Frame0(icon);
             }
             else
             {
@@ -898,33 +777,35 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
     /// If currently targeting with no slot or a different slot, switches to
     /// targeting with the specified slot.
     /// </summary>
-    private void ToggleTargeting(EntityUid actionId, BaseTargetActionComponent action)
+    private void ToggleTargeting(Entity<ActionComponent, TargetActionComponent> ent)
     {
-        if (SelectingTargetFor == actionId)
+        if (SelectingTargetFor == ent)
         {
             StopTargeting();
             return;
         }
 
-        StartTargeting(actionId, action);
+        StartTargeting(ent);
     }
 
     /// <summary>
     /// Puts us in targeting mode, where we need to pick either a target point or entity
     /// </summary>
-    private void StartTargeting(EntityUid actionId, BaseTargetActionComponent action)
+    private void StartTargeting(Entity<ActionComponent, TargetActionComponent> ent)
     {
+        var (uid, action, target) = ent;
+
         // If we were targeting something else we should stop
         StopTargeting();
 
-        SelectingTargetFor = actionId;
+        SelectingTargetFor = uid;
         // TODO inform the server
-        action.Toggled = true;
+        _actionsSystem?.SetToggled(uid, true);
 
         // override "held-item" overlay
         var provider = action.Container;
 
-        if (action.TargetingIndicator && _overlays.TryGetOverlay<ShowHandItemOverlay>(out var handOverlay))
+        if (target.TargetingIndicator && _overlays.TryGetOverlay<ShowHandItemOverlay>(out var handOverlay))
         {
             if (action.ItemIconStyle == ItemActionIconStyle.BigItem && action.Container != null)
             {
@@ -940,7 +821,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         {
             foreach (var button in _container.GetButtons())
             {
-                if (button.ActionId == actionId)
+                if (button.Action?.Owner == uid)
                     button.UpdateIcons();
             }
         }
@@ -950,19 +831,19 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         // - Add a yes/no checkmark where the HandItemOverlay usually is
 
         // Highlight valid entity targets
-        if (action is not EntityTargetActionComponent entityAction)
+        if (!EntityManager.TryGetComponent<EntityTargetActionComponent>(uid, out var entity))
             return;
 
         Func<EntityUid, bool>? predicate = null;
-        var attachedEnt = entityAction.AttachedEntity;
+        var attachedEnt = action.AttachedEntity;
 
-        if (!entityAction.CanTargetSelf)
+        if (!entity.CanTargetSelf)
             predicate = e => e != attachedEnt;
 
-        var range = entityAction.CheckCanAccess ? action.Range : -1;
+        var range = target.CheckCanAccess ? target.Range : -1;
 
         _interactionOutline?.SetEnabled(false);
-        _targetOutline?.Enable(range, entityAction.CheckCanAccess, predicate, entityAction.Whitelist, entityAction.Blacklist, null);
+        _targetOutline?.Enable(range, target.CheckCanAccess, predicate, entity.Whitelist, entity.Blacklist, null);
     }
 
     /// <summary>
@@ -974,11 +855,8 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
             return;
 
         var oldAction = SelectingTargetFor;
-        if (_actionsSystem != null && _actionsSystem.TryGetActionData(oldAction, out var action))
-        {
-            // TODO inform the server
-            action.Toggled = false;
-        }
+        // TODO inform the server
+        _actionsSystem?.SetToggled(oldAction, false);
 
         SelectingTargetFor = null;
 
@@ -989,7 +867,7 @@ public sealed class ActionUIController : UIController, IOnStateChanged<GameplayS
         {
             foreach (var button in _container.GetButtons())
             {
-                if (button.ActionId == oldAction)
+                if (button.Action?.Owner == oldAction)
                     button.UpdateIcons();
             }
         }

Content.Client/UserInterface/Systems/Actions/Controls/ActionButton.cs

@@ -4,6 +4,7 @@ using Content.Client.Actions.UI;
 using Content.Client.Cooldown;
 using Content.Client.Stylesheets;
 using Content.Shared.Actions;
+using Content.Shared.Actions.Components;
 using Content.Shared.Charges.Components;
 using Content.Shared.Charges.Systems;
 using Robust.Client.GameObjects;
@@ -54,8 +55,7 @@ public sealed class ActionButton : Control, IEntityControl
 
     private Texture? _buttonBackgroundTexture;
 
-    public EntityUid? ActionId { get; private set; }
-    private BaseActionComponent? _action;
+    public Entity<ActionComponent>? Action { get; private set; }
     public bool Locked { get; set; }
 
     public event Action<GUIBoundKeyEventArgs, ActionButton>? ActionPressed;
@@ -193,7 +193,7 @@ public sealed class ActionButton : Control, IEntityControl
 
     private Control? SupplyTooltip(Control sender)
     {
-        if (!_entities.TryGetComponent(ActionId, out MetaDataComponent? metadata))
+        if (!_entities.TryGetComponent(Action, out MetaDataComponent? metadata))
             return null;
 
         var name = FormattedMessage.FromMarkupPermissive(Loc.GetString(metadata.EntityName));
@@ -201,14 +201,14 @@ public sealed class ActionButton : Control, IEntityControl
         FormattedMessage? chargesText = null;
 
         // TODO: Don't touch this use an event make callers able to add their own shit for actions or I kill you.
-        if (_entities.TryGetComponent(ActionId, out LimitedChargesComponent? actionCharges))
+        if (_entities.TryGetComponent(Action, out LimitedChargesComponent? actionCharges))
         {
-            var charges = _sharedChargesSys.GetCurrentCharges((ActionId.Value, actionCharges, null));
+            var charges = _sharedChargesSys.GetCurrentCharges((Action.Value, actionCharges, null));
             chargesText = FormattedMessage.FromMarkupPermissive(Loc.GetString($"Charges: {charges.ToString()}/{actionCharges.MaxCharges}"));
 
-            if (_entities.TryGetComponent(ActionId, out AutoRechargeComponent? autoRecharge))
+            if (_entities.TryGetComponent(Action, out AutoRechargeComponent? autoRecharge))
             {
-                var chargeTimeRemaining = _sharedChargesSys.GetNextRechargeTime((ActionId.Value, actionCharges, autoRecharge));
+                var chargeTimeRemaining = _sharedChargesSys.GetNextRechargeTime((Action.Value, actionCharges, autoRecharge));
                 chargesText.AddText(Loc.GetString($"{Environment.NewLine}Time Til Recharge: {chargeTimeRemaining}"));
             }
         }
@@ -223,7 +223,7 @@ public sealed class ActionButton : Control, IEntityControl
 
     private void UpdateItemIcon()
     {
-        if (_action is not {EntityIcon: { } entity} ||
+        if (Action?.Comp is not {EntityIcon: { } entity} ||
             !_entities.HasComponent<SpriteComponent>(entity))
         {
             _bigItemSpriteView.Visible = false;
@@ -233,7 +233,7 @@ public sealed class ActionButton : Control, IEntityControl
         }
         else
         {
-            switch (_action.ItemIconStyle)
+            switch (Action?.Comp.ItemIconStyle)
             {
                 case ItemActionIconStyle.BigItem:
                     _bigItemSpriteView.Visible = true;
@@ -259,17 +259,17 @@ public sealed class ActionButton : Control, IEntityControl
 
     private void SetActionIcon(Texture? texture)
     {
-        if (_action == null || texture == null)
+        if (Action?.Comp is not {} action || texture == null)
         {
             _bigActionIcon.Texture = null;
             _bigActionIcon.Visible = false;
             _smallActionIcon.Texture = null;
             _smallActionIcon.Visible = false;
         }
-        else if (_action.EntityIcon != null && _action.ItemIconStyle == ItemActionIconStyle.BigItem)
+        else if (action.EntityIcon != null && action.ItemIconStyle == ItemActionIconStyle.BigItem)
         {
             _smallActionIcon.Texture = texture;
-            _smallActionIcon.Modulate = _action.IconColor;
+            _smallActionIcon.Modulate = action.IconColor;
             _smallActionIcon.Visible = true;
             _bigActionIcon.Texture = null;
             _bigActionIcon.Visible = false;
@@ -277,7 +277,7 @@ public sealed class ActionButton : Control, IEntityControl
         else
         {
             _bigActionIcon.Texture = texture;
-            _bigActionIcon.Modulate = _action.IconColor;
+            _bigActionIcon.Modulate = action.IconColor;
             _bigActionIcon.Visible = true;
             _smallActionIcon.Texture = null;
             _smallActionIcon.Visible = false;
@@ -289,7 +289,7 @@ public sealed class ActionButton : Control, IEntityControl
         UpdateItemIcon();
         UpdateBackground();
 
-        if (_action == null)
+        if (Action is not {} action)
         {
             SetActionIcon(null);
             return;
@@ -297,29 +297,27 @@ public sealed class ActionButton : Control, IEntityControl
 
         _controller ??= UserInterfaceManager.GetUIController<ActionUIController>();
         _spriteSys ??= _entities.System<SpriteSystem>();
-        if ((_controller.SelectingTargetFor == ActionId || _action.Toggled))
+        var icon = action.Comp.Icon;
+        if (_controller.SelectingTargetFor == action || action.Comp.Toggled)
         {
-            if (_action.IconOn != null)
-                SetActionIcon(_spriteSys.Frame0(_action.IconOn));
-            else if (_action.Icon != null)
-                SetActionIcon(_spriteSys.Frame0(_action.Icon));
-            else
-                SetActionIcon(null);
+            if (action.Comp.IconOn is {} iconOn)
+                icon = iconOn;
 
-            if (_action.BackgroundOn != null)
-                _buttonBackgroundTexture = _spriteSys.Frame0(_action.BackgroundOn);
+            if (action.Comp.BackgroundOn is {} background)
+                _buttonBackgroundTexture = _spriteSys.Frame0(background);
         }
         else
         {
-            SetActionIcon(_action.Icon != null ? _spriteSys.Frame0(_action.Icon) : null);
             _buttonBackgroundTexture = Theme.ResolveTexture("SlotBackground");
         }
+
+        SetActionIcon(icon != null ? _spriteSys.Frame0(icon) : null);
     }
 
     public void UpdateBackground()
     {
         _controller ??= UserInterfaceManager.GetUIController<ActionUIController>();
-        if (_action != null ||
+        if (Action != null ||
             _controller.IsDragging && GetPositionInParent() == Parent?.ChildCount - 1)
         {
             Button.Texture = _buttonBackgroundTexture;
@@ -333,9 +331,7 @@ public sealed class ActionButton : Control, IEntityControl
     public bool TryReplaceWith(EntityUid actionId, ActionsSystem system)
     {
         if (Locked)
-        {
             return false;
-        }
 
         UpdateData(actionId, system);
         return true;
@@ -343,16 +339,15 @@ public sealed class ActionButton : Control, IEntityControl
 
     public void UpdateData(EntityUid? actionId, ActionsSystem system)
     {
-        ActionId = actionId;
-        system.TryGetActionData(actionId, out _action);
-        Label.Visible = actionId != null;
+        Action = system.GetAction(actionId);
+
+        Label.Visible = Action != null;
         UpdateIcons();
     }
 
     public void ClearData()
     {
-        ActionId = null;
-        _action = null;
+        Action = null;
         Cooldown.Visible = false;
         Cooldown.Progress = 1;
         Label.Visible = false;
@@ -365,19 +360,15 @@ public sealed class ActionButton : Control, IEntityControl
 
         UpdateBackground();
 
-        Cooldown.Visible = _action != null && _action.Cooldown != null;
-        if (_action == null)
+        Cooldown.Visible = Action?.Comp.Cooldown != null;
+        if (Action?.Comp is not {} action)
             return;
 
-        if (_action.Cooldown != null)
-        {
-            Cooldown.FromTime(_action.Cooldown.Value.Start, _action.Cooldown.Value.End);
-        }
+        if (action.Cooldown is {} cooldown)
+            Cooldown.FromTime(cooldown.Start, cooldown.End);
 
-        if (ActionId != null && _toggled != _action.Toggled)
-        {
-            _toggled = _action.Toggled;
-        }
+        if (_toggled != action.Toggled)
+            _toggled = action.Toggled;
     }
 
     protected override void MouseEntered()
@@ -404,7 +395,7 @@ public sealed class ActionButton : Control, IEntityControl
     public void Depress(GUIBoundKeyEventArgs args, bool depress)
     {
         // action can still be toggled if it's allowed to stay selected
-        if (_action is not {Enabled: true})
+        if (Action?.Comp is not {Enabled: true})
             return;
 
         _depressed = depress;
@@ -414,17 +405,17 @@ public sealed class ActionButton : Control, IEntityControl
     public void DrawModeChanged()
     {
         _controller ??= UserInterfaceManager.GetUIController<ActionUIController>();
-        HighlightRect.Visible = _beingHovered && (_action != null || _controller.IsDragging);
+        HighlightRect.Visible = _beingHovered && (Action != null || _controller.IsDragging);
 
         // always show the normal empty button style if no action in this slot
-        if (_action == null)
+        if (Action?.Comp is not {} action)
         {
             SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassNormal);
             return;
         }
 
         // show a hover only if the action is usable or another action is being dragged on top of this
-        if (_beingHovered && (_controller.IsDragging || _action!.Enabled))
+        if (_beingHovered && (_controller.IsDragging || action.Enabled))
         {
             SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassHover);
         }
@@ -439,16 +430,16 @@ public sealed class ActionButton : Control, IEntityControl
         }
 
         // if it's toggled on, always show the toggled on style (currently same as depressed style)
-        if (_action.Toggled || _controller.SelectingTargetFor == ActionId)
+        if (action.Toggled || _controller.SelectingTargetFor == Action?.Owner)
         {
             // when there's a toggle sprite, we're showing that sprite instead of highlighting this slot
-            SetOnlyStylePseudoClass(_action.IconOn != null
+            SetOnlyStylePseudoClass(action.IconOn != null
                 ? ContainerButton.StylePseudoClassNormal
                 : ContainerButton.StylePseudoClassPressed);
             return;
         }
 
-        if (!_action.Enabled)
+        if (!action.Enabled)
         {
             SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassDisabled);
             return;
@@ -457,5 +448,5 @@ public sealed class ActionButton : Control, IEntityControl
         SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassNormal);
     }
 
-    EntityUid? IEntityControl.UiEntity => ActionId;
+    EntityUid? IEntityControl.UiEntity => Action;
 }

Content.Client/UserInterface/Systems/Bwoink/AHelpUIController.cs

@@ -48,6 +48,8 @@ public sealed class AHelpUIController: UIController, IOnSystemChanged<BwoinkSyst
     private bool _bwoinkSoundEnabled;
     private string? _aHelpSound;
 
+    protected override string SawmillName => "c.s.go.es.bwoink";
+
     public override void Initialize()
     {
         base.Initialize();
@@ -129,7 +131,7 @@ public sealed class AHelpUIController: UIController, IOnSystemChanged<BwoinkSyst
 
     private void ReceivedBwoink(object? sender, SharedBwoinkSystem.BwoinkTextMessage message)
     {
-        Logger.InfoS("c.s.go.es.bwoink", $"@{message.UserId}: {message.Text}");
+        Log.Info($"@{message.UserId}: {message.Text}");
         var localPlayer = _playerManager.LocalSession;
         if (localPlayer == null)
         {

Content.Client/UserInterface/Systems/Character/CharacterUIController.cs

@@ -28,21 +28,16 @@ namespace Content.Client.UserInterface.Systems.Character;
 public sealed class CharacterUIController : UIController, IOnStateEntered<GameplayState>, IOnStateExited<GameplayState>, IOnSystemChanged<CharacterInfoSystem>
 {
     [Dependency] private readonly IEntityManager _ent = default!;
-    [Dependency] private readonly ILogManager _logMan = default!;
     [Dependency] private readonly IPlayerManager _player = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
 
     [UISystemDependency] private readonly CharacterInfoSystem _characterInfo = default!;
     [UISystemDependency] private readonly SpriteSystem _sprite = default!;
 
-    private ISawmill _sawmill = default!;
-
     public override void Initialize()
     {
         base.Initialize();
 
-        _sawmill = _logMan.GetSawmill("character");
-
         SubscribeNetworkEvent<MindRoleTypeChangedEvent>(OnRoleTypeChanged);
     }
 
@@ -222,7 +217,7 @@ public sealed class CharacterUIController : UIController, IOnStateEntered<Gamepl
             return;
 
         if (!_prototypeManager.TryIndex(mind.RoleType, out var proto))
-            _sawmill.Error($"Player '{_player.LocalSession}' has invalid Role Type '{mind.RoleType}'. Displaying default instead");
+            Log.Error($"Player '{_player.LocalSession}' has invalid Role Type '{mind.RoleType}'. Displaying default instead");
 
         _window.RoleType.Text = Loc.GetString(proto?.Name ?? "role-type-crew-aligned-name");
         _window.RoleType.FontColorOverride = proto?.Color ?? Color.White;

Content.Client/UserInterface/Systems/Chat/ChatUIController.Highlighting.cs

@@ -0,0 +1,156 @@
+using System.Linq;
+using System.Text.RegularExpressions;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controllers;
+using Content.Shared.CCVar;
+using Content.Client.CharacterInfo;
+using static Content.Client.CharacterInfo.CharacterInfoSystem;
+
+namespace Content.Client.UserInterface.Systems.Chat;
+
+/// <summary>
+/// A partial class of ChatUIController that handles the saving and loading of highlights for the chatbox.
+/// It also makes use of the CharacterInfoSystem to optionally generate highlights based on the character's info.
+/// </summary>
+public sealed partial class ChatUIController : IOnSystemChanged<CharacterInfoSystem>
+{
+    [UISystemDependency] private readonly CharacterInfoSystem _characterInfo = default!;
+
+    /// <summary>
+    ///     The list of words to be highlighted in the chatbox.
+    /// </summary>
+    private List<string> _highlights = new();
+
+    /// <summary>
+    ///     The string holding the hex color used to highlight words.
+    /// </summary>
+    private string? _highlightsColor;
+
+    private bool _autoFillHighlightsEnabled;
+
+    /// <summary>
+    ///     The boolean that keeps track of the 'OnCharacterUpdated' event, whenever it's a player attaching or opening the character info panel.
+    /// </summary>
+    private bool _charInfoIsAttach = false;
+
+    public event Action<string>? HighlightsUpdated;
+
+    private void InitializeHighlights()
+    {
+        _config.OnValueChanged(CCVars.ChatAutoFillHighlights, (value) => { _autoFillHighlightsEnabled = value; }, true);
+
+        _config.OnValueChanged(CCVars.ChatHighlightsColor, (value) => { _highlightsColor = value; }, true);
+
+        // Load highlights if any were saved.
+        string highlights = _config.GetCVar(CCVars.ChatHighlights);
+
+        if (!string.IsNullOrEmpty(highlights))
+        {
+            UpdateHighlights(highlights, true);
+        }
+    }
+
+    public void OnSystemLoaded(CharacterInfoSystem system)
+    {
+        system.OnCharacterUpdate += OnCharacterUpdated;
+    }
+
+    public void OnSystemUnloaded(CharacterInfoSystem system)
+    {
+        system.OnCharacterUpdate -= OnCharacterUpdated;
+    }
+
+    private void UpdateAutoFillHighlights()
+    {
+        if (!_autoFillHighlightsEnabled)
+            return;
+
+        // If auto highlights are enabled generate a request for new character info
+        // that will be used to determine the highlights.
+        _charInfoIsAttach = true;
+        _characterInfo.RequestCharacterInfo();
+    }
+
+    public void UpdateHighlights(string newHighlights, bool firstLoad = false)
+    {
+        // Do nothing if the provided highlights are the same as the old ones and it is not the first time.
+        if (!firstLoad && _config.GetCVar(CCVars.ChatHighlights).Equals(newHighlights, StringComparison.CurrentCultureIgnoreCase))
+            return;
+
+        _config.SetCVar(CCVars.ChatHighlights, newHighlights);
+        _config.SaveToFile();
+
+        _highlights.Clear();
+
+        // We first subdivide the highlights based on newlines to prevent replacing
+        // a valid "\n" tag and adding it to the final regex.
+        string[] splittedHighlights = newHighlights.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+
+        for (int i = 0; i < splittedHighlights.Length; i++)
+        {
+            // Replace every "\" character with a "\\" to prevent "\n", "\0", etc...
+            string keyword = splittedHighlights[i].Replace(@"\", @"\\");
+
+            // Escape the keyword to prevent special characters like "(" and ")" to be considered valid regex.
+            keyword = Regex.Escape(keyword);
+
+            // 1. Since the "["s in WrappedMessage are already sanitized, add 2 extra "\"s
+            // to make sure it matches the literal "\" before the square bracket.
+            keyword = keyword.Replace(@"\[", @"\\\[");
+
+            // If present, replace the double quotes at the edges with tags
+            // that make sure the words to match are separated by spaces or punctuation.
+            // NOTE: The reason why we don't use \b tags is that \b doesn't match reverse slash characters "\" so
+            // a pre-sanitized (see 1.) string like "\[test]" wouldn't get picked up by the \b.
+            if (keyword.Count(c => (c == '"')) > 0)
+            {
+                // Matches the last double quote character.
+                keyword = Regex.Replace(keyword, "\"$", "(?!\\w)");
+                // When matching for the first double quote character we also consider the possibility
+                // of the double quote being preceded by a @ character.
+                keyword = Regex.Replace(keyword, "^\"|(?<=^@)\"", "(?<!\\w)");
+            }
+
+            // Make sure any name tagged as ours gets highlighted only when others say it.
+            keyword = Regex.Replace(keyword, "^@", "(?<=(?<=/name.*)|(?<=,.*\"\".*))");
+
+            _highlights.Add(keyword);
+        }
+
+        // Arrange the list of highlights in descending order so that when highlighting,
+        // the full word (eg. "Security") gets picked before the abbreviation (eg. "Sec").
+        _highlights.Sort((x, y) => y.Length.CompareTo(x.Length));
+    }
+
+    private void OnCharacterUpdated(CharacterData data)
+    {
+        // If _charInfoIsAttach is false then the opening of the character panel was the one
+        // to generate the event, dismiss it.
+        if (!_charInfoIsAttach)
+            return;
+
+        var (_, job, _, _, entityName) = data;
+
+        // Mark this entity's name as our character name for the "UpdateHighlights" function.
+        string newHighlights = "@" + entityName;
+
+        // Subdivide the character's name based on spaces or hyphens so that every word gets highlighted.
+        if (newHighlights.Count(c => (c == ' ' || c == '-')) == 1)
+            newHighlights = newHighlights.Replace("-", "\n@").Replace(" ", "\n@");
+
+        // If the character has a name with more than one hyphen assume it is a lizard name and extract the first and
+        // last name eg. "Eats-The-Food" -> "@Eats" "@Food"
+        if (newHighlights.Count(c => c == '-') > 1)
+            newHighlights = newHighlights.Split('-')[0] + "\n@" + newHighlights.Split('-')[^1];
+
+        // Convert the job title to kebab-case and use it as a key for the loc file.
+        string jobKey = job.Replace(' ', '-').ToLower();
+
+        if (Loc.TryGetString($"highlights-{jobKey}", out var jobMatches))
+            newHighlights += '\n' + jobMatches.Replace(", ", "\n");
+
+        UpdateHighlights(newHighlights);
+        HighlightsUpdated?.Invoke(newHighlights);
+        _charInfoIsAttach = false;
+    }
+}

Content.Client/UserInterface/Systems/Chat/ChatUIController.cs

@@ -41,9 +41,10 @@ using Robust.Shared.Replays;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
+
 namespace Content.Client.UserInterface.Systems.Chat;
 
-public sealed class ChatUIController : UIController
+public sealed partial class ChatUIController : UIController
 {
     [Dependency] private readonly IClientAdminManager _admin = default!;
     [Dependency] private readonly IChatManager _manager = default!;
@@ -240,6 +241,7 @@ public sealed class ChatUIController : UIController
 
         _config.OnValueChanged(CCVars.ChatWindowOpacity, OnChatWindowOpacityChanged);
 
+        InitializeHighlights();
     }
 
     public void OnScreenLoad()
@@ -426,6 +428,8 @@ public sealed class ChatUIController : UIController
     private void OnAttachedChanged(EntityUid uid)
     {
         UpdateChannelPermissions();
+
+        UpdateAutoFillHighlights();
     }
 
     private void AddSpeechBubble(ChatMessage msg, SpeechBubble.SpeechType speechType)
@@ -825,6 +829,12 @@ public sealed class ChatUIController : UIController
                 msg.WrappedMessage = SharedChatSystem.InjectTagInsideTag(msg, "Name", "color", GetNameColor(SharedChatSystem.GetStringInsideTag(msg, "Name")));
         }
 
+        // Color any words chosen by the client.
+        foreach (var highlight in _highlights)
+        {
+            msg.WrappedMessage = SharedChatSystem.InjectTagAroundString(msg, highlight, "color", _highlightsColor);
+        }
+
         // Color any codewords for minds that have roles that use them
         if (_player.LocalUser != null && _mindSystem != null && _roleCodewordSystem != null)
         {

Content.Client/UserInterface/Systems/Chat/Controls/ChannelFilterPopup.xaml

@@ -1,10 +1,22 @@
 <controls:ChannelFilterPopup
     xmlns="https://spacestation14.io"
+    xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
     xmlns:controls="clr-namespace:Content.Client.UserInterface.Systems.Chat.Controls">
     <PanelContainer Name="FilterPopupPanel" StyleClasses="BorderedWindowPanel">
-        <BoxContainer Orientation="Horizontal">
-            <Control MinSize="4 0"/>
-            <BoxContainer Name="FilterVBox" MinWidth="110" Margin="0 10" Orientation="Vertical" SeparationOverride="4"/>
+        <BoxContainer Orientation="Horizontal" SeparationOverride="8" Margin="10 0">
+            <BoxContainer Name="FilterVBox" MinWidth="105" Margin="0 10" Orientation="Vertical" SeparationOverride="4"/>
+            <BoxContainer Name="HighlightsVBox" MinWidth="120" Margin="0 10" Orientation="Vertical" SeparationOverride="4">
+                <Label Text="{Loc 'hud-chatbox-highlights'}"/>
+                <PanelContainer>
+                    <!-- Begin custom background for TextEdit -->
+                    <PanelContainer.PanelOverride>
+                        <gfx:StyleBoxFlat BackgroundColor="#323446"/>
+                    </PanelContainer.PanelOverride>
+                    <!-- End custom background -->
+                    <TextEdit Name="HighlightEdit" MinHeight="150" Margin="5 5"/>
+                </PanelContainer>
+                <Button Name="HighlightButton" Text="{Loc 'hud-chatbox-highlights-button'}" ToolTip="{Loc 'hud-chatbox-highlights-tooltip'}"/>
+            </BoxContainer>
         </BoxContainer>
     </PanelContainer>
 </controls:ChannelFilterPopup>

Content.Client/UserInterface/Systems/Chat/Controls/ChannelFilterPopup.xaml.cs

@@ -1,4 +1,7 @@
 using Content.Shared.Chat;
+using Content.Shared.CCVar;
+using Robust.Shared.Utility;
+using Robust.Shared.Configuration;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
@@ -29,10 +32,24 @@ public sealed partial class ChannelFilterPopup : Popup
     private readonly Dictionary<ChatChannel, ChannelFilterCheckbox> _filterStates = new();
 
     public event Action<ChatChannel, bool>? OnChannelFilter;
+    public event Action<string>? OnNewHighlights;
 
     public ChannelFilterPopup()
     {
         RobustXamlLoader.Load(this);
+
+        HighlightButton.OnPressed += HighlightsEntered;
+        // Add a placeholder text to the highlights TextEdit.
+        HighlightEdit.Placeholder = new Rope.Leaf(Loc.GetString("hud-chatbox-highlights-placeholder"));
+
+        // Load highlights if any were saved.
+        var cfg = IoCManager.Resolve<IConfigurationManager>();
+        string highlights = cfg.GetCVar(CCVars.ChatHighlights);
+
+        if (!string.IsNullOrEmpty(highlights))
+        {
+            UpdateHighlights(highlights);
+        }
     }
 
     public bool IsActive(ChatChannel channel)
@@ -92,12 +109,22 @@ public sealed partial class ChannelFilterPopup : Popup
         }
     }
 
+    public void UpdateHighlights(string highlights)
+    {
+        HighlightEdit.TextRope = new Rope.Leaf(highlights);
+    }
+
     private void CheckboxPressed(ButtonEventArgs args)
     {
         var checkbox = (ChannelFilterCheckbox) args.Button;
         OnChannelFilter?.Invoke(checkbox.Channel, checkbox.Pressed);
     }
 
+    private void HighlightsEntered(ButtonEventArgs _args)
+    {
+        OnNewHighlights?.Invoke(Rope.Collapse(HighlightEdit.TextRope));
+    }
+
     public void UpdateUnread(ChatChannel channel, int? unread)
     {
         if (_filterStates.TryGetValue(channel, out var checkbox))

Content.Client/UserInterface/Systems/Chat/Widgets/ChatBox.xaml.cs

@@ -38,9 +38,10 @@ public partial class ChatBox : UIWidget
         ChatInput.Input.OnFocusExit += OnFocusExit;
         ChatInput.ChannelSelector.OnChannelSelect += OnChannelSelect;
         ChatInput.FilterButton.Popup.OnChannelFilter += OnChannelFilter;
-
+        ChatInput.FilterButton.Popup.OnNewHighlights += OnNewHighlights;
         _controller = UserInterfaceManager.GetUIController<ChatUIController>();
         _controller.MessageAdded += OnMessageAdded;
+        _controller.HighlightsUpdated += OnHighlightsUpdated;
         _controller.RegisterChat(this);
     }
 
@@ -67,6 +68,11 @@ public partial class ChatBox : UIWidget
         AddLine(msg.WrappedMessage, color);
     }
 
+    private void OnHighlightsUpdated(string highlights)
+    {
+        ChatInput.FilterButton.Popup.UpdateHighlights(highlights);
+    }
+
     private void OnChannelSelect(ChatSelectChannel channel)
     {
         _controller.UpdateSelectedChannel(this);
@@ -97,6 +103,11 @@ public partial class ChatBox : UIWidget
         }
     }
 
+    private void OnNewHighlights(string highlighs)
+    {
+        _controller.UpdateHighlights(highlighs);
+    }
+
     public void AddLine(string message, Color color)
     {
         var formatted = new FormattedMessage(3);

Content.Client/UserInterface/Systems/Guidebook/GuidebookUIController.cs

@@ -227,7 +227,7 @@ public sealed class GuidebookUIController : UIController, IOnStateEntered<LobbyS
         {
             if (!_prototypeManager.TryIndex(guideId, out var guide))
             {
-                Logger.Error($"Encountered unknown guide prototype: {guideId}");
+                Log.Error($"Encountered unknown guide prototype: {guideId}");
                 continue;
             }
             guides.Add(guideId, guide);
@@ -257,7 +257,7 @@ public sealed class GuidebookUIController : UIController, IOnStateEntered<LobbyS
 
             if (!_prototypeManager.TryIndex(childId, out var child))
             {
-                Logger.Error($"Encountered unknown guide prototype: {childId} as a child of {guide.Id}. If the child is not a prototype, it must be directly provided.");
+                Log.Error($"Encountered unknown guide prototype: {childId} as a child of {guide.Id}. If the child is not a prototype, it must be directly provided.");
                 continue;
             }
 

Content.Client/UserInterface/Systems/Info/InfoUIController.cs

@@ -15,22 +15,21 @@ public sealed class InfoUIController : UIController, IOnStateExited<GameplayStat
     [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
     [Dependency] private readonly INetManager _netManager = default!;
     [Dependency] private readonly IPrototypeManager _prototype = default!;
-    [Dependency] private readonly ILogManager _logMan = default!;
 
     private RulesPopup? _rulesPopup;
     private RulesAndInfoWindow? _infoWindow;
-    private ISawmill _sawmill = default!;
 
     [ValidatePrototypeId<GuideEntryPrototype>]
     private const string DefaultRuleset = "DefaultRuleset";
 
     public ProtoId<GuideEntryPrototype> RulesEntryId = DefaultRuleset;
 
+    protected override string SawmillName => "rules";
+
     public override void Initialize()
     {
         base.Initialize();
 
-        _sawmill = _logMan.GetSawmill("rules");
         _netManager.RegisterNetMessage<RulesAcceptedMessage>();
         _netManager.RegisterNetMessage<SendRulesInformationMessage>(OnRulesInformationMessage);
 
@@ -94,7 +93,7 @@ public sealed class InfoUIController : UIController, IOnStateExited<GameplayStat
         if (!_prototype.TryIndex(RulesEntryId, out var guideEntryPrototype))
         {
             guideEntryPrototype = _prototype.Index<GuideEntryPrototype>(DefaultRuleset);
-            _sawmill.Error($"Couldn't find the following prototype: {RulesEntryId}. Falling back to {DefaultRuleset}, please check that the server has the rules set up correctly");
+            Log.Error($"Couldn't find the following prototype: {RulesEntryId}. Falling back to {DefaultRuleset}, please check that the server has the rules set up correctly");
             return guideEntryPrototype;
         }
 

Content.Client/UserInterface/Systems/Inventory/InventoryUIController.cs

@@ -243,7 +243,7 @@ public sealed class InventoryUIController : UIController, IOnStateEntered<Gamepl
     {
         if (_inventoryHotbar == null)
         {
-            Logger.Warning("Tried to toggle inventory bar when none are assigned");
+            Log.Warning("Tried to toggle inventory bar when none are assigned");
             return;
         }
 

Content.Client/UserInterface/Systems/Viewport/ViewportUIController.cs

@@ -102,6 +102,6 @@ public sealed class ViewportUIController : UIController
 
         // Currently, this shouldn't happen. This likely happened because the main eye was set to null. When this
         // does happen it can create hard to troubleshoot bugs, so lets print some helpful warnings:
-        Logger.Warning($"Main viewport's eye is in nullspace (main eye is null?). Attached entity: {_entMan.ToPrettyString(ent.Value)}. Entity has eye comp: {eye != null}");
+        Log.Warning($"Main viewport's eye is in nullspace (main eye is null?). Attached entity: {_entMan.ToPrettyString(ent.Value)}. Entity has eye comp: {eye != null}");
     }
 }

Content.Client/Weapons/Melee/MeleeSpreadCommand.cs

@@ -3,39 +3,33 @@ using Robust.Client.Graphics;
 using Robust.Client.Input;
 using Robust.Client.Player;
 using Robust.Shared.Console;
-using Robust.Shared.Map;
 
 namespace Content.Client.Weapons.Melee;
 
-
-public sealed class MeleeSpreadCommand : IConsoleCommand
+public sealed class MeleeSpreadCommand : LocalizedEntityCommands
 {
-    public string Command => "showmeleespread";
-    public string Description => "Shows the current weapon's range and arc for debugging";
-    public string Help => $"{Command}";
-    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IInputManager _inputManager = default!;
+    [Dependency] private readonly IOverlayManager _overlay = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly MeleeWeaponSystem _meleeSystem = default!;
+    [Dependency] private readonly SharedCombatModeSystem _combatSystem = default!;
+    [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
+
+    public override string Command => "showmeleespread";
+
+    public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        var collection = IoCManager.Instance;
-
-        if (collection == null)
+        if (_overlay.RemoveOverlay<MeleeArcOverlay>())
             return;
 
-        var overlayManager = collection.Resolve<IOverlayManager>();
-
-        if (overlayManager.RemoveOverlay<MeleeArcOverlay>())
-        {
-            return;
-        }
-
-        var sysManager = collection.Resolve<IEntitySystemManager>();
-
-        overlayManager.AddOverlay(new MeleeArcOverlay(
-            collection.Resolve<IEntityManager>(),
-            collection.Resolve<IEyeManager>(),
-            collection.Resolve<IInputManager>(),
-            collection.Resolve<IPlayerManager>(),
-            sysManager.GetEntitySystem<MeleeWeaponSystem>(),
-            sysManager.GetEntitySystem<SharedCombatModeSystem>(),
-            sysManager.GetEntitySystem<SharedTransformSystem>()));
+        _overlay.AddOverlay(new MeleeArcOverlay(
+            EntityManager,
+            _eyeManager,
+            _inputManager,
+            _playerManager,
+            _meleeSystem,
+            _combatSystem,
+            _transformSystem));
     }
 }

Content.IntegrationTests/Tests/Access/AccessReaderTest.cs

@@ -1,9 +1,9 @@
 using System.Collections.Generic;
-using System.Linq;
 using Content.Shared.Access;
 using Content.Shared.Access.Components;
 using Content.Shared.Access.Systems;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
 
 namespace Content.IntegrationTests.Tests.Access
@@ -12,6 +12,15 @@ namespace Content.IntegrationTests.Tests.Access
     [TestOf(typeof(AccessReaderComponent))]
     public sealed class AccessReaderTest
     {
+        [TestPrototypes]
+        private const string Prototypes = @"
+- type: entity
+  id: TestAccessReader
+  name: access reader
+  components:
+  - type: AccessReader
+";
+
         [Test]
         public async Task TestTags()
         {
@@ -19,13 +28,13 @@ namespace Content.IntegrationTests.Tests.Access
             var server = pair.Server;
             var entityManager = server.ResolveDependency<IEntityManager>();
 
-
             await server.WaitAssertion(() =>
             {
                 var system = entityManager.System<AccessReaderSystem>();
+                var ent = entityManager.SpawnEntity("TestAccessReader", MapCoordinates.Nullspace);
+                var reader = new Entity<AccessReaderComponent>(ent, entityManager.GetComponent<AccessReaderComponent>(ent));
 
                 // test empty
-                var reader = new AccessReaderComponent();
                 Assert.Multiple(() =>
                 {
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "Foo" }, reader), Is.True);
@@ -34,8 +43,7 @@ namespace Content.IntegrationTests.Tests.Access
                 });
 
                 // test deny
-                reader = new AccessReaderComponent();
-                reader.DenyTags.Add("A");
+                system.AddDenyTag(reader, "A");
                 Assert.Multiple(() =>
                 {
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "Foo" }, reader), Is.True);
@@ -43,10 +51,10 @@ namespace Content.IntegrationTests.Tests.Access
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A", "Foo" }, reader), Is.False);
                     Assert.That(system.AreAccessTagsAllowed(Array.Empty<ProtoId<AccessLevelPrototype>>(), reader), Is.True);
                 });
+                system.ClearDenyTags(reader);
 
                 // test one list
-                reader = new AccessReaderComponent();
-                reader.AccessLists.Add(new HashSet<ProtoId<AccessLevelPrototype>> { "A" });
+                system.AddAccess(reader, "A");
                 Assert.Multiple(() =>
                 {
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A" }, reader), Is.True);
@@ -54,10 +62,10 @@ namespace Content.IntegrationTests.Tests.Access
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A", "B" }, reader), Is.True);
                     Assert.That(system.AreAccessTagsAllowed(Array.Empty<ProtoId<AccessLevelPrototype>>(), reader), Is.False);
                 });
+                system.ClearAccesses(reader);
 
                 // test one list - two items
-                reader = new AccessReaderComponent();
-                reader.AccessLists.Add(new HashSet<ProtoId<AccessLevelPrototype>> { "A", "B" });
+                system.AddAccess(reader, new HashSet<ProtoId<AccessLevelPrototype>> { "A", "B" });
                 Assert.Multiple(() =>
                 {
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A" }, reader), Is.False);
@@ -65,11 +73,14 @@ namespace Content.IntegrationTests.Tests.Access
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A", "B" }, reader), Is.True);
                     Assert.That(system.AreAccessTagsAllowed(Array.Empty<ProtoId<AccessLevelPrototype>>(), reader), Is.False);
                 });
+                system.ClearAccesses(reader);
 
                 // test two list
-                reader = new AccessReaderComponent();
-                reader.AccessLists.Add(new HashSet<ProtoId<AccessLevelPrototype>> { "A" });
-                reader.AccessLists.Add(new HashSet<ProtoId<AccessLevelPrototype>> { "B", "C" });
+                var accesses = new List<HashSet<ProtoId<AccessLevelPrototype>>>() {
+                    new HashSet<ProtoId<AccessLevelPrototype>> () { "A" },
+                    new HashSet<ProtoId<AccessLevelPrototype>> () { "B", "C" }
+                };
+                system.AddAccesses(reader, accesses);
                 Assert.Multiple(() =>
                 {
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A" }, reader), Is.True);
@@ -79,11 +90,11 @@ namespace Content.IntegrationTests.Tests.Access
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "C", "B", "A" }, reader), Is.True);
                     Assert.That(system.AreAccessTagsAllowed(Array.Empty<ProtoId<AccessLevelPrototype>>(), reader), Is.False);
                 });
+                system.ClearAccesses(reader);
 
                 // test deny list
-                reader = new AccessReaderComponent();
-                reader.AccessLists.Add(new HashSet<ProtoId<AccessLevelPrototype>> { "A" });
-                reader.DenyTags.Add("B");
+                system.AddAccess(reader, new HashSet<ProtoId<AccessLevelPrototype>> { "A" });
+                system.AddDenyTag(reader, "B");
                 Assert.Multiple(() =>
                 {
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A" }, reader), Is.True);
@@ -91,6 +102,8 @@ namespace Content.IntegrationTests.Tests.Access
                     Assert.That(system.AreAccessTagsAllowed(new List<ProtoId<AccessLevelPrototype>> { "A", "B" }, reader), Is.False);
                     Assert.That(system.AreAccessTagsAllowed(Array.Empty<ProtoId<AccessLevelPrototype>>(), reader), Is.False);
                 });
+                system.ClearAccesses(reader);
+                system.ClearDenyTags(reader);
             });
             await pair.CleanReturnAsync();
         }

Content.IntegrationTests/Tests/Actions/ActionsAddedTest.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using Content.Shared.Actions;
+using Content.Shared.Actions.Components;
 using Content.Shared.CombatMode;
 using Robust.Server.Player;
 using Robust.Shared.GameObjects;
@@ -46,24 +47,26 @@ public sealed class ActionsAddedTest
         // This action should have a non-null event both on the server & client.
         var evType = typeof(ToggleCombatActionEvent);
 
+        var sQuery = sEntMan.GetEntityQuery<InstantActionComponent>();
+        var cQuery = cEntMan.GetEntityQuery<InstantActionComponent>();
         var sActions = sActionSystem.GetActions(serverEnt).Where(
-            x => x.Comp is InstantActionComponent act && act.Event?.GetType() == evType).ToArray();
+            ent => sQuery.CompOrNull(ent)?.Event?.GetType() == evType).ToArray();
         var cActions = cActionSystem.GetActions(clientEnt).Where(
-            x => x.Comp is InstantActionComponent act && act.Event?.GetType() == evType).ToArray();
+            ent => cQuery.CompOrNull(ent)?.Event?.GetType() == evType).ToArray();
 
         Assert.That(sActions.Length, Is.EqualTo(1));
         Assert.That(cActions.Length, Is.EqualTo(1));
 
-        var sAct = sActions[0].Comp;
-        var cAct = cActions[0].Comp;
+        var sAct = sActions[0];
+        var cAct = cActions[0];
 
-        Assert.That(sAct, Is.Not.Null);
-        Assert.That(cAct, Is.Not.Null);
+        Assert.That(sAct.Comp, Is.Not.Null);
+        Assert.That(cAct.Comp, Is.Not.Null);
 
         // Finally, these two actions are not the same object
         // required, because integration tests do not respect the [NonSerialized] attribute and will simply events by reference.
-        Assert.That(ReferenceEquals(sAct, cAct), Is.False);
-        Assert.That(ReferenceEquals(sAct.BaseEvent, cAct.BaseEvent), Is.False);
+        Assert.That(ReferenceEquals(sAct.Comp, cAct.Comp), Is.False);
+        Assert.That(ReferenceEquals(sQuery.GetComponent(sAct).Event, cQuery.GetComponent(cAct).Event), Is.False);
 
         await pair.CleanReturnAsync();
     }

Content.IntegrationTests/Tests/Chameleon/ChameleonJobLoadoutTest.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Text;
+using Content.Client.Implants;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Clothing;
+using Content.Shared.Implants;
+using Content.Shared.Preferences.Loadouts;
+using Content.Shared.Roles;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Chameleon;
+
+/// <summary>
+/// Ensures all round <see cref="IsProbablyRoundStartJob">"round start jobs"</see> have an associated chameleon loadout.
+/// </summary>
+public sealed class ChameleonJobLoadoutTest : InteractionTest
+{
+    private readonly List<ProtoId<JobPrototype>> JobBlacklist =
+    [
+
+    ];
+
+    [Test]
+    public async Task CheckAllJobs()
+    {
+        var alljobs = ProtoMan.EnumeratePrototypes<JobPrototype>();
+
+        // Job -> number of references
+        Dictionary<ProtoId<JobPrototype>, int> validJobs = new();
+
+        // Only add stuff that actually has clothing! We don't want stuff like AI or borgs.
+        foreach (var job in alljobs)
+        {
+            if (!IsProbablyRoundStartJob(job) || JobBlacklist.Contains(job.ID))
+                continue;
+
+            validJobs.Add(job.ID, 0);
+        }
+
+        var chameleons = ProtoMan.EnumeratePrototypes<ChameleonOutfitPrototype>();
+
+        foreach (var chameleon in chameleons)
+        {
+            if (chameleon.Job == null || !validJobs.ContainsKey(chameleon.Job.Value))
+                continue;
+
+            validJobs[chameleon.Job.Value] += 1;
+        }
+
+        var errorMessage = new StringBuilder();
+        errorMessage.AppendLine("The following job(s) have no chameleon prototype(s):");
+        var invalid = false;
+
+        // All round start jobs have a chameleon loadout
+        foreach (var job in validJobs)
+        {
+            if (job.Value != 0)
+                continue;
+
+            errorMessage.AppendLine(job.Key + " has no chameleonOutfit prototype.");
+            invalid = true;
+        }
+
+        if (!invalid)
+            return;
+
+        Assert.Fail(errorMessage.ToString());
+    }
+
+    /// <summary>
+    /// Best guess at what a "round start" job is.
+    /// </summary>
+    private bool IsProbablyRoundStartJob(JobPrototype job)
+    {
+        return job.StartingGear != null && ProtoMan.HasIndex<RoleLoadoutPrototype>(LoadoutSystem.GetJobPrototype(job.ID));
+    }
+
+}

Content.IntegrationTests/Tests/Construction/Interaction/MachineConstruction.cs

@@ -18,7 +18,7 @@ public sealed class MachineConstruction : InteractionTest
         ClientAssertPrototype(Unfinished, Target);
         await Interact(Wrench, Cable);
         AssertPrototype(MachineFrame);
-        await Interact(ProtolatheBoard, Bin1, Bin1, Manipulator1, Manipulator1, Beaker, Beaker, Screw);
+        await Interact(ProtolatheBoard, Manipulator1, Manipulator1, Manipulator1, Manipulator1, Beaker, Beaker, Screw);
         AssertPrototype(Protolathe);
     }
 
@@ -36,8 +36,7 @@ public sealed class MachineConstruction : InteractionTest
             (Steel, 5),
             (Cable, 1),
             (Beaker, 2),
-            (Manipulator1, 2),
-            (Bin1, 2),
+            (Manipulator1, 4),
             (ProtolatheBoard, 1));
     }
 
@@ -52,7 +51,7 @@ public sealed class MachineConstruction : InteractionTest
         // Change it into an autolathe
         await InteractUsing("AutolatheMachineCircuitboard");
         AssertPrototype(MachineFrame);
-        await Interact(Bin1, Bin1, Bin1, Manipulator1, Glass, Screw);
+        await Interact(Manipulator1, Manipulator1, Manipulator1, Manipulator1, Glass, Screw);
         AssertPrototype("Autolathe");
     }
 }

Content.IntegrationTests/Tests/Fluids/AbsorbentTest.cs

@@ -33,6 +33,7 @@ public sealed class AbsorbentTest
   id: {AbsorbentDummyId}
   components:
   - type: Absorbent
+    useAbsorberSolution: true
   - type: SolutionContainerManager
     solutions:
       absorbed:
@@ -94,7 +95,7 @@ public sealed class AbsorbentTest
             refillable = entityManager.SpawnEntity(RefillableDummyId, coordinates);
 
             entityManager.TryGetComponent(absorbent, out component);
-            solutionContainerSystem.TryGetSolution(absorbent, AbsorbentComponent.SolutionName, out var absorbentSoln, out var absorbentSolution);
+            solutionContainerSystem.TryGetSolution(absorbent, component.SolutionName, out var absorbentSoln, out var absorbentSolution);
             solutionContainerSystem.TryGetRefillableSolution(refillable, out var refillableSoln, out var refillableSolution);
 
             // Arrange
@@ -152,7 +153,7 @@ public sealed class AbsorbentTest
             refillable = entityManager.SpawnEntity(SmallRefillableDummyId, coordinates);
 
             entityManager.TryGetComponent(absorbent, out component);
-            solutionContainerSystem.TryGetSolution(absorbent, AbsorbentComponent.SolutionName, out var absorbentSoln, out var absorbentSolution);
+            solutionContainerSystem.TryGetSolution(absorbent, component.SolutionName, out var absorbentSoln, out var absorbentSolution);
             solutionContainerSystem.TryGetRefillableSolution(refillable, out var refillableSoln, out var refillableSolution);
 
             // Arrange

Content.IntegrationTests/Tests/Interaction/InteractionTest.Constants.cs

@@ -29,8 +29,6 @@ public abstract partial class InteractionTest
     protected const string Rod = "MetalRod";
 
     // Parts
-    protected const string Bin1 = "MatterBinStockPart";
-    protected const string Cap1 = "CapacitorStockPart";
     protected const string Manipulator1 = "MicroManipulatorStockPart";
     protected const string Battery1 = "PowerCellSmall";
     protected const string Battery4 = "PowerCellHyper";

Content.IntegrationTests/Tests/Interaction/InteractionTest.Helpers.cs

@@ -791,7 +791,7 @@ public abstract partial class InteractionTest
             gridUid = gridEnt;
             gridComp = gridEnt.Comp;
             var gridXform = SEntMan.GetComponent<TransformComponent>(gridUid);
-            Transform.SetWorldPosition(gridXform, pos.Position);
+            Transform.SetWorldPosition((gridUid, gridXform), pos.Position);
             MapSystem.SetTile((gridUid, gridComp), SEntMan.GetCoordinates(coords ?? TargetCoords), tile);
 
             if (!MapMan.TryFindGridAt(pos, out _, out _))

Content.IntegrationTests/Tests/Power/StationPowerTests.cs

@@ -0,0 +1,105 @@
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.GameTicking;
+using Content.Server.Maps;
+using Content.Server.Power.Components;
+using Content.Server.Power.NodeGroups;
+using Content.Server.Power.Pow3r;
+using Content.Shared.NodeContainer;
+using Robust.Shared.EntitySerialization;
+
+namespace Content.IntegrationTests.Tests.Power;
+
+[Explicit]
+public sealed class StationPowerTests
+{
+    /// <summary>
+    /// How long the station should be able to survive on stored power if nothing is changed from round start.
+    /// </summary>
+    private const float MinimumPowerDurationSeconds = 10 * 60;
+
+    private static readonly string[] GameMaps =
+    [
+        "Fland",
+        "Meta",
+        "Packed",
+        "Omega",
+        "Bagel",
+        "Box",
+        "Core",
+        "Marathon",
+        "Saltern",
+        "Reach",
+        "Train",
+        "Oasis",
+        "Gate",
+        "Amber",
+        "Loop",
+        "Plasma",
+        "Elkridge",
+        "Convex",
+        "Relic",
+    ];
+
+    [Test, TestCaseSource(nameof(GameMaps))]
+    public async Task TestStationStartingPowerWindow(string mapProtoId)
+    {
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings
+        {
+            Dirty = true,
+        });
+        var server = pair.Server;
+
+        var entMan = server.EntMan;
+        var protoMan = server.ProtoMan;
+        var ticker = entMan.System<GameTicker>();
+
+        // Load the map
+        await server.WaitAssertion(() =>
+        {
+            Assert.That(protoMan.TryIndex<GameMapPrototype>(mapProtoId, out var mapProto));
+            var opts = DeserializationOptions.Default with { InitializeMaps = true };
+            ticker.LoadGameMap(mapProto, out var mapId, opts);
+        });
+
+        // Let powernet set up
+        await server.WaitRunTicks(1);
+
+        // Find the power network with the greatest stored charge in its batteries.
+        // This keeps backup SMESes out of the calculation.
+        var networks = new Dictionary<PowerState.Network, float>();
+        var batteryQuery = entMan.EntityQueryEnumerator<PowerNetworkBatteryComponent, BatteryComponent, NodeContainerComponent>();
+        while (batteryQuery.MoveNext(out var uid, out _, out var battery, out var nodeContainer))
+        {
+            if (!nodeContainer.Nodes.TryGetValue("output", out var node))
+                continue;
+            if (node.NodeGroup is not IBasePowerNet group)
+                continue;
+            networks.TryGetValue(group.NetworkNode, out var charge);
+            networks[group.NetworkNode] = charge + battery.CurrentCharge;
+        }
+        var totalStartingCharge = networks.MaxBy(n => n.Value).Value;
+
+        // Find how much charge all the APC-connected devices would like to use per second.
+        var totalAPCLoad = 0f;
+        var receiverQuery = entMan.EntityQueryEnumerator<ApcPowerReceiverComponent>();
+        while (receiverQuery.MoveNext(out _, out var receiver))
+        {
+            totalAPCLoad += receiver.Load;
+        }
+
+        var estimatedDuration = totalStartingCharge / totalAPCLoad;
+        var requiredStoredPower = totalAPCLoad * MinimumPowerDurationSeconds;
+        Assert.Multiple(() =>
+        {
+            Assert.That(estimatedDuration, Is.GreaterThanOrEqualTo(MinimumPowerDurationSeconds),
+                $"Initial power for {mapProtoId} does not last long enough! Needs at least {MinimumPowerDurationSeconds}s " +
+                $"but estimated to last only {estimatedDuration}s!");
+            Assert.That(totalStartingCharge, Is.GreaterThanOrEqualTo(requiredStoredPower),
+                $"Needs at least {requiredStoredPower - totalStartingCharge} more stored power!");
+        });
+
+
+        await pair.CleanReturnAsync();
+    }
+}

Content.Packaging/ServerPackaging.cs

@@ -51,6 +51,7 @@ public static class ServerPackaging
         // Python script had Npgsql. though we want Npgsql.dll as well soooo
         "Npgsql",
         "Microsoft",
+        "Discord",
     };
 
     private static readonly List<string> ServerNotExtraAssemblies = new()

Content.Server/Access/AccessWireAction.cs

@@ -1,6 +1,7 @@
 using Content.Server.Wires;
 using Content.Shared.Access;
 using Content.Shared.Access.Components;
+using Content.Shared.Access.Systems;
 using Content.Shared.Wires;
 
 namespace Content.Server.Access;
@@ -23,23 +24,21 @@ public sealed partial class AccessWireAction : ComponentWireAction<AccessReaderC
     public override bool Cut(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
         WiresSystem.TryCancelWireAction(wire.Owner, PulseTimeoutKey.Key);
-        comp.Enabled = false;
-        EntityManager.Dirty(wire.Owner, comp);
+        EntityManager.System<AccessReaderSystem>().SetActive((wire.Owner, comp), false);
+
         return true;
     }
 
     public override bool Mend(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
-        comp.Enabled = true;
-        EntityManager.Dirty(wire.Owner, comp);
+        EntityManager.System<AccessReaderSystem>().SetActive((wire.Owner, comp), true);
 
         return true;
     }
 
     public override void Pulse(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
-        comp.Enabled = false;
-        EntityManager.Dirty(wire.Owner, comp);
+        EntityManager.System<AccessReaderSystem>().SetActive((wire.Owner, comp), false);
         WiresSystem.StartWireAction(wire.Owner, _pulseTimeout, PulseTimeoutKey.Key, new TimedWireEvent(AwaitPulseCancel, wire));
     }
 
@@ -57,8 +56,7 @@ public sealed partial class AccessWireAction : ComponentWireAction<AccessReaderC
         {
             if (EntityManager.TryGetComponent<AccessReaderComponent>(wire.Owner, out var access))
             {
-                access.Enabled = true;
-                EntityManager.Dirty(wire.Owner, access);
+                EntityManager.System<AccessReaderSystem>().SetActive((wire.Owner, access), true);
             }
         }
     }

Content.Server/Access/AddAccessLogCommand.cs

@@ -1,8 +1,8 @@
 using Content.Server.Administration;
 using Content.Shared.Access.Components;
+using Content.Shared.Access.Systems;
 using Content.Shared.Administration;
 using Robust.Shared.Toolshed;
-using Robust.Shared.Toolshed.Syntax;
 
 namespace Content.Server.Access;
 
@@ -19,7 +19,7 @@ public sealed class AddAccessLogCommand : ToolshedCommand
             ctx.WriteLine($"WARNING: Surpassing the limit of the log by {accessLogCount - accessReader.AccessLogLimit+1} entries!");
 
         var accessTime = TimeSpan.FromSeconds(seconds);
-        accessReader.AccessLog.Enqueue(new AccessRecord(accessTime, accessor));
+        EntityManager.System<AccessReaderSystem>().LogAccess((input, accessReader), accessor, accessTime, true);
         ctx.WriteLine($"Successfully added access log to {input} with this information inside:\n " +
                       $"Time of access: {accessTime}\n " +
                       $"Accessed by: {accessor}");

Content.Server/Access/LogWireAction.cs

@@ -37,21 +37,21 @@ public sealed partial class LogWireAction : ComponentWireAction<AccessReaderComp
     public override bool Cut(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
         WiresSystem.TryCancelWireAction(wire.Owner, PulseTimeoutKey.Key);
-        comp.LoggingDisabled = true;
-        EntityManager.Dirty(wire.Owner, comp);
+        EntityManager.System<AccessReaderSystem>().SetLoggingActive((wire.Owner, comp), false);
+
         return true;
     }
 
     public override bool Mend(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
-        comp.LoggingDisabled = false;
+        EntityManager.System<AccessReaderSystem>().SetLoggingActive((wire.Owner, comp), true);
         return true;
     }
 
     public override void Pulse(EntityUid user, Wire wire, AccessReaderComponent comp)
     {
         _access.LogAccess((wire.Owner, comp), Loc.GetString(PulseLog));
-        comp.LoggingDisabled = true;
+        EntityManager.System<AccessReaderSystem>().SetLoggingActive((wire.Owner, comp), false);
         WiresSystem.StartWireAction(wire.Owner, PulseTimeout, PulseTimeoutKey.Key, new TimedWireEvent(AwaitPulseCancel, wire));
     }
 
@@ -64,7 +64,7 @@ public sealed partial class LogWireAction : ComponentWireAction<AccessReaderComp
     private void AwaitPulseCancel(Wire wire)
     {
         if (!wire.IsCut && EntityManager.TryGetComponent<AccessReaderComponent>(wire.Owner, out var comp))
-            comp.LoggingDisabled = false;
+            EntityManager.System<AccessReaderSystem>().SetLoggingActive((wire.Owner, comp), true);
     }
 
     private enum PulseTimeoutKey : byte

Content.Server/Access/Systems/AccessOverriderSystem.cs

@@ -168,21 +168,6 @@ public sealed class AccessOverriderSystem : SharedAccessOverriderSystem
         return accessList;
     }
 
-    private List<HashSet<ProtoId<AccessLevelPrototype>>> ConvertAccessListToHashSet(List<ProtoId<AccessLevelPrototype>> accessList)
-    {
-        List<HashSet<ProtoId<AccessLevelPrototype>>> accessHashsets = new List<HashSet<ProtoId<AccessLevelPrototype>>>();
-
-        if (accessList != null && accessList.Any())
-        {
-            foreach (ProtoId<AccessLevelPrototype> access in accessList)
-            {
-                accessHashsets.Add(new HashSet<ProtoId<AccessLevelPrototype>>() { access });
-            }
-        }
-
-        return accessHashsets;
-    }
-
     /// <summary>
     /// Called whenever an access button is pressed, adding or removing that access requirement from the target access reader.
     /// </summary>
@@ -244,12 +229,10 @@ public sealed class AccessOverriderSystem : SharedAccessOverriderSystem
         _adminLogger.Add(LogType.Action, LogImpact.High,
             $"{ToPrettyString(player):player} has modified {ToPrettyString(accessReaderEnt.Value):entity} with the following allowed access level holders: [{string.Join(", ", addedTags.Union(removedTags))}] [{string.Join(", ", newAccessList)}]");
 
-        accessReaderEnt.Value.Comp.AccessLists = ConvertAccessListToHashSet(newAccessList);
+        _accessReader.SetAccesses(accessReaderEnt.Value, newAccessList);
 
         var ev = new OnAccessOverriderAccessUpdatedEvent(player);
         RaiseLocalEvent(component.TargetAccessReaderId, ref ev);
-
-        Dirty(accessReaderEnt.Value);
     }
 
     /// <summary>

Content.Server/Access/Systems/AgentIDCardSystem.cs

@@ -9,6 +9,11 @@ using Robust.Server.GameObjects;
 using Robust.Shared.Prototypes;
 using Content.Shared.Roles;
 using System.Diagnostics.CodeAnalysis;
+using Content.Server.Clothing.Systems;
+using Content.Server.Implants;
+using Content.Shared.Implants;
+using Content.Shared.Inventory;
+using Content.Shared.PDA;
 
 namespace Content.Server.Access.Systems
 {
@@ -18,6 +23,8 @@ namespace Content.Server.Access.Systems
         [Dependency] private readonly IdCardSystem _cardSystem = default!;
         [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly ChameleonClothingSystem _chameleon = default!;
+        [Dependency] private readonly ChameleonControllerSystem _chamController = default!;
 
         public override void Initialize()
         {
@@ -28,6 +35,46 @@ namespace Content.Server.Access.Systems
             SubscribeLocalEvent<AgentIDCardComponent, AgentIDCardNameChangedMessage>(OnNameChanged);
             SubscribeLocalEvent<AgentIDCardComponent, AgentIDCardJobChangedMessage>(OnJobChanged);
             SubscribeLocalEvent<AgentIDCardComponent, AgentIDCardJobIconChangedMessage>(OnJobIconChanged);
+            SubscribeLocalEvent<AgentIDCardComponent, InventoryRelayedEvent<ChameleonControllerOutfitSelectedEvent>>(OnChameleonControllerOutfitChangedItem);
+        }
+
+        private void OnChameleonControllerOutfitChangedItem(Entity<AgentIDCardComponent> ent, ref InventoryRelayedEvent<ChameleonControllerOutfitSelectedEvent> args)
+        {
+            if (!TryComp<IdCardComponent>(ent, out var idCardComp))
+                return;
+
+            _prototypeManager.TryIndex(args.Args.ChameleonOutfit.Job, out var jobProto);
+
+            var jobIcon = args.Args.ChameleonOutfit.Icon ?? jobProto?.Icon;
+            var jobName = args.Args.ChameleonOutfit.Name ?? jobProto?.Name ?? "";
+
+            if (jobIcon != null)
+                _cardSystem.TryChangeJobIcon(ent, _prototypeManager.Index(jobIcon.Value), idCardComp);
+
+            if (jobName != "")
+                _cardSystem.TryChangeJobTitle(ent, Loc.GetString(jobName), idCardComp);
+
+            // If you have forced departments use those over the jobs actual departments.
+            if (args.Args.ChameleonOutfit?.Departments?.Count > 0)
+                _cardSystem.TryChangeJobDepartment(ent, args.Args.ChameleonOutfit.Departments, idCardComp);
+            else if (jobProto != null)
+                _cardSystem.TryChangeJobDepartment(ent, jobProto, idCardComp);
+
+            // Ensure that you chameleon IDs in PDAs correctly. Yes this is sus...
+
+            // There is one weird interaction: If the job / icon don't match the PDAs job the chameleon will be updated
+            // to the PDAs IDs sprite but the icon and job title will not match. There isn't a way to get around this
+            // really as there is no tie between job -> pda or pda -> job.
+
+            var idSlotGear = _chamController.GetGearForSlot(args, "id");
+            if (idSlotGear == null)
+                return;
+
+            var proto = _prototypeManager.Index(idSlotGear);
+            if (!proto.TryGetComponent<PdaComponent>(out var comp, EntityManager.ComponentFactory))
+                return;
+
+            _chameleon.SetSelectedPrototype(ent, comp.IdCard);
         }
 
         private void OnAfterInteract(EntityUid uid, AgentIDCardComponent component, AfterInteractEvent args)